深入理解Java虚拟机：从JVM角度理解类初始化、方法重载、重写

类初始化

在讲类初始化之前，我们先对类声明周期有一个大概的了解。如下图，

类的声明周期可以分为7个阶段，但今天我们只讲初始化阶段。我觉得除了使用和卸载步骤之外，初始化是我们平时学习的时候也算最简单最简单的了。笔试。如果想了解每一步，可以看《深入理解Java虚拟机》这本书。

让我们从初始化过程开始。 ？传递了 类变量 的初始值。例如，假设一个整数的初始值为 0，一个对象的初始值为 0。基本数据类型的初始值如下：

首先我们来想一个问题。当我们运行java程序时，每个类都会被初始化吗？如果不是每个类都会执行初始化过程，那么什么时候类会执行初始化过程呢？

答案是并不是所有的类都会执行初始化过程。想一想，如果这个类根本不被使用，为什么要初始化它呢？它充满了。

关于何时执行初始化过程，虚拟机规范严格规定了并且只有在5种情况下才会立即初始化类。

1. 当使用关键字new实例化对象时，读取或设置类的静态字段，并调用类的静态注释（由final修饰的静态字段除外）。
2. 使用java.lang.reflect包中的方法对类进行反射调用时，如果该类尚未初始化，则会触发该类的初始化。
3. 当一个类初始化后，其父类尚未初始化时，会先触发其父类。
4. 虚拟机启动时，用户必须指定一个要执行的主类（包含main()方法的类），虚拟机首先初始化该主类。
5. 在使用JDK 1.7的动态语言支持时，如果...（省略，说出来也没明白，哈哈）。

请注意， 只有。这五种行为称为对类的主动引用。

初始化过程

类的初始化过程做了什么？

类的初始化过程中，说白了，执行的是一个类的constructor()方法过程。请注意，这个 clinit 不是该类的构造函数（init()）。

关于 clinit() 方法包含哪些内容？

事实上，clinit()方法是编译器自动从类变量和静态语句块中的语句merge的所有赋值操作中自动收集的，编译器收集的顺序语句由句子在源文件中出现的顺序决定。并且在静态语句块中只能访问静态语句块之前定义的变量。在它之后定义的变量可以在前面的静态语句块中赋值，但是无法访问。比如下面的程序。

public class Test1 {
    static {
        t = 10;//编译可以正常通过
        System.out.println(t);//提示illegal forward reference错误
    }
    static int t = 0;
}
复制代码

给你一个练习

public class Father {
    public static int t1 = 10;
    static {
        t1 = 20;
    }
}
class Son extends Father{
    public static int t2 = t1;
}
//测试调用
class Test2{
    public static void main(String[] args){
        System.out.println(Son.t2);
    }
}
复制代码

输出结果是什么？

答案是20，我想大家都知道为什么。因为父类是先初始化的。

不过，这里需要注意的是，对于类来说，当执行该类的 clinit() 方法时，会先执行父类的 clinit() 方法，但是对于接口来说，会先执行 clinit() 方法接口的( )方法不会被执行。父接口的clinit()方法不会被执行。只有当使用了父类接口中定义的变量时，才会执行父接口的clinit()方法。

被动引用

上面提到的类初始化的五种情况称为主动引用。主动的存在也意味着存在所谓的被动参考。这里需要提到的是，被动引用不会触发类初始化。下面我们提供几个被动引用的例子：

1. 通过子类引用父类的静态字段，不会触发子类的初始化

/**
 * 1.通过子类引用父类的静态字段，不会触发子类的初始化
 */
public class FatherClass {
    //静态块
    static {
        System.out.println("FatherClass init");
    }
    public static int value = 10;
}

class SonClass extends FatherClass {
    static {
        System.out.println("SonClass init");
    }
}
 class Test3{
    public static void main(String[] args){
        System.out.println(SonClass.value);
    }
}
复制代码

输出结果

FatherClass init
复制代码

表示子类的初始化是未触发

1. 通过数组定义引用类不会触发该类的初始化。

 class Test3{
    public static void main(String[] args){
        SonClass[] sonClass = new SonClass[10];//引用上面的SonClass类。
    }      
 }
复制代码

输出结果什么都没有。

1. 在其他类中引用常量，不会触发该类的初始化

public class FatherClass {
    //静态块
    static {
        System.out.println("FatherClass init");
    }
    public static final String value = "hello";//常量
}

class Test3{
    public static void main(String[] args){
        System.out.println(FatherClass.value);
    }
}
复制代码

输出结果：hello

在编译阶段不会输出。对此常数进行了一些优化。例如，由于Test3类使用了常量“hello”，因此“hello”常量在编译阶段就已存储在Test3类的常量池中。将来，FatherClass.value 引用实际上将转换为 Test3 类对其自己的常量池的引用。也就是说，编译成class文件后，两个类就没有任何关系了。

重载

对于重载，我想学过Java的人都明白，但今天我们就从虚拟机的角度来看一下重载。

首先看一段代码：

//定义几个类
public abstract class Animal {
}
class Dog extends Animal{
}
class Lion extends Animal{
}

class Test4{
    public void run(Animal animal){
        System.out.println("动物跑啊跑");
    }
    public void run(Dog dog){
        System.out.println("小狗跑啊跑");
    }
    public void run(Lion lion){
        System.out.println("狮子跑啊跑");
    }
    //测试
    public static void main(String[] args){
        Animal dog = new Dog();
        Animal lion = new Lion();;
        Test4 test4 = new Test4();
        test4.run(dog);
        test4.run(lion);
    }
}
复制代码

运行结果：

动物跑跑跑

动物跑跑跑

猜出这个结果。但为什么选择这个方法来重载呢？如何选择虚拟机？

在此之前，我们先了解两个概念。

首先我们看一行代码：

Animal dog = new Dog(); 变量dog的称为

public class Test {
    public static void sayHello(Object arg){
        System.out.println("hello Object");
    }
    public static void sayHello(int arg){
        System.out.println("hello int");
    }
    public static void sayHello(long arg){
        System.out.println("hello long");
    }
    public static void sayHello(Character arg){
        System.out.println("hello Character");
    }
    public static void sayHello(char arg){
        System.out.println("hello char");
    }
    public static void sayHello(char... arg){
        System.out.println("hello char...");
    }
    public static void sayHello(Serializable arg){
        System.out.println("hello Serializable");
    }

    //测试
    public static void main(String[] args){
        char a = 'a';
        sayHello('a');
    }
}
复制代码

//定义几个类
public abstract class Animal {
    public abstract void run();
}
class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("小狗跑啊跑");
    }
}
class Lion extends Animal{
    @Override
    public void run() {
        System.out.println("狮子跑啊跑");
    }
}
class Test4{
    //测试
    public static void main(String[] args){
        Animal dog = new Dog();
        Animal lion = new Lion();;
        dog.run();
        lion.run();
    }
}
复制代码

//声明：我只是挑出了一部分关键的字节码
public static void (java.lang.String[]);
    Code:
    Stack=2, Locals=3, Args_size=1;//可以不用管这个
    //下面的是关键
    0：new #16;//即new Dog
    3: dup
    4: invokespecial #18; //调用初始化方法
    7: astore_1
    8: new #19 ;即new Lion
    11: dup
    12: invokespecial #21;//调用初始化方法
    15: astore_2
    
    16: aload_1; 压入栈顶
    17: invokevirtual #22;//调用run()方法
    20: aload_2 ;压入栈顶
    21: invokevirtual #22;//调用run()方法
    24: return
复制代码