Java8 关键字 final，static

心已赠人 2023-07-25 09:46 10阅读 0赞

### 关键字 ###

*   *  一.final
     *   *  1. 数据
         *  2. 方法
         *  3. 类
     *  二.static
     *   *  1. 静态变量
         *  2. 静态方法
         *  3. 静态语句块
         *  4. 静态内部类
         *  5. 静态导包
         *  6. 初始化顺序

**本文全文摘抄自gihub[CyC2018/CS-Notes][CyC2018_CS-Notes]仅供本人学习记录使用**

## 一.final ##

### 1. 数据 ###

声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。

对于基本类型，final 使**数值不变**；  
对于引用类型，final 使**引用不变**，也就不能引用其它对象，但是被引用的对象本身是可以修改的。

final int x = 1;
    // x = 2; // cannot assign value to final variable 'x'
    final A y = new A();
    y.a = 1;

### 2. 方法 ###

声明**方法不能被子类重写**。

private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。

### 3. 类 ###

声明类不允许被继承。

## 二.static ##

### 1. 静态变量 ###

**静态变量**：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。  
**实例变量**：每创建一个实例就会产生一个实例变量，它与该实例同生共死。

public class A { 
    
        private int x;         // 实例变量
        private static int y;  // 静态变量
    
        public static void main(String[] args) { 
            // int x = A.x; // Non-static field 'x' cannot be referenced from a static context
            A a = new A();
            int x = a.x;
            int y = A.y;
        }
    }

### 2. 静态方法 ###

静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。

public abstract class A { 
        public static void func1(){ 
        }
        // public abstract static void func2(); // Illegal combination of modifiers: 'abstract' and 'static'
    }

**静态方法**只能访问所属类的**静态字段和静态方法**，方法中不能有 this 和 super 关键字，因此这两个关键字与具体对象关联。

public class A { 
    
        private static int x;
        private int y;
    
        public static void func1(){ 
            int a = x;
            // int b = y; // Non-static field 'y' cannot be referenced from a static context
            // int b = this.y; // 'A.this' cannot be referenced from a static context
        }
    }

### 3. 静态语句块 ###

静态语句块在**类初始化时运行一次**。

public class A { 
        static { 
            System.out.println("123");
        }
    
        public static void main(String[] args) { 
            A a1 = new A();
            A a2 = new A();
        }
    }

123  
这个123在spring工程启动的时候就打印了，而不是在创建实例的时候

### 4. 静态内部类 ###

非静态内部类依赖于外部类的实例，也就是说需要先创建外部类实例，才能用这个实例去创建非静态内部类。而静态内部类不需要。

public class OuterClass { 
    
        class InnerClass { 
        }
    
        static class StaticInnerClass { 
        }
    
        public static void main(String[] args) { 
            // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
            OuterClass outerClass = new OuterClass();
            InnerClass innerClass = outerClass.new InnerClass();
            StaticInnerClass staticInnerClass = new StaticInnerClass();
        }
    }

静态内部类不能访问外部类的非静态的变量和方法。

### 5. 静态导包 ###

在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。

import static com.xxx.ClassName.*

### 6. 初始化顺序 ###

静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。

public static String staticField = "静态变量";
    static { 
        System.out.println("静态语句块");
    }
    public String field = "实例变量";
    { 
        System.out.println("普通语句块");
    }
    最后才是构造函数的初始化。
    
    public InitialOrderTest() { 
        System.out.println("构造函数");
    }

存在继承的情况下，初始化顺序为：

父类（静态变量、静态语句块）  
子类（静态变量、静态语句块）  
父类（实例变量、普通语句块）  
父类（构造函数）  
子类（实例变量、普通语句块）  
子类（构造函数）

[CyC2018_CS-Notes]: https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20%E5%9F%BA%E7%A1%80.md