java类加载、对象创建过程

类加载过程：

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

2， 在.class加载到方法区时，会分为两部分加载：先加载非静态内容，再加载静态内容

3， 加载非静态内容：把.class中的所有非静态内容加载到方法区下的非静态区域内

4， 加载静态内容：

    4.1、把.class中的所有静态内容加载到方法区下的静态区域内

    4.2、静态内容加载完成之后，对所有的静态变量进行默认初始化

    4.3、所有的静态变量默认初始化完成之后，再进行显式初始化

    4.4、执行静态代码块(注：静态代码块与静态变量显式初始化无先后顺序，与代码顺序相关，如静态代码块在上，则先加载代码块)

5，整个类的加载就完成了。

 

对象创建过程：

1， 在堆内存中开辟一块空间

2， 给开辟空间分配一个地址

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

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

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

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

    6.1、隐式三步：

        1，执行super语句

        2，对开辟空间下的所有非静态成员变量进行显式初始化

        3，执行构造代码块(注：代码块与非静态成员变量显示初始化无先后顺序，与代码顺序相关，如代码块在上，则先加载代码块)

    6.2、在隐式三步执行完之后，执行构造函数中书写的代码

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

总结类中能书写的成员

栈： 用来运行函数。可以存储局部信息

     特点：先进后出

堆：用来存储实体（被new创建出来的）。

特点：

1，  每一个实体所开辟的空间都有一个地址

2，  每一个实体中存储的数据都有一个默认初始值

方法区：存放class和static。 方法区其实是由N多个小的区域构成。有存放非静态内容的非静态区域，还有存放静态内容的静态区域，还有存放常量的常量池 等

 

class  ABC

{

         非静态成员变量

         静态成员变量

 

        非静态成员函数

        静态成员函数

 

构造函数：ABC(...){...}

 

静态代码块： static {...}

构造代码块 :  {...}

}

 

 图解调用过程：

  

父子类加载及创建对象过程代码实例：

1. //子类
2. public class Insect {
3. private int i = printInit("Insect:i");
4. protected int j;
5.  
6. protected static int x1 = printInit("static Insect.x1 initialized");
7. static{
8. System.out.println( "Insect静态代码块");
9. x1= 80;
10. }
11. Insect() {
12. System.out.println( "基类构造函数阶段： i = " + i + ", j = " + j);
13. j = 39;
14. System.out.println(x1);
15. }
16.  
17. static int printInit(String s) {
18. System.out.println(s);
19. return 47;
20. }
21.  
22. }
23. //父类
24. public class Beetle extends Insect{
25. {
26. k= 90;
27. }
28. private int k = printInit("Beetle.k initialized");
29.  
30.  
31. protected static int x2 = printInit("static Beetle.x2 initialized");
32.  
33.  
34. public Beetle() {
35. System.out.println(k);
36. }
37.  
38.  
39. public static void main(String[] args) {
40. Beetle b = new Beetle();
41. }
42.  
43. }

运行结果：

对象创建过程代码和注释：

class Person {
    int age;

    Person(int age) {
        this.age = age;
    }
}

class Student extends Person {
    // 2，对开辟空间下的所有非静态成员变量进行显式初始化
    String school = "abc";

    Student(String school, int age) {
        // 1，执行super语句
        super(age);
        // 4、在隐式三步执行完之后，执行构造函数中书写的代码
        this.school = school;
    }

    {
        // 3，执行构造代码块
        System.out.println("Student code block");
    }
}