类加载机制

类加载的时机

主动引用（有且只有下面的五种）

1. 使用new关键字创建对象时，访问类的静态字段时；

2. 使用java.lang.reflect包的方法进行反射调用的时候；

3. 初始化一个类时，如果父类没有被初始化，则需要先初始化；

4. 当虚拟机启动的时候，虚拟机先会初始化主类（main()方法所在的类）

5. JDK1.7动态语言支持；

被动引用（类不会加载）

1. 子类引用父类的静态字段，不会导致子类的的初始化。

2. 通过数组定义引用类。

3. 访问类中的常量；

类加载流程

1. 加载

   1.1 加载二进制字节流到内存

   1.2 生成方法区数据结构

   1.3 生成java.lang.Class对象

2. 连接

   2.1 验证

   • 文件格式验证： 版本号，是不是
   • 元数据验证：是否基础了final类？是不是有父类？是不是实现了抽象类的方法？
   • 字节码验证：跳转指令是否合法？
   • 字符引用验证：引用的类是否存在？类及接口是否有访问权限？

   2.2 准备
   类变量（即静态变量而不是实例变量）分配内存，并为类设置初始值（方法区）

   • public static int v=1;
   • 在准备阶段中个，v会被设置为0
   • 在初始化的<clinit>中才会被设置为1
   • 对于static final类型，在准备阶段就会被赋上准确的值
   • public static final int v=1

   2.3 解析

   • 字符引用转换为直接引用：com.XXX.sudent这个就是个符号，直接引用就是它在内存的地址

3. 初始化
   执行类构造器<clinit>方法，<clinit>方法由静态代码块、静态变量构成和赋值语句构成。

   • <clinit>方法线程安全： 基于它可以实现线程安全单例，参考单例模式
   • <clinit>方法执行时，发现父类的没有执行先执行父类的<clinit>方法

4. 使用

5. 卸载

类加载器

类加载器分类

1. 启动类加载器

2. 扩展加载器

3. 应用类加载器

4. 自定义类加载器

备注：类加载器之间不是继承的关系，而是组合的关系。

双亲委派模式

类加载器：字底向上查找是否已经加载类，自顶向下加载类。

双亲委派模式：为了维护类加载的安全。

破坏双亲委派模式

1. 接口在rt.jar实现在应用程序，启动类加载器如何加载应用类加载器的类，例如：SPI机制

   线程上线文类加载器可以解决这个问题，它模式的类加载器是应用类加载器。

2. 热替换

问题 1：

static{
    a = 300;
    System.out.println(a);//这里会报错，声明语句之前只能赋值不能引用
}
public static int a = 10;

问题 2：

类加载中只用类变量及静态代码执行，那么构造方法、普通代码块啥时候执行呢，其实这个不属于类加载，它属于类的实例化，在类的实例化是执行。

public class Line {  
    static {  
        System.out.println("静态代码块执行：loading line");  
    }  
  
    public static String s = getString();  
  
    private static String getString() {  
        System.out.println("给静态变量赋值的静态方法执行：loading line");  
        return "ss";  
    }  
  
    public static void test() {  
        System.out.println("普通静态方法执行：loading line");  
    }  
  
    public Line() {  
        System.out.println("构造方法执行：loading line");  
    }  
  
    {  
        System.out.println("构造代码块执行");  
    }  
}
public class CodeBlockTest {  
    public static void main(String[] args) {  
        System.out.println("主方法");  
        {  
            System.out.println("main方法中最开始的，普通代码块执行");  
        }  
        Line line = new Line();  
        System.out.println("...............");  
        Line line1 = new Line();  
        System.out.println("...............");  
        {  
            System.out.println("main方法中结尾事的，普通代码块执行");  
        }  
    }  
}

结果大家自己执行，注意下：构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。

问题 3：

public class Singleton {
    private static Singleton mInstance = new Singleton();// 位置1
    public static int counter1;
    public static int counter2 = 0;
//        private static Singleton mInstance = new Singleton();// 位置2
    private Singleton() {
        counter1++;
        counter2++;
    }

    public static Singleton getInstance() {
        return mInstance;
    }
}

class InitDemo {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("counter1: " + singleton.counter1);
        System.out.println("counter2: " + singleton.counter2);
    }
}
位置1：
counter1=1
counter2=0

位置2：
counter1=1
counter2=1