static关键字- final关键字- 代码块- 内部类- 枚举

目录

static关键字

final关键字

代码块

内部类

枚举

static关键字

翻译：static：静态的

注意事项：

1. static修饰的成员只能跟类有关系，类被加载的时候，static修饰的成员就放入了内存中，即static修饰的方法只能够调用类变量

2. static能修饰哪些变量

   1）、成员变量 （不能修饰局部变量）

   2）、修饰非抽象的方法

3. 成员变量加static和不加static的区别？

• 名称不一样

• 存储位置不一样

• 一个是全局一个是局部

• 加载的顺序也不一样static跟类一起率先加载

使用时机：

1）、所有成员需要共享一个数据的时候，声明成员变量就需要加static

2）、static修饰的成员变量只能够用public修饰，没有static修饰的都需要用private

1. static修饰方法

1）、static修饰的方法是类方法

2）、没有static修饰的方法是实例方法

final关键字

翻译：最终的

特点：final修饰的成员不能被更改

1. final修饰类：意味着该类不能被继承，任何试图继承 final类的尝试都会导致编译时错误。

final class FinalClass {
    // class implementation
}

1. final修饰方法：如果一个方法被声明为 final，则意味着该方法不能被子类重写。子类无法改变或覆盖 final 方法的实现。

class BaseClass {
    final void finalMethod() {
        // method implementation 方法实现
    }
}
​
class DerivedClass extends BaseClass {
    // Error: Cannot override the final method from BaseClass  方法不能被重写
    // void finalMethod() { /* overridden implementation */ }
}

1. final修饰变量：如果一个变量被声明为 final，则意味着该变量只能被赋值一次。一旦赋值后，就无法再次修改它的值。

class Example {
    final int constantValue = 10;
​
    void modifyValue() {
        // Error: The final field constantValue cannot be assigned
        // constantValue = 20;
    }
}

作用：final 修饰的成员无法被改变的特性是为了强调其不可变性或者不可重写性，从而提高代码的可靠性和安全性。

代码块

概念：{ }包含起来的就是代码块

类型：

1. 构造代码块：在调用构造方法之前就要执行的代码，每调用一次构造方法就会被执行一次，在方法外

{ }

    2.静态代码块：只有第一次调用构造方法的时候执行一次，后面就不会执行了，通常用于静态字段的赋值

static{ }

   3.构造方法：

public CodeDemo() {
        System.out.println("无参构造");
}

执行顺序：1.静态代码块（只执行一次） 2. 构造代码块 3.构造方法

内部类

概念：设计在一个类内部的类就是内部类

1. 成员内部类：成员内部类与外部类关联较为密切，可以访问外部类的成员变量和方法，能修饰成员内部了关键字

public class OuterClass {
    private int outerField;
​
    public class InnerClass {
        private int innerField;
​
        public void innerMethod() {
            outerField = 10; // 访问外部类的成员变量
        }
    }
}

    2.静态内部类：静态内部类是静态的，与外部类的实例无关，可以直接通过外部类的类名访问。

public class OuterClass {
    private static int staticOuterField;
​
    public static class StaticNestedClass {
        private int staticNestedField;
        
        public void staticNestedMethod() {
            staticOuterField = 20; // 访问外部类的静态成员变量
        }
    }
}

   3.局部内部类：设计在一个方法里面内部类就是局部内部类，局部内部类定义在一个方法或作用域内，其作用范围被限制在方法内。

public class Outer {
    String name;
    static int age;
    public static final int SCORE = 100;
  class Inner { // 内部类，只让Outer类使用Inner这个类
        // 内部类的字节码文件的名字：外部类的类名$内部类的名字.class
        public  void mm() {
            System.out.println(age);
            System.out.println(SCORE);
        }
    }
​
    public void m() {  // 这是一个方法
      int a = 10;
        class InnerOfMethod { // 局部内部类，放在方法里面
            public void mmm() {
                System.out.println(name); //   局部内部类访问了外面方法的变量后会将其变回常量
                System.out.println(age);
                System.out.println(SCORE);
                System.out.println(a);
            }
        }
    }
​
    public static void main(String[] args) {
        Outer out = new Outer();
        out.m(); 
    }
}

1. 匿名内部类：属于局部内部类，匿名内部类没有类名，通常用于创建接口和抽象类的实例。

作用：当我们需要创建抽象类或接口放入对象，而且这个对象只用一次，可以使用匿名内部来来简化创建中间子类的过程

public class AnonymousInnerClassDemo {
    public static void main(String[] args) {
    // 创建AbstractClass的对象，抽象类
      AbstractClass ac = new AbstractClass() {  // 这就是匿名内部类，可以直接创建抽象类的对象
          @Override
          public void test() {
              System.out.println("哦哟"); // 重写抽象类的方法
          }
          // JVM会在这个方法里面自动创建一个内部类
      };// 调用构造方法
    
      ac.test();
​
      new AbstractClass() {  // 也可以不用对象来接收
          @Override
          public void test() {
              System.out.println("哈哈");
          }
      }.test(); // 可以直接调用里面的方法
​
    // 创建接口对象
    ICrud iCrud = new ICrud() {  // 接口也是跟抽象类同样的道理
        @Override
        public void add() {
                System.out.println("添加数据的方法");
            }
        };
​
        iCrud.add();
    }
}

枚举

概念：是特殊的结构（特殊的类）

语法：public enum 枚举名{ }

注意：

1. 枚举是继承一个抽象类Enum

2. 枚举创建对象，直接写常量名

3. 内部的成员几乎和类一样

4. 构造方法的访问修饰符只能是private，不写默认是private

作用：当设计的类创建对象个数固定，那么就可以使用枚举来代替类