java 关于类加载

拼搏现实的明天。 2022-11-25 13:18 83阅读 0赞

运行一个java文件通常 要经历java → .class → 运行。而从.class → 运行 就需要用到类加载机制

举个通俗点的例子来说，JVM在执行某段代码时，遇到了class A， 然而此时内存中并没有class A的相关信息，于是JVM就会   到相应的class文件中去寻找class A的类信息，并加载进内存中，这就是我们所说的类加载过程。

## 类加载 ##

![format_png][]

### 加载 ###

简单来说，加载指的是把class字节码文件从各个来源通过类加载器装载入内存中。

这里有两个重点：

*  字节码来源。一般的加载来源包括从本地路径下编译生成的.class文件，从jar包中的.class文件，从远程网络，以及动态代理实时编译
 *  类加载器。一般包括启动类加载器，扩展类加载器，应用类加载器，以及用户的自定义类加载器。

注：为什么会有自定义类加载器？

*  一方面是由于java代码很容易被反编译，如果需要对自己的代码加密的话，可以对编译后的代码进行加密，然后再通过实现自己的自定义类加载器进行解密，最后再加载。
 *  另一方面也有可能从非标准的来源加载代码，比如从网络来源，那就需要自己实现一个类加载器，从指定源进行加载。

### 验证 ###

主要是为了保证加载进来的字节流符合虚拟机规范，不会造成安全错误。

其中包括：

1.对于元数据的验证，比如该类是否继承了被final修饰的类？类中的字段，方法是否与父类冲突？是否出现了不合理的重载？

2.对于字节码的验证，保证程序语义的合理性，比如要保证类型转换的合理性。

3.对于符号引用的验证，比如校验符号引用中通过全限定名是否能够找到对应的类？校验符号引用中的访问性（private，public等）是否可被当前类访问？

### 准备 ###

主要是为类变量（注意，不是实例变量）分配内存，并且赋予初值。

特别需要注意，初值，不是代码中具体写的初始化的值，而是Java虚拟机根据不同变量类型的默认初始值。

比如8种基本类型的初值，默认为0；引用类型的初值则为null；常量的初值即为代码中设置的值，final static tmp = 456， 那么该阶段tmp的初值就是456

### 解析 ###

将常量池内的符号引用替换为直接引用的过程。(其实就是由 代码→地址操作 的转化)

两个重点：

*  符号引用。即一个字符串，但是这个字符串给出了一些能够唯一性识别一个方法，一个变量，一个类的相关信息。
 *  直接引用。可以理解为一个内存地址，或者一个偏移量。比如类方法，类变量的直接引用是指向方法区的指针；而实例方法，实例变量的直接引用则是从实例的头指针开始算起到这个实例变量位置的偏移量

举个例子来说，现在调用方法hello()，这个方法的地址是1234567，那么hello就是符号引用，1234567就是直接引用。

在解析阶段，虚拟机会把所有的类名，方法名，字段名这些符号引用替换为具体的内存地址或偏移量，也就是直接引用。

### 初始化 ###

这个阶段主要是对类变量初始化，是执行类构造器的过程。

换句话说，只对static修饰的变量或语句进行初始化。

如果初始化一个类的时候，其父类尚未初始化，则优先初始化其父类。

如果同时包含多个静态变量和静态代码块，则按照自上而下的顺序依次执行。

## **下面是类加载顺序的例子** ##

public class ClassLoaderTest {
    
        public static void main(String[] args) {
            son sons=new son();
        }
    }
    
    class parent{
        private static  int a=1;
        private static  int b;
        private   int c=initc();
        static {
            b=1;
            System.out.println("1.父类静态代码块：赋值b成功");
            System.out.println("1.父类静态代码块：a的值"+a);
        }
        int initc(){
            System.out.println("3.父类成员变量赋值：---> c的值"+c);
            this.c=12;
            System.out.println("3.父类成员变量赋值：---> c的值"+c);
            return c;
        }
        public parent(){
            System.out.println("4.父类构造方式开始执行---> a:"+a+",b:"+b);
            System.out.println("4.父类构造方式开始执行---> c:"+c);
        }
    }
    
    class son extends parent{
        private static  int sa=1;
        private static  int sb;
        private   int sc=initc2();
        static {
            sb=1;
            System.out.println("2.子类静态代码块：赋值sb成功");
            System.out.println("2.子类静态代码块：sa的值"+sa);
        }
        int initc2(){
            System.out.println("5.子类成员变量赋值--->：sc的值"+sc);
            this.sc=12;
            return sc;
        }
        public son(){
            System.out.println("6.子类构造方式开始执行---> sa:"+sa+",sb:"+sb);
            System.out.println("6.子类构造方式开始执行---> sc:"+sc);
        }
    }

结果

1.父类静态代码块：赋值b成功
     1.父类静态代码块：a的值1
     2.子类静态代码块：赋值sb成功
     2.子类静态代码块：sa的值1
     3.父类成员变量赋值：---> c的值0
     3.父类成员变量赋值：---> c的值12
     4.父类构造方式开始执行---> a:1,b:1
     4.父类构造方式开始执行---> c:12
     5.子类成员变量赋值--->：sc的值0
     6.子类构造方式开始执行---> sa:1,sb:1
     6.子类构造方式开始执行---> sc:12

[format_png]: /images/20221124/d3c1b088934949e494dd84d224cd5d4c.png