类是如何初始化的

类的初始化和对象的初始化是两个不同的概念,本文分为类加载和对象的实例化过程

类初始化时机

1.new生成新对象实例

2.使用java.lang.reflect包的方法对类进行发射调用时

3.当子类进行加载或初始化,发现其有父类并未被加载的情况

4.调用类的静态方法,或方法静态变量

对象实例化过程

准备代码

1.创建接口Interface

public interface Interface {

    Object x = new Object() {
        {
            println("dynamic block x in interface field object initialization");
        }
    };
    Object y = new Object() {
        {
            println("dynamic block y in interface field object initialization");
        }
    };
}

2.创建抽象类实现Interface

public abstract class Abstract implements Interface {
    static {
        println("static block before Abstract constructor");
    }

    {
        println("block before Abstract constructor");
    }

    public Abstract() {
        println("Abstract constructor");
    }

    static {
        println("static block after Abstract constructor");
    }

    {
        println("block after Abstract constructor");
    }
}

3.创建Contrete类继承Abstract

public class Concrete extends Abstract {

    static {
        println("static block before Concrete constructor");
    }

    {
        println("block before Concrete constructor");
    }

    public Concrete() {
        println("Concrete constructor");
    }

    static {
        println("static block after Concrete constructor");
    }

    {
        println("block after Concrete constructor");
    }

}

4.main方法测试

 println("creating concrete object");
        Concrete c = new Concrete();
        println("1st concrete object done");
        c = new Concrete();
        c.x.toString();
        println("2nd concrete object done");

1.Concrete c 在栈内存给引用变量c开辟一块空间,指向null, new关键字触发Concrete类的.class文件被JVM加载到方法区,并在堆  内存开辟一块存储该对象的区间,并最终将这块内存地址值分配给引用变量c.

2.跟踪代码,对象内部初始化过程:

 

先加载Concrete的父类,初始化父类的构造方法之前先加载父类的静态代码块,再加载Concrete对象的静态代码块

再加载父类的构造代码块,加载完毕开始先初始化父类构造方法,父类初始化完毕,紧接着加载Concrete的构造代码块,最后初始化

该类构造方法------------------>打印"1st concrete object done"

3.引用变量c开始指向堆内存新的地址值, 此时静态父类和该实例对象的静态代码块不会再次加载,静态代码块只会加载一次,依旧
依次加载父类构造代码块,父类构造方法,该类构造代码块,构造方法

4.通过对象c调用接口内x的方法,接口两个方法都会打印---------->这里不太明白

5.被static修饰的变量,会被作为GC的root根节点,作为根节点,意味着这一类变量是基本上不会被回收,因此,static容易造成内存泄露的风险.