【java】类的加载和对象的构造（实例化）过程及顺序

1.类的加载

1.1 什么类的加载load？（Node类的加载）

答.从硬盘上找到Node.class，解析该文件内容，生成Node类，把Node类的信息存放在内存的方法区

1.2 什么情况下回触发类的加载？并且该类不在内存中

（1）按需加载（懒加载过程）

          a.实例化该类的一个对象 new Node(1);

          b.使用类的静态属性或者静态方法 Main.merge(…)

          c.用到子类，必须要有父类 new CNode

         d.先加载父类的静态代码块，再加载子类的静态代码块

 

1.3 其他规则

静态属性的初始化顺序：

按代码的书写顺序，执行

a.静态属性定义时的初始化

b.静态代码

2.代码块

代码块定义：使用“{}”定义的一段代码；

构造代码块是跟着对象的加载而加载的。

2.1 普通代码块

普通代码块：定义在方法中的代码块；

public class Test1 {
    public static void main(String[] args) {
        {
            //普通代码块
            int a=10;
            System.out.println(a);
        }
        int a=20;
        System.out.println(a);
    }
}

2.2 构造块

构造块：定义在类中的代码块（不加修饰符）

class A{
    //定义在类中，不加任意修饰符
    {
        System.out.println("A的构造块");
    }
    //构造方法
    public A(){
        System.out.println("A的构造方法");
    }
}
public class Test2 {
    public static void main(String[] args) {
        new A();
        new A();
    }
}

通过上述代码可以发现：构造块优先于构造方法执行，每产生一个新的对象就调用一次构造块。所以构造块可以进行简单的逻辑操作（在调用构造方法之前）。

2.3 静态代码块

静态代码块：使用static定义的代码块，它是跟着类的加载而加载的。

根据静态代码块所在的类不同又可分为以下两种类型：

1.在非主类中的静态代码块

2.在主类中的静态代码块

2.3.1 在非主类中的静态代码块

class B{
    //构造块
    {
        System.out.println("B类的构造块");
    }
    //代码方法
    public B(){
        System.out.println("B类的构造方法");
    }
    //静态代码块
    static {
        System.out.println("B类的静态代码块");
    }
}
public class Test3 {
    public static void main(String[] args) {
        System.out.println("==============================");
        new B();
        new B();
        System.out.println("==============================");
    }
}

可以发现：

                1.在非主类的静态代码块中，在类加载时执行，优先于构造块执行

                2.无论产生多少实例化对象，静态代码块只执行一次

静态块的主要作用是为static属性进行初始化！

2.3.2 在主类中的静态代码块

public class Test4 {
    //构造块
    {
        System.out.println("Test4类的构造块");
    }

    //构造方法
    public Test4(){
        System.out.println("Test4类的构造方法");
    }
    //静态代码块
    static {
        System.out.println("Test4类的静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("===========================");
        new Test4();
        new Test4();
        System.out.println("===========================");
    }
}

在主类中定义的静态块，优先于主方法（main）执行，在JVM启动时执行，当编译执行时JVM会首先加载主类，此时主类中的静态代码块就会执行。

3.对象的构造/实例化 new Node

3.1 规则

1.优先初始化父类的属性，（和下面的执行顺序相同）

2.按照下面的顺序执行初始化

a.按照代码书写顺序，执行定义时和构造代码块

b.再去执行构造方法

3.静态代码块只在加载时执行一次，先执行父类的静态代码块，再执行子类的静态代码块。

3.2关于执行顺序的问题

1.父类的加载在子类之前

2.父类的构造方法在子类之前调用

3.static属性初始化是在类的加载时执行（按顺序执行）

1）定义时初始化

2）构造代码块时初始化

4.普通属性初始化是在对象的构造时执行（按顺序执行）

1）定义时初始化

2）构造代码块时初始化

3）构造方法时初始化

5.只有用到类，才会加载类

class Hello{
    //构造方法
    public Hello(){
        System.out.println("1.Hello父类的构造方法");
    }
    //非静态代码块
    {
        System.out.println("2.Hello父类非静态代码块");
    }
    //静态代码块
    static{
        System.out.println("3.Hello父类静态代码块");
    }
}
public class HelloA extends Hello{
    public HelloA(){
        System.out.println("4.helloA构造方法");
    }
    //非静态代码块
    {
        System.out.println("5.HelloA非静态代码块");
    }
    //静态代码块
    static{
        System.out.println("6.HelloA静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("7.---start---");
        new HelloA();
        new HelloA();
        System.out.println("8.---end---");
    }
}

按照上面讲的执行顺序执行：因为先用到了主类HeoolA,所以先加载了静态代码块；

执行结果：

class Hello1{
    //构造方法
    public Hello1(){
        System.out.println("1.Hello1父类的构造方法");
    }
    //非静态代码块
    {
        System.out.println("2.Hello1父类非静态代码块");
    }
    //静态代码块
    static{
        System.out.println("3.Hello1父类静态代码块");
    }
}
class Hello2 extends Hello1 {
    public Hello2() {
        System.out.println("4.hello2构造方法");
    }

    //非静态代码块
    {
        System.out.println("5.Hello2非静态代码块");
    }

    //静态代码块
    static {
        System.out.println("6.Hello2静态代码块");
    }

}
public class Test{
    public static void main(String[] args) {
        System.out.println("7.---start---");
        new Hello2();
        new Hello2();
        System.out.println("8.---end---");
    }
}

运行结果：

 

注：代码块的内容参考本文章！！！