类加载机制

类加载的时机

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

使用new关键字创建对象时，访问类的静态字段时；
使用java.lang.reflect包的方法进行反射调用的时候；
初始化一个类时，如果父类没有被初始化，则需要先初始化；
当虚拟机启动的时候，虚拟机先会初始化主类（main()方法所在的类）
JDK1.7动态语言支持；

被动引用（类不会加载）

子类引用父类的静态字段，不会导致子类的的初始化。
通过数组定义引用类。
访问类中的常量；

类加载流程

加载

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

1.2 生成方法区数据结构

1.3 生成java.lang.Class对象
连接

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这个就是个符号，直接引用就是它在内存的地址
初始化
执行类构造器<clinit>方法，<clinit>方法由静态代码块、静态变量构成和赋值语句构成。
- <clinit>方法线程安全：基于它可以实现线程安全单例，参考单例模式
- <clinit>方法执行时，发现父类的没有执行先执行父类的<clinit>方法
使用
卸载

类加载器

类加载器分类

启动类加载器
扩展加载器
应用类加载器
自定义类加载器

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

双亲委派模式

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

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

破坏双亲委派模式

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

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

问题 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