public class InitialOrderTest {
        public static String staticField = "静态变量";

        public String field = "变量";
       
        static {
                System.out.println(staticField);
                System.out.println("静态初始化块");
        }

        {
                System.out.println(field);
                System.out.println("初始化块");
        }

        public InitialOrderTest() {
                System.out.println("构造器");
        }
        public static void main(String[] args) {
                new InitialOrderTest();
        }
}
请问上述代码运行后结果是什么？？

一个类实例化顺序是
1父类静态块
2子类静态块
3父类自由块
4父类构造函数块
5子类自由块
6子类构造函数块

1. public class MainClass {
   
2.         public static void main(String[] args) {
   
3.                 new InitialOrderTest();//1,5
   
4.         }
   
5. }
   
6. class InitialOrderTest {
   
7.         public static String staticField = "静态变量";//2
   
8.         public String field = "变量";//8
   
9.         static {
   
10.                 System.out.println(staticField);//3
    
11.                 System.out.println("静态初始化块");//4
    
12.         }
    
13.         {
    
14.                 System.out.println(field);//9
    
15.                 System.out.println("初始化块");//10
    
16.         }
    
17.         public InitialOrderTest() {//6
    
18.                 //7进入父类Obeject类
    
19.                 System.out.println("构造器");//11
    
20.         }
    
21. }

复制代码

代码中的注释说明运行顺序
所以上面的代码运行结果是：
静态变量
静态初始化块
变量
初始化块
构造器

1、超类静态变量；超类静态初始化块。－－按排列顺序；
2、子类静态变量；子类静态初始化块。－－按排列顺序；
3、超类成员变量；超类初始化块。－－按排列顺序；
4、超类构造函数。
5、子类成员变量；子类初始化块。－－按排列顺序；
6、子类构造函数。

class Super {

Super() {
System.out.println("超类默认构造器.n-------------");
}

{
System.out.println("超类初始化块.n-------------");
}

Print s1 = new Print("超类变量.n-------------");
static {
System.out.println("超类静态初始化块.n-------------");
}

static Print s2 = new Print("超类静态变量.n-------------");

}

class Class extends Super {

static Print s4 = new Print("静态变量.n-------------");

static {
System.out.println("静态初始化块.n-------------");
}

public Class() {
System.out.println("构造器.n-------------");
}

Print s3 = new Print("变量.n-------------");
{
System.out.println("初始化块.n-------------");
}
}

class Print {
public Print(String s) {
System.out.println(s);
}
}

public class ClassInitializtion {
public static void main(String[] args) {
new Class();
}
}

public class InitialOrderTest {
        public static String staticField = "静态变量";//(1)静态的全局变量

        public String field = "变量";//（2）非静态成员变量
        
        static {//（3）静态代码块
                System.out.println(staticField);
                System.out.println("静态初始化块");
        }

        {//（4）构造代码块
                System.out.println(field);
                System.out.println("初始化块");
        }

        public InitialOrderTest() {//（5）构造函数
                System.out.println("构造器");
        }
        public static void main(String[] args) {
                new InitialOrderTest();
        }
}
(1)静态的变量：随着类的加载而加载，优先于对象存在。只执行一次，并先于主函数。在静态代码块中，上面的程序是“  System.out.println(staticField);System.out.println("静态初始化块");”
      所以首先输出的是："静态变量"，"静态初始化块"
（2）构造代码块：作用给对象进行初始化，运行时间：对象一建立就运行，而且优先于构造函数，在构造代码块中，程序是“ System.out.println(field); System.out.println("初始化块");”
     所以输出的顺序是："变量","初始化块"
   构造函数和构造代码块的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，构造代码块中定义的是不同对象共性的初始化内容。
（3）构造函数：输出：“构造器”
上面的运行结果如下：
静态变量
静态初始化块
变量
初始化块
构造器