# 类加载+双亲委派机制

## 一、类加载过程

**`JVM`把`class`文件加载到内存，并对数据进行验证、准备、解析、初始化，最终形成`JVM`可以直接使用的Java类型的过程。**

![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/01/28/kuangstudy40f79b0b-fdac-4e2c-9dd4-e55fb17f7d8a.png)

### 1.加载

![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/01/28/kuangstudy8c98d176-237a-47c1-827d-96ce75834e6e.png)

1. 将类的`.class`文件中的二进制数据读入到内存中；
 	2. 将数据转换成方法区的运行时数据（静态变量、静态代码块、常量池等）；
 	3. 在堆中生成一个`Class类对象`代表该类（反射），用该对象作为方法区类数据的访问入口。

### 2.链接

将Java类的二进制代码合并到JVM的运行状态之中。

- **验证**

确保class文件中字节流包含的信息符合`JVM`规范。主要包括四种：文件格式验证，元数据验证，字节码验证，符号引用验证

- **准备**

为类变量分配内存并设置类变量（被static修饰的变量，变量不是常量，所以不是final的，就是static的）初始值的阶段。这些内存都将在方法区中进行分配。

此时的设置初始值为默认值，具体赋值在初始化阶段完成。

注意：

1. <font color=red>如果变量被`final`修饰，则在编译时进行分配，准备阶段进行显示初始化</font>
  2. <font color='red'>不会为实例变量分配初始化，因为静态变量是存在于方法区中的，而实例变量会随着Java对象一起被分配到`java堆`中</font>

举例：

```java
  /*
   * 类变量age会在准备阶段过后为 其分配四个（int四个字节）字节的空间，并且设置初始值为0，而不是10。
   * 若是final的，则在编译期就会设置上最终值。
   */
  private static int age = 10;
  ```

- **解析**

将虚拟机常量池内的符号引用转换为直接引用，将指针指向内存地址。

PS：**解析操作一般在初始化阶段完成以后执行**

### 3.初始化

执行类构造器方法`clinit（）`,为静态变量赋值。

类构造器`<clinit>()`方法是由编译器自动收集类中的所有类变量的**赋值**动作和**静态语句块(static块)**中的语句合并产生的。

到了初始化阶段，才真正开始执行类定义的Java程序代码（或者说字节码 ），比如准备阶段的那个age初始值是0，到这一步就设置为10。

- 当初始化一个类的时候，如果发现其父类还没有进行过初始化、则需要先初始化其父类。
- 虚拟机会保证一个类的`<clinit>()`方法在多线程环境中被正确加锁和同步。

#### 一、Java程序初始化顺序

1. 父类的静态变量
2. 父类的静态代码块
3. 子类的静态变量
4. 子类的静态代码块
5. 父类的非静态变量
6. 父类的非静态代码块
7. 父类的构造方法
8. 子类的非静态变量
9. 子类的非静态代码块
10. 子类的构造方法

```java
/**
 * @Description 测试程序初始化顺序
 * @Author Shy
 */
public class InitSortDemo {
    public static void main(String[] args) {
        B b = new B();
    }
}

class A{

static String str1 = "父类A的静态变量";
    String str2 = "父类A的非静态变量";

static {
        System.out.println("执行了父类A的静态代码块");
    }

{
        System.out.println("执行了父类A的非静态代码块");
    }

public A(){
        System.out.println("执行了父类A的构造方法");
    }
}

class B extends A{

static String str1 = "子类B的静态变量";
    String str2 = "子类B的非静态变量";

static {
        System.out.println("执行了子类B的静态代码块");
    }

{
        System.out.println("执行了子类B的非静态代码块");
    }

public B(){
        System.out.println("执行了子类B的构造方法");
    }
}

/**
 * 依次输出
 * 执行了父类A的静态代码块
 * 执行了子类B的静态代码块
 * 执行了父类A的非静态代码块
 * 执行了父类A的构造方法
 * 执行了子类B的非静态代码块
 * 执行了子类B的构造方法
 */
```

#### 二、类的引用(主动引用和被动引用)

1. **主动引用（一定会初始化）**

- new一个类的对象。
   - 调用类的静态成员(除了final常量)和静态方法。
   - 使用java.lang.reflect包的方法对类进行反射调用。
   - 当虚拟机启动，java Hello，则一定会初始化Hello类。说白了就是先启动main方法所在的类。
   - 当初始化一个类，如果其父类没有被初始化，则先会初始化他的父类。

2. **被动引用**

- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。例如：通过子类引用父类的静态变量，不会导致子类初始化。

- 通过数组定义类引用，不会触发此类的初始化。

- 引用常量不会触发此类的初始化（常量在编译阶段就存入调用类的常量池中了）。

```java
/**
 * @Description 类的引用
 * @Author Shy
 */
public class ClassAppointDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //主动引用：new一个类的对象
        	People people = new People();
        //主动引用：调用类的静态成员(除了final常量)和静态方法
	        People.getAge();
	        System.out.println(People.age);
        //主动调用：使用java.lang.reflect包的方法对类进行反射调用
	        Class.forName("com.sun.classloader.People");

//被动引用:当访问一个静态域时，只有真正声明这个域的类才会被初始化。
  	       System.out.println(WhitePeople.age);
        //被动引用:通过数组定义引用，不会初始化
	       People[] people = new People[10];
        //被动引用:引用常量不会触发此类的初始化
       	   System.out.println(People.num);
    }
    //主动调用：先启动main方法所在的类
  	  static {
	       System.out.println("main方法所在的类在虚拟机启动时就加载");
	  }
}

class People{

static int age = 3;
    static final int num = 20;

static {
        System.out.println("People被初始化了！");
    }

public People() {
    }

public static int getAge() {
        return age;
    }

public static void setAge(int age) {
        People.age = age;
    }
}

class WhitePeople extends People{

static {
        System.out.println("WhitePeople被初始化了！");
    }
}
```

### 4.使用

对象已经出来了，业务系统直接调用阶段。

### 5.卸载

用完了，可以被GC回收了。

## 二、类加载器

## 三、类加载器的代理模式

JVM中的类加载+双亲委派机制

总共已有 0 条评论