Java类加载顺序

最新推荐文章于 2022-12-09 16:35:28 发布

ah_zf

最新推荐文章于 2022-12-09 16:35:28 发布

阅读量266

点赞数 2

分类专栏：笔试面试文章标签： class 顺序 Java 静态类加载

本文链接：https://blog.csdn.net/ah_zf/article/details/60761830

版权

笔试面试专栏收录该内容

2 篇文章 0 订阅

订阅专栏

例1：

public class StaticTest {

    public static int k = 0;
    public static StaticTest t1 = new StaticTest("t1");
    public static StaticTest t2 = new StaticTest("t2");
    public static int i = print("i");
    public static int n = 99;
    public int j = print("j");

    {
        print("构造快");
    }

    {
        print("静态块");
    }

    public StaticTest(String str) {
        System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
        ++n;
        ++i;
    }

    public static int print(String str) {
        System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
        ++i;
        return ++n;
    }
    public static void main(String[] args) {
        StaticTest t = new StaticTest("init");
    }
}

结果：
1:j i=0 n=0
2:构造快 i=1 n=1
3:静态块 i=2 n=2
4:t1 i=3 n=3
5:j i=4 n=4
6:构造快 i=5 n=5
7:静态块 i=6 n=6
8:t2 i=7 n=7
9:i i=8 n=8
10:j i=9 n=99
11:构造快 i=10 n=100
12:静态块 i=11 n=101
13:init i=12 n=102

类加载顺序：
* 1.加载类的静态属性(非静态不管)
* 这里加载的是:public static int k = 0;
* 然后加载:public static StaticTest t1 = new StaticTest(“t1”);
* 因为此处进行了类的实例化所以
* 1.1加载类的非静态属性
* 这里是:public int j = print(“j”);
* 运行完这个方法接着
* 1.2顺序加载类中的非static代码块(static暂时不加载)
* 这里是:print(“构造快”);和print(“静态块”);
* 运行完接着
* 1.3加载类的构造方法
* 这里是:public StaticTest(String str)
* 运行完（一个静态属性的实例就完成了）
* 2.继续加载类的静态属性
* 这里加载的是:public static StaticTest t2 = new StaticTest(“t2”);
* 2.1重复（1.1-1.3）
* 3.继续加载类的静态属性
* 这里加载的是:public static int i = print(“i”);
* 运行完接着
* 4.继续加载类的静态属性
* 这里加载的是:public static int n = 99;
* 不管你n原来是多少现在为99
* 接着
* 5.（如果有static代码块，在这里先加载，这个里面没有所以加载主函数）加载主函数
* 这里加载的是:StaticTest t = new StaticTest(“init”);
* 因为此处进行了类的实例化所以
* 5.1
* 重复1.1-1.3
* 5.2
* 因为public static int print(String str)这个方法返回++n
* 所以n从99开始累
* 运行完OK了

例2：

public class test {                         //1.准备加载类


    public static void main(String[] args) {
        new test();                              
    }

    static int num = 4;                    //2.静态变量和静态代码块的加载顺序由编写先后决定 

    {
        num += 3;
        System.out.println("b");           //4.按照顺序加载匿名代码块和非静态变量
    }


    int a =5;                              //5.按照顺序加载匿名代码块和非静态变量

    { 
        System.out.println("c");           //6.按照顺序加载匿名代码块和非静态变量

    }

    test() { 
        System.out.println("d");           //7.最后加载构造函数，完成对象的建立
    }

    static {                               //3.静态变量和静态代码块的加载顺序由编写先后决定

        System.out.println("a");
    }

    static void run()                      // 静态方法，调用的时候才加载// 注意看，e没有加载
    {
        System.out.println("e");
    }
}

一般顺序：静态块（静态变量）–>成员变量（匿名代码块）–>构造方法–>静态方法（调用的时候才加载）

例3：

public class Parent{

     public static Print obj1 = new Print("1");

     public Print obj2 = new Print("2");

     public static Print obj3 = new Print("3");

     static{
         new Print("4");
     }
     public static Print obj4 = new Print("5");

     public Print obj5 = new Print("6");

     public Parent(){
         new Print("7");
     }

 }

public class Child extends Parent{


     static{
         new Print("a");
     }

     public static Print obj1 = new Print("b");

     public Print obj2 = new Print("c");

     public Child (){
         new Print("d");
     }

     public static Print obj3 = new Print("e");

     public Print obj4 = new Print("f");

     public static void main(String [] args){
         Parent obj1 = new Child ();
         Parent obj2 = new Child ();
     }
 }