静态代码块、静态变量、构造代码块、构造方法的执行顺序

最近项目经理要我整理一下java基础，找个重点讲一下，刚好最近在研究关于静态static的东西，所以拿出来先分享一下。

首先讲一下java中有关静态代码块、静态变量、构造代码块、构造方法的定义。

静态代码块：直接在类中定义的并且加了static关键字的代码块{}，静态代码块是在类加载时自动执行的一段语句。形如：

public class Test
{
  static {
    //.......
  }
}

静态变量：被static修饰的变量。形如：

static int num = 1;

构造代码块：直接在类中定义的没有加static关键字的代码块{}。   

public class Test
{
  {
    //.......
  }
}

构造方法：

public class Test
{
  Test()
  {
    //无参构造方法
  }
  Test(int i)
  {
    //有参构造方法
  }
}

然后开始我们的实验。

1、对于一个类里的静态变量和静态代码块，执行的顺序是谁在前先执行谁。

测试代码：

Test4.java

public class Test4 
{
public static int no = 1;
public static int num1 = 6;
static {
if(num1 == 6)
System.out.println("第" + (no++) + "次加载静态变量");
System.out.println("第" + (no++) + "次加载静态代码块");
}
public static int num2 = 10;
static {
if(num2 == 10)
System.out.println("第" + (no++) + "次加载静态变量");
System.out.println("第" + (no++) + "次加载静态代码块");
}

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

}

测试结果：

第1次加载静态变量
第2次加载静态代码块
第3次加载静态变量
第4次加载静态代码块

2、对于一个类里的静态代码块(静态变量)、构造代码块、构造方法的执行顺序为：
静态代码块(静态变量)>实例化[构造代码块]>实例化[构造方法] 测试代码： Test5.java

public class Test5 
{
public static int no = 1;

{
System.out.println("第" + (no++) + "次加载构造代码块");
}

static {
System.out.println("第" + (no++) + "次加载静态代码块");
}

Test5()
{
System.out.println("第" + (no++) + "次加载构造方法");
}

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

}

测试结果：

第1次加载静态代码块
第2次加载构造代码块
第3次加载构造方法

3、对于有继承关系的父类子类中的静态代码块(静态变量)、构造代码块、构造方法的执行顺序为：
父类静态代码块(静态变量)>子类的静态代码块(静态变量)>父类构造代码块>父类构造方法>子类构造代码块>子类构造方法 测试代码： TestParent.java

public class TestParent 
{
{
System.out.println("这是父类的构造代码块");
}

static {
System.out.println("这是父类的静态代码块");
}

TestParent()
{
System.out.println("这是父类的构造方法");
}
}

TestChild.java

public class TestChild extends TestParent
{
{
System.out.println("这是子类的构造代码块");
}

static {
System.out.println("这是子类的静态代码块");
}

TestChild()
{
System.out.println("这是子类的构造方法");
}
}

Test6.java

public class Test6 
{
public static void main(String args[])
{
new TestChild();
}
}

测试结果：

这是父类的静态代码块
这是子类的静态代码块
这是父类的构造代码块
这是父类的构造方法
这是子类的构造代码块
这是子类的构造方法

其中静态代码块(静态变量)和静态方法的区别在于静态代码块是自动执行，而静态方法则是被调用的时候才执行。
4、对于静态变量和静态代码块，自动执行且只执行一次。
构造代码块和构造方法是实例化几次执行几次。注意是实例化，不是声明，声明不会执行构造代码块和构造方法 测试代码： Test7.java

public class Test7 
{
public static int no = 1;
static {
if(no == 1)
System.out.println("第" + (no++) + "次加载静态变量");
System.out.println("第" + (no++) + "次加载静态代码块");
}

{
System.out.println("第" + (no++) + "次加载构造代码块");
}

Test7()
{
System.out.println("第" + (no++) + "次加载构造方法");
}

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

测试结果：

第1次加载静态变量
第2次加载静态代码块
第3次加载构造代码块
第4次加载构造方法
第5次加载构造代码块
第6次加载构造方法

特殊情况1、当类里面声明并实例化一个自己的静态类，对于当前的静态变量而言，如果静态变量在静态类之前，则先执行静态变量；如果静态变量在静态类之后，则绕开静态变量，执行静态类里面的构造代码块和构造方法：
静态类[构造代码块]>静态类[构造方法]>当前类[静态代码块(静态变量)]>实例化[构造代码块]>实例化[构造方法] 测试代码： Test8.java

public class Test8   
{  
    public static int no = 1; 
    public static Test8 t8 = new Test8();  
    
