java类加载顺序和创建对象的流程详细分析

实例问题

实例代码

Parent类

1. 1 package mytest.javaBase;
2. 2
3. 3 public class Parent {
4. 4 int a = 10;
5. 5 static int b = 11;
6. 6 // 静态代码块
7. 7 static {
8. 8 System.out.println("Parent静态代码块：b=" + b);
9. 9 b++;
10. 10 }
11. 11 // 代码块
12. 12 {
13. 13 System.out.println("Parent代码块： a=" + a);
14. 14 System.out.println("Parent代码块： b=" + b);
15. 15 b++;
16. 16 a++;
17. 17 }
18. 18
19. 19 // 无参构造函数
20. 20 Parent() {
21. 21 System.out.println("Parent无参构造函数： a=" + a);
22. 22 System.out.println("Parent无参构造函数： b=" + b);
23. 23 }
24. 24
25. 25 // 有参构造函数
26. 26 Parent(int a) {
27. 27 System.out.println("Parent有参构造函数： a=" + a);
28. 28 System.out.println("Parent有参构造函数： b=" + b);
29. 29 }
30. 30
31. 31 // 方法
32. 32 void function() {
33. 33 System.out.println("Parent function run ……");
34. 34 }
35. 35
36. 36 }

Child类

1. 1 package mytest.javaBase;
2. 2
3. 3 public class Child extends Parent {
4. 4 int x = 10;
5. 5 static int y = 11;
6. 6 // 静态代码块
7. 7 static {
8. 8 System.out.println("Child静态代码块：y=" + y);
9. 9 y++;
10. 10 }
11. 11 // 代码块
12. 12 {
13. 13 System.out.println("Child代码块： x=" + x);
14. 14 System.out.println("Child代码块： y=" + y);
15. 15 y++;
16. 16 x++;
17. 17 }
18. 18
19. 19 // 构造函数
20. 20 Child() {
21. 21 System.out.println("Child构造函数： x=" + x);
22. 22 System.out.println("Child构造函数： y=" + y);
23. 23 }
24. 24
25. 25 // 方法
26. 26 void function() {
27. 27 System.out.println("Child function run ……");
28. 28 }
29. 29
30. 30 }

Test测试类

1. 1 package mytest.javaBase;
2. 2
3. 3 public class Test {
4. 4 public static void main(String[] args) {
5. 5 Child demo = new Child();
6. 6 demo.function();
7. 7 System.out.println("…………………………………………………………………………………………………………………………");
8. 8 Child child = new Child();
9. 9 child.function();
10. 10 }
11. 11 }

我们可以先不看运行结果，自己思考下，运行结果会是什么，之后再比较下和自己思考的结果是否一样。

运行结果

1 2 3 4 5 6 7 8 9 扫描二维码关注公众号，回复： 3333709 查看本文章 10 11 12 13 14 15 16 17 18 19 20 21

Parent静态代码块：b=11 Child静态代码块：y=11 Parent代码块： a=10 Parent代码块： b=12 Parent无参构造函数： a=11 Parent无参构造函数： b=13 Child代码块： x=10 Child代码块： y=12 Child构造函数： x=11 Child构造函数： y=13 Child function run …… ………………………………………………………………………………………………………………………… Parent代码块： a=10 Parent代码块： b=13 Parent无参构造函数： a=11 Parent无参构造函数： b=14 Child代码块： x=10 Child代码块： y=13 Child构造函数： x=11 Child构造函数： y=14 Child function run ……

结果详细分析 

我们运行Test类的main方法

1、  启动JVM，开始分配内存空间； 

2、  开始加载Test.class文件，加载到方法区中，在加载的过程中静态的内容要进入静态区中；

3、  在开始运行main方法，这时JVM就会把main调用到栈中运行，开始从方法的第一行往下运行；

4、  在main方法中new Child()；这时JVM就会在方法区中查找有没有Child文件，如果没有就加载Child.class文件，并且Child继承Parent类，所以也要查找有没有Parent类，如果没有也要加载Parent.class文件。

5、  Child.class和Parent.class中的所有的非静态内容会加载到非静态的区域中，而静态的内容会加载到静态区中。静态内容（静态变量，静态代码块，静态方法）按照书写顺序加载。

说明：类的加载只会执行一次。下次再创建对象时，可以直接在方法区中获取class信息。

6、  开始给静态区中的所有静态的成员变量开始默认初始化。默认初始化完成之后，开始给所有的静态成员变量显示初始化。

7、  所有静态成员变量显示初始化完成之后，开始执行静态的代码块。先执行父类的静态代码块，再执行子类的静态代码块。

//这时输出
Parent静态代码块：b=11
Child静态代码块：y=11

说明：>>静态代码块是在类加载的时候执行的，类的加载只会执行一次所以静态代码块也只会执行一次；

     >>非静态代码块和构造函数中的代码是在对象创建的时候执行的，因此对象创建(new)一次，它们就会执行一次。

8、  这时Parent.class文件 和 Child.class文件加载完成。

9、  开始在堆中创建Child对象。给Child对象分配内存空间，其实就是分配内存地址。

