java类的初始化和对象的创建顺序

- 日理万妓 2022-07-16 07:23 300阅读 0赞

学习java编程思想--类的初始化p146

类的加载顺序
    * 1加载器启动找到 xxx.class文件，通过extends关键字寻找基类，先加载基类
    * 2类初始化先初始化static成员变量和static--->
    * 2先初始化父类的static成员变量和static
    * 3再初始化本类的static成员变量和static
    
    * 类加载之后，对象创建开始
    * 1先加载父类的非静态成员变量（静态成员变量在类初始化的时候已经加载，非静态成员变量要随对象的创建而初始化）
    * 2先加载父类的构造函数
    * 3再加载本类的非静态成员变量
    * 4再加载本类的构造函数
    *
    
     总体：
    * -->表示顺序
    * 父类-->子类
    * 静态-->非静态
    * 类-->对象
    * static随类的加载而加载
    * 非static成员变量随对象的创建而加载
    * 成员变量先于构造器加载

1 package com.test.java.classs;
     2 
     3 /**
     4  * Created by Administrator on 2015/12/8.
     5  * 类的加载顺序
     6  * 1加载器启动找到 xxx.class文件，通过extends关键字寻找基类，先加载基类
     7  * 2类初始化先初始化static成员变量和static--->
     8  * 2先初始化父类的static成员变量和static
     9  * 3再初始化本类的static成员变量和static
    10  * 类加载之后，对象创建开始加载
    11  * 1先加载父类的非静态成员变量（静态成员变量在类初始化的时候已经加载，非静态成员变量要随对象的创建而初始化）
    12  * 2先加载父类的构造函数
    13  * 3再加载本类的非静态成员变量
    14  * 4再加载本类的构造函数
    15  *
    16  * 总体：
    17  * -->表示顺序
    18  * 父类-->子类
    19  * 静态-->非静态
    20  * 类-->对象
    21  * static随类的加载而加载
    22  * 非static成员变量随对象的创建而加载
    23  * 成员变量先于构造器加载
    24  *
    25  */
    26 public class ClassLoadOrder extends Father{
    27     //2父类的static成员变量加载完之后 开始加载子类的static域
    28     private static int k = printInt("child static k initialized");
    29     //5 子类的非静态成员变量初始化
    30     private int m = printInt("child 非static 变量加载");
    31 
    32     //子类的构造器加载
    33     public ClassLoadOrder() {
    34         System.out.println("child constructor initialized");
    35         System.out.println("k="+k);
    36         System.out.println("j="+j);
    37     }
    38 
    39     static {
    40         System.out.println("child static initialized");
    41     }
    42     static int printInt2(){
    43         System.out.println("child static function initialized");
    44         return 50;
    45     }
    46 
    47     public static void main(String[] args) {
    48         ClassLoadOrder c = new ClassLoadOrder();
    49     }
    50 }
    51 
    52 class Father{
    53     private int i=9;
    54     protected int j;
    55     //4 父类构造器加载
    56     Father(){
    57         System.out.println("father constructor initialized");
    58         System.out.println("i="+i+",j="+j);
    59         j=39;
    60     }
    61     //3 对象创建时，先初始化父类的非静态成员变量
    62     int n = printInt("father 非static变量加载");
    63     //1先加载父类的static域
    64     static {
    65         System.out.println("father static initialized");
    66     }
    67     //1
    68     private static int x1 = printInt("father static .x1 initialized");
    69     static int printInt(String s ){
    70         System.out.println(s);
    71         return 47;
    72     }
    73 }

结果：

father static initialized  
father static .x1 initialized  
child static k initialized  
child static initialized  
father 非static变量加载  
father constructor initialized  
i=9,j=0  
child 非static 变量加载  
child constructor initialized  
k=47  
j=39