think in java 阅读笔记（类的加载和实例化）

public class ClassLoadingTest {
    static String staticString=getStaticString();    //静态成员变量
    private String privateString=getPrivateString();//普通成员变量
    public ClassLoadingTest() {
        System.out.println("Loading ClassLoadingTest()");
    }

    public static void loadStaticMethod() {
        System.out.println("Loading static method");
    }
    
    private void loadNotStaticMethed(){
        System.out.println("Loading NotStaticMethed");
    }
    
    private String getPrivateString() {
        String string=new String("Loading private variable");
        System.out.println(string);
        return string;
    }

    private static String getStaticString() {
        String string=new String("Loading static variable");
        System.out.println(string);
        return string;
    }
    
    public static void main(String[] args) {
        loadStaticMethod();    //加载静态方法
        System.out.println("try to new ClassLoadingTest()");
        ClassLoadingTest test=new ClassLoadingTest();
        test.loadNotStaticMethed();//加载普通方法
    }

}

 　　打印结果：　　

     Loading static variable

　　　Loading static method

　　　try to new ClassLoadingTest()

　　　Loading private variable

　　　Loading ClassLoadingTest()

　　　Loading NotStaticMethed          

 

　　分析结果：

1. 1. 当调用该类的某个静态方法时，首先加载该类的静态成员变量和静态方法（此时类还没有实例化）
   2. 当new该类之后，会加载该类的普通成员变量，然后才是构造方法。

　　得出结论：

　　　　当一个类没有父类的时候，加载顺序为：

　　　　静态成员变量/静态方法-->开始实例化-->普通成员变量/普通方法-->构造方法-->实例化结束。

 

当该类有父类的时：

　　测试代码：

　　　　父类：

public class ClassLoadingTestSuper {
    static String staticString=getSuperStaticString();        //父类的静态成员变量
    private String privateString=getSuperPrivateString();    //父类的普通成员变量
    public ClassLoadingTestSuper() {
        System.out.println("Loading ClassLoadingTestSuper()");
    }
    
    private String getSuperPrivateString() {
        String string=new String("Loading super class private variable");
        System.out.println(string);
        return string;
    }

    private static String getSuperStaticString() {
        String string=new String("Loading super class static variable");
        System.out.println(string);
        return string;
    }

}

　　　　子类：

public class ClassLoadingTest extends ClassLoadingTestSuper {

/*内容与ClassLoadingTest相同*/

}

　　打印结果：

Loading super class static variable

Loading static variable

Loading static method

try to new ClassLoadingTest()

Loading super class private variable

Loading ClassLoadingTestSuper()

Loading private variable

Loading ClassLoadingTest()

Loading NotStaticMethed

　　分析结果：

1. 1. 首先加载的是父类的static变量和方法；
   2. 然后加载的是该类的static变量和方法；
   3. 将该类实例化；
   4. 然后加载的是父类的普通成员变量和方法；
   5. 然后加载的是父类的构造方法；
   6. 然后加载的是该类的成员变量和方法；
   7. 然后加载的才是该类的构造方法；
   8. 最后实例化结束，外部才可以操作该对象。

 

　　得出结论：

　　　　当该类有父类的时候，类的实例化的加载过程是：

　　　　　　父类的static成员变量和方法-->该类的static变量和方法-->开始实例化-->父类的普通成员变量和方法-->父类的构造方法-->该类的普通成员变量和方法-->该类的构造方法-->实例化结束。

类的初始化顺序，找到static方法初始化类，找到父类static的成员方法和变量，静态域的初始化随着类的加载而加载，父类的普通成员与方法，非静态域的方法，在创建实例时初始化，而创建实例需要调用构造器。