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

java中首先是静态块先执行，静态方法，最后是构造函数。示例如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

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( "子类--构造函数" );        }   }     执行结果  =====  父类--静态代码块  子类--静态代码块  父类--非静态代码块  父类--构造函数  子类--非静态代码块  子类--构造函数

---

1.父类、子类之间代码块与构造方法

package com.web.test2;

public class HelloA {
    static{
        System.out.println("static A");
    }

    {System.out.println("I'm A class");}

    public HelloA(){

        System.out.println("HelloA");
    }
    public HelloA(String s){

        System.out.println(s+"HelloA");
    }

    public static void main(String[] args) {
        new HelloB();
    }
}
 class HelloB extends HelloA{
    public HelloB () {
        //只能调用一个父类的构造方法
//      super();
        super("parent");
        System.out.println("HelloB");
    }
    {System.out.println("I'm B class");}
    static{
        System.out.println("static B");
    }


}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37

执行结果： 
static A 
static B 
I’m A class 
parentHelloA 
I’m B class 
HelloB

---

总结如下：

① 代码块于构造方法之前执行，静态于非静态之前；

② 在类第一次被调用时，加载该类，静态代码块只执行一次；

③ 项目启动时，只加载需要加载的类(比如xml中显示配置的bean，或者web.xml中的listener等)，并不会将所有的类都加载(这是很可怕的事情)；

④ 静态代码块只能调用静态变量；静态方法只能调用静态变量；

⑤ 非静态代码块或非静态方法可以调用任何(静态+非静态)变量。

⑥ 非静态代码块在实例化对象时，于构造方法之前执行。

---

2.父类、子类与super（）

public class People {
    String name;
    public People() {
        System.out.println(1);
    }
    public People(String name) {
        System.out.println(2);
        this.name = name;
    }
}
 class Child extends People{
     People father;
    public Child () {
        //super()系统会默认添加的
        System.out.println(4);
    }
    public Child (String name) {
        //super()系统会默认添加的
        System.out.println(3);
        this.name = name;
        father = new People(name+":F");
    }
    public static void main(String[] args) {
        new Child("mike");
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27

故执行结果：132

---

另外一个难缠的实例：

public class ExA {  
    private static ExA a = new 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 {  

    private static ExB b = new ExB();

    static {  
        System.out.println("子类--静态代码块");  
    }  
    {  
        System.out.println("子类--非静态代码块");  
    }  

    public ExB() {  
        System.out.println("子类--构造函数");  
    }  
}  

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34

• result as follows ：

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