java什么时候会发生类的初始化

什么时候会发生类的初始化

类的主动引用一定会发生类的初始化

1. 当JVM虚拟机启动，先初始化main方法所在的类
2. new 一个类的对象
3. 调用类的静态成员（final常量除外）和静态方法
4. 使用java.lang.reflect包的方法对类进行反射调用
5. 当初始化一个类，如果其父类没有被初始化，则会先初始化他的父类

类的被动引用（不会发生类的初始化）

1. 当访问一个静态域时，只有真正申明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
2. 通过数组定义类引用，不会触发此类的初始化
3. 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

用代码进行讲解，我们先创建两个类

class Father{
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

在这两个类中，都有一个静态代码块，如果该类初始化，则会执行静态代码块之中的内容

当JVM虚拟机启动，先初始化main方法所在的类

//测试类什么时候会初始化
public class Test06 {
    static {
        System.out.println("main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
       
    }
}

class Father{
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

运行结果：

new 一个类的对象，如果其父类没有被初始化，则会先初始化他的父类

//测试类什么时候会初始化
public class Test06 {
    static {
        System.out.println("main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
       Son son = new Son();
    }
}

class Father{
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

运行结果：

调用类的静态成员（final常量除外）和静态方法会发生类的初始化

public class Test06 {
    static {
        System.out.println("main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
       System.out.println(Son.m);
    }
}

class Father{
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

运行结果：

使用java.lang.reflect包的方法对类进行反射调用会发生类的初始化

//测试类什么时候会初始化
public class Test06 {
    static {
        System.out.println("main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("com.lixv.reflection.Son");//参数是类的路径
    }
}

class Father {
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father {
    static {
        System.out.println("子类被加载");
        m = 300;
    }

    static int m = 100;
    static final int M = 1;
}

运行结果：

当通过子类引用父类的静态变量，不会导致子类初始化

//测试类什么时候会初始化
public class Test06 {
    static {
        System.out.println("main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println(Son.b)
    }
}

class Father {
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father {
    static {
        System.out.println("子类被加载");
        m = 300;
    }

    static int m = 100;
    static final int M = 1;
}

运行结果：

通过数组定义类引用，和引用类的常量（不会会发生类的初始化）

//测试类什么时候会初始化
public class Test06 {
    static {
        System.out.println("main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //4.通过数组定义类引用
        Son[] sons = new Son[55];
        //5.引用常量
        System.out.println(Son.M);
    }
}

class Father {
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father {
    static {
        System.out.println("子类被加载");
        m = 300;
    }

    static int m = 100;
    static final int M = 1;
}

运行结果：