面试准备（五） java类的初始化和实例化

﹏ヽ暗。殇╰゛Y 2022-10-07 10:44 159阅读 0赞

### **首先要了解java中类的加载机制：** ###

类的加载机制网上有各种各样的讲解文章，其实通俗的概括就是

![20140105211344671][]

首先程序运行就会启动java虚拟机JVM。

1）Loading（载入）

JVM 在该阶段的主要目的是将字节码从不同的数据源（可能是 class 文件、也可能是 jar 包，甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的 `java.lang.Class` 对象。

2）Verification（验证）

JVM 会在该阶段对二进制字节流进行校验，只有符合 JVM 字节码规范的才能被 JVM 正确执行。该阶段是保证 JVM 安全的重要屏障，下面是一些主要的检查。

*  确保二进制字节流格式符合预期（比如说是否以 `cafe bene` 开头）。
 *  是否所有方法都遵守访问控制关键字的限定。
 *  方法调用的参数个数和类型是否正确。
 *  确保变量在使用之前被正确初始化了。
 *  检查变量是否被赋予恰当类型的值。、

3）Preparation（准备）

JVM 会在该阶段对类变量（也称为静态变量，`static` 关键字修饰的）分配内存并初始化（对应数据类型的默认初始值，如 0、0L、null、false 等）。

也就是说，假如有这样一段代码：

public String chenmo = "沉默";
    public static String wanger = "王二";
    public static final String cmower = "沉默王二";

chenmo 不会被分配内存，而 wanger 会；但 wanger 的初始值不是“王二”而是 `null`。

需要注意的是，`static final` 修饰的变量被称作为常量，和类变量不同。常量一旦赋值就不会改变了，所以 cmower 在准备阶段的值为“沉默王二”而不是 `null`。

4）Resolution（解析）

该阶段将常量池中的符号引用转化为直接引用。

what？符号引用，直接引用？

**符号引用**以一组符号（任何形式的字面量，只要在使用时能够无歧义的定位到目标即可）来描述所引用的目标。

在编译时，Java 类并不知道所引用的类的实际地址，因此只能使用符号引用来代替。比如 `com.Wanger` 类引用了 `com.Chenmo` 类，编译时 Wanger 类并不知道 Chenmo 类的实际内存地址，因此只能使用符号 `com.Chenmo`。

**直接引用**通过对符号引用进行解析，找到引用的实际内存地址。

5）Initialization（初始化）

该阶段是类加载过程的最后一步。在准备阶段，类变量已经被赋过默认初始值，而在初始化阶段，类变量将被赋值为代码期望赋的值。换句话说，初始化阶段是执行类构造器方法的过程。

### **在举例之前，先了解一下初始化顺序：** ###

![70][]

![70 1][]

### **举例：** ###

**首先有个Father类**

class Father {
        private int i = test();
        private static int j = method();
        static {
            System.out.println("(1)");
        }
        Father() {
            System.out.println("(2)");
        }
    
        {
            System.out.println("(3)");
        }
    
        public int test() {
            System.out.println("(4)");
            return 1;
        }
        public static int method() {
            System.out.println("(5)");
            return 1;
        }
    }

**其次有个Son类：**

class Son extends Father {
        private int i = test();
        private static int j = method();
        static {
            System.out.println("(6)");
        }
        Son() {
            System.out.println("(7)");
        }
        {
            System.out.println("(8)");
        }
        public int test() {
            System.out.println("(9)");
            return 1;
        }
    
        public static int method() {
            System.out.println("(10)");
            return 1;
        }
    }

**main函数：**

public static void main(String[] args) {
            Son son  = new Son();
            System.out.println();
            Son son1 = new Son();
        }

根据我们的执行顺序可以得出结果：

(5)  
(1)  
(10)  
(6)  
(9)  
(3)  
(2)  
(9)  
(8)  
(7)

(9)  
(3)  
(2)  
(9)  
(8)  
(7)

**这里有两个注意事项：**

**1、父类加载普通成员i=test()时，test调用的实际是子类重写的方法。所以是 9 **

**2、第二次初始化对象时，静态成员变量不会第二次被初始化。**

[20140105211344671]: /images/20221005/c1e4069e7c3d42f5a7cf45a2dba873ae.png
[70]: /images/20221005/7fb275d9e8d0461d8e18c859f50993e0.png
[70 1]: /images/20221005/d5f856dc2afc482399ea40dbd27833ae.png