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

静态代码块和构造代码块结构如下： 
static { 
静态语句代码块 
} 

{ 构造代码块 } 

特点：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。而构造代码块随着对象的创建而执行，每创建一次对象就执行一次构造代码块。优先级：静态代码块>构造代码块(普通初始化块)>构造方法。

public class Test_Static_Class {  
    //静态代码块  
    static {  
         
       System.out.println("静态代码块");  
   }  
   {  
       System.out.println("普通代码块1");  
   }  
   
   public   Test_Static_Class() {  
       System.out.println("执行了构造方法");  
}  
   //普通的成员方法  
   public void test() {  
       System.out.println("在方法中的普通代码块");  
       //普通的代码块  
       {  
           System.out.println("普通代码块");  
       }  
        
}  
   public static void main(String[] args) {  
    System.out.println("执行了主方法");  
    System.out.println("--------------------");  
    new Test_Static_Class();  
    System.out.println("------第二次创建对象---------------");  
    new Test_Static_Class();  
    System.out.println("------第三次创建对象---------------");  
    new Test_Static_Class().test();  
}  
   
   {  
       System.out.println("普通代码块2");  
   }  
}  

1. 多次创建对象，静态代码块只执行一次，且最先执行。

2. 接下来执行的是非静态语句代码块(即：构造代码块) ，会每创建一个对象执行一次，且多个构造代码块会由上到下的执行。

3. 在接下来执行的是构造方法，构造方法也是每创建一个对象就会执行一次。

4. 在接下来就是调用普通的方法中的代码块，执行的顺序，在方法中没有什么特殊的。

对于静态属性，与静态代码块一样，也是在类加载时就会被自动执行，属于整个类的属性。

　　静态方法只能直接访问静态成员，不能直接访问非静态成员，如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来间接的访问非静态变量. 对于静态方法中也不能直接使用this对象。

 

若有继承的情况：

 

public class Demo {
    public static class ClassA {
        public ClassA() {
            System.out.println("ClassA");
        }
        
        static  {
            System.out.println("static A class");
        }
        
        {
            System.out.println("A class");
        }
    }
    
    public static class ClassB  extends ClassA {
        public ClassB() {
            super();
            System.out.println("ClassB");
        }
        
        static {
            System.out.println("static B class");
        }
        
        {
            System.out.println("B class");
        }
        public void print() {
            System.out.println("B print");
        }
    }
    
    public static void main(String []args) {
        new ClassB();
    }
    
    static  {
        System.out.println("static Demo class");
    }
    
    {
        System.out.println("Demo class");
    }

}

 

结果：

static Demo class
static A class
static B class
A class
ClassA
B class
ClassB

原因：首先加载Demo类文件，执行Demo类中的static代码块；执行main函数中的new ClassB()，因为继承ClassA，加载ClassA，执行ClassA中的static代码块->加载ClassB，执行ClassB中的static代码块；

执行classA的构造代码块->执行classA的构造函数->执行classB的构造代码块->执行classB的构造函数

public class Demo {
    public static class ClassA {
        public ClassA() {
            System.out.println("ClassA");
        }
    }
    
    static  {
        System.out.println("static A class");
    }
    
    {
        System.out.println("A class");
    }
    
    public static class ClassB  {
        public ClassB() {
            System.out.println("ClassB");
        }
        
        static {
            System.out.println("static B class");
        }
        
        {
            System.out.println("B class");
        }
        public void print() {
            System.out.println("B print");
        }
    }
    
    public static void main(String []args) {
        new ClassB();
    }

}

让ClassB不在继承ClassA

结果：

 

public class ExA {  
    static {  
        System.out.println("父类--静态代码块");  
    }  
   
    public ExA() {  
        System.out.println("父类--构造函数");  
    }  
   
    {  
        System.out.println("父类--非静态代码块");  
    }  
   
    public static void main(String[] args) {  
        new ExB();  
    }  
}  
   
class ExB extends ExA {  
    static {  
        System.out.println("子类--静态代码块");  
    }  
    {  
        System.out.println("子类--非静态代码块");  
    }  
   
    public ExB() {  
        System.out.println("子类--构造函数");  
    }  
} 

结果：

父类--静态代码块
子类--静态代码块
父类--非静态代码块
父类--构造函数
子类--非静态代码块
子类--构造函数

 

若一个类(用B表示)继承其他类(用A表示)，则在new B()时，执行A的静态代码块(只执行一次)--->执行B的静态代码块(只执行一次)——>执行A的非静态代码块——>A的构造方法——>执行B的非静态代码块——>B的构造方法。