10、开始对类中的的非静态的成员变量开始默认初始化。

11、开始加载对应的构造方法，执行隐式三步

1. ①有个隐式的super();
2.  
3. ②显示初始化(给所有的非静态的成员变量)
4.  
5. ③执行构造代码块
6.  
7. 之后才开始执行本类的构造方法中的代码

super()是调用父类的构造函数，此处即为Parent的构造函数，在Parent的构造函数中也有个隐式三步：首先super()，再执行Parent的显示初始化，然后执行Parent的非静态构造代码块，最后执行Parent的构造函数中的代码。

//这时输出
Parent代码块： a=10
Parent代码块： b=12
Parent无参构造函数： a=11
Parent无参构造函数： b=13

说明：虽然Parent没有明写extends，但是我们知道在Java中有个超类Object，它是所有类的父类，因此此处Parent类的super()是调用Object的构造函数

Parent的执行完之后，回来继续执行Child自己的隐式三步中的第二步：显示初始化，然后执行Child的非静态代码块的，最后执行Child的构造函数中的代码

//这时输出
Child代码块： x=10
Child代码块： y=12
Child构造函数： x=11
Child构造函数： y=13

12、对象创建完成，把内存的地址赋值给demo使用。

13、执行demo.function()方法。

//这时输出
Child function run ……

14、由于后面又创建(new)了一个新的Child对象，因此重复一下【9】之后的步骤，很容易明白它的输出结果为

Parent代码块： a=10
Parent代码块： b=13
Parent无参构造函数： a=11
Parent无参构造函数： b=14
Child代码块： x=10
Child代码块： y=13
Child构造函数： x=11
Child构造函数： y=14
Child function run ……

 简单的画个内存运行示例图

总结

我们知道，我们在创建(new)一个对象的时候，先要去JVM的方法区里获取该对象所对应的类的信息，如果方法区里没有该类的信息，则需要去将它加载进来，加载进来之后，有了该类的信息，我们才能创建一个对象。

一般，Java类被编译后，会生成一个class文件，在运行的时候会将class文件加载到Java虚拟机JVM中，class文件由类装载器装载，在JVM中（准确的来说应该是在JVM的方法区里）将形成一份描述Class结构的元信息对象，通过该元信息对象可以获知Class的结构信息：如构造函数，属性和方法等。

一、类的加载过程

首先，Jvm在执行时，遇到一个新的类时，会到内存中的方法区去找class的信息，如果找到就直接拿来用，如果没有找到，就会去将类文件加载到方法区。在类加载时，静态成员变量加载到方法区的静态区域，非静态成员变量加载到方法区的非静态区域。

静态代码块是在类加载时自动执行的代码，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块。

加载过程：

1、JVM会先去方法区中找有没有相应类的.class存在。如果有，就直接使用；如果没有，则把相关类的.clss加载到方法区。

2、在.class加载到方法区时，先加载父类再加载子类；先加载静态内容，再加载非静态内容

3、加载静态内容：

• 把.class中的所有静态内容加载到方法区下的静态区域内
• 静态内容加载完成之后，对所有的静态变量进行默认初始化
• 所有的静态变量默认初始化完成之后，再进行显式初始化
• 当静态区域下的所有静态变量显式初始化完后，执行静态代码块

4、加载非静态内容：把.class中的所有非静态变量及非静态代码块加载到方法区下的非静态区域内。

5、执行完之后，整个类的加载就完成了。

对于静态方法和非静态方法都是被动调用，即系统不会自动调用执行，所以用户没有调用时都不执行，主要区别在于静态方法可以直接用类名直接调用（实例化对象也可以），而非静态方法只能先实例化对象后才能调用。

二、对象的创建过程

1、new一个对象时，在堆内存中开辟一块空间。

2、给开辟的空间分配一个地址。

3、把对象的所有非静态成员加载到所开辟的空间下。

4、所有的非静态成员加载完成之后，对所有非静态成员变量进行默认初始化。

5、所有非静态成员变量默认初始化完成之后，调用构造函数。

6、在构造函数入栈执行时，分为两部分：先执行构造函数中的隐式三步，再执行构造函数中书写的代码。

1. 隐式三步：
2. ①执行super()语句
3.  
4. ②显示初始化(对开辟空间下的所有非静态成员变量进行)
   
   ③执行构造代码块

7、在整个构造函数执行完并弹栈后，把空间分配的地址赋给引用对象。

三、其他

super语句，可能出现以下三种情况:

1）构造方法体的第一行是this()语句，则不会执行隐式三步，而是调用this()语句所对应的的构造方法，最终肯定会有第一行不是this语句的构造方法。 

package mytest.javaBase;
public class Student {
    private String name;
    private String age;
    Student() {
    };
    Student(String name) {
        this.name = name;
    };
    Student(String name, String age) {
        // 不会执行隐式三步
        this(name);
        this.age = age;
    };
}

2）构造方法体的第一行是super()语句，则调用相应的父类的构造方法， 
3）构造方法体的第一行既不是this()语句也不是super()语句，则隐式调用super()，即其父类的默认构造方法，这也是为什么一个父类通常要提供默认构造方法的原因；