    static {  
        if(no == 1)  
            System.out.println("第" + (no++) + "次加载静态变量");  
        System.out.println("第" + (no++) + "次加载静态代码块");  
    }  
      
    {  
        System.out.println("第" + (no++) + "次加载构造代码块");  
    }  
      
    Test8()  
    {  
        System.out.println("第" + (no++) + "次加载构造方法");  
    }  
      
    public static void main(String args[])  
    {  
        new Test8();  
    }  
}  

测试结果：

第1次加载构造代码块
第2次加载构造方法
第3次加载静态代码块
第4次加载构造代码块
第5次加载构造方法

Test8.java(1)

public class Test8   
{  

    public static Test8 t8 = new Test8();
    public static int no = 1; 

    static {  
        if(no == 1)  
            System.out.println("第" + (no++) + "次加载静态变量");  
        System.out.println("第" + (no++) + "次加载静态代码块");  
    }  

    {  
        System.out.println("第" + (no++) + "次加载构造代码块" );  
    }  

    Test8()  
    {  
        System.out.println("第" + (no++) + "次加载构造方法");  
    }  

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

测试结果：

第0次加载构造代码块
第1次加载构造方法
第1次加载静态变量
第2次加载静态代码块
第3次加载构造代码块
第4次加载构造方法

注意：这里之所以加载构造代码块的序号为0，是因为静态变量在静态类之后，而在静态类执行的时候，是不执行静态变量、静态代码块的，但是，会对静态变量进行声明，虽然能访问到no这个变量，但是没有初始化，所以为0。当加载构造方法时因为 no自增加了1，所以值变为1。但是当执行完静态类以后，no变量又被初始化为1。这也进一步验证了静态变量、静态代码块只执行一次。
特殊情况2、当类里面声明并实例化一个具有父类的自己的静态类，则该类的执行顺序为:
父类的静态代码块(静态变量)>父类的构造代码块>父类的构造方法>子类的构造代码块>子类的构造方法>子类的静态代码块(静态变量) 测试代码： TestParent.java

public class TestParent 
{
{
System.out.println("这是父类的构造代码块");
}

static {
System.out.println("这是父类的静态代码块");
}

TestParent()
{
System.out.println("这是父类的构造方法");
}
}

TestChild1.java

public class TestChild1 extends TestParent
{
public static TestChild1 tc1 = new TestChild1();
{
System.out.println("这是子类的构造代码块");
}

static {
System.out.println("这是子类的静态代码块");
}

TestChild1()
{
System.out.println("这是子类的构造方法");
}

public static void main(String args[])
{

}
}

测试结果：

这是父类的静态代码块
这是父类的构造代码块
这是父类的构造方法
这是子类的构造代码块
这是子类的构造方法
这是子类的静态代码块

特殊情况3、当类里面声明并实例化一个不是当前类的静态类，则该类的执行顺序为:
静态类[静态代码块(静态变量)]>静态类[构造代码块]>静态类[构造方法]>当前类[静态代码块(静态变量)] 测试代码： Test9.java

public class Test9 {
public static Test10 t10;
public static Test10 t11 = new Test10();
public static int no = 1;
static {
if(no == 1)
System.out.println("第" + (no++) + "次加载静态变量");
System.out.println("第" + (no++) + "次加载静态代码块");
}

{
System.out.println("第" + (no++) + "次加载构造代码块");
}

Test9()
{
System.out.println("第" + (no++) + "次加载构造方法");
}

public static void main(String args[])
{

}

}

Test10.java

public class Test10 
{
public static int no = 1;
static {
if(no == 1)
System.out.println("第" + (no++) + "次加载静态变量");
System.out.println("第" + (no++) + "次加载静态代码块");
}

{
System.out.println("第" + (no++) + "次加载构造代码块");
}

Test10()
{
System.out.println("第" + (no++) + "次加载构造方法");
}

}

测试结果：

第1次加载静态变量
第2次加载静态代码块
第3次加载构造代码块
第4次加载构造方法
第1次加载静态变量
第2次加载静态代码块

这里可以看出，如果实例化的静态类不是当前类，那么该静态类的执行顺序还是正常的，也就是说不会绕开静态代码块和静态变量。注意，这里如果没有实例化而只是声明了静态类，那么该静态类不会执行任何语句。
总结： 1、不考虑特殊情况，类的执行顺序为静态代码块(静态变量)>构造代码块>构造方法 2、特殊情况中，在类里面实例化自己的静态类这种情况在实际编码中极少出现，所以也不太需要考虑这种情况。