Java面试系列（一）：代码的执行顺序

转：http://raising.iteye.com/blog/2377707
1、静态代码块、构造代码块、普通代码块和构造函数的执行顺序

静态代码块：在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。

构造代码块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。

普通代码块：在方法或语句中出现的{}就称为普通代码块。普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定–“先出现先执行”

构造函数：也称构造器，和类同名，没有返回类型。（void也没有）

那么他们的执行顺序如何呢？用一个小例子可以了解~

Java代码 收藏代码

class A {  
    {  
        System.out.println("我是构造代码块=======");  
    }  

    static {  
        System.out.println("我是静态代码块=======");  
    }  

    A() {  
        System.out.println("我是构造函数=========");  
    }  

    public void test() {  
        System.out.println("我是普通代码块=========");  
    }  

        public static void main(String[] args) {  
        System.out.println("我是main普通代码块=========");  
    }  
}  

我们先运行A本身：

我是静态代码块=======

我是main普通代码块=========

我们再用另一个类调用下：

Java代码 收藏代码

A a = new A();  
a.test();  
System.out.println();  
A a1 = new A();  
a1.test();  

打印结果：

我是静态代码块=======

我是构造代码块=======

我是构造函数=========

我是普通代码块=========

我是构造代码块=======

我是构造函数=========

我是普通代码块=========

由此可见：每个类的静态代码块只会执行一次，无论你初始化多少次；而构造代码块、构造函数是每初始化一次就执行一次的。

执行顺序：静态代码块>构造代码块>构造方法>main方法（构造代码块和构造方法只有在被初始化的时候才会调用）

2、构造函数与继承

每个类都有一个默认的构造函数（不带参数），可以不用定义；但是当你重载了一个带参的构造函数，则默认的构造函数将会被覆盖，如果你想同时拥有默认的构造器和重载的带参的构造器，则默认构造器必须定义出来。

而构造函数的继承也是常见考点~也是比较蛋疼的地方。。

Java代码 收藏代码

class Aoo {  
    public Aoo() {  
        System.out.println("Aoo 默认构造器");  
    }  

    public Aoo(int i) {  
        System.out.println("Aoo 带参构造器:" + i);  
    }  

    public void test() {  
        System.out.println("Aoo 的test方法");  
    }  

    public void test(int i) {  
        System.out.println("Aoo 的test带参方法:" + i);  
    }  
}  

class Boo extends Aoo{  
    public Boo() {  
        System.out.println("Boo 默认构造器");  
    }  

    public Boo(int i) {  
        System.out.println("Boo 带参构造器:" + i);  
    }  

    public void test() {  
        System.out.println("Boo 的test方法");  
    }  

    public void test(int i) {  
        System.out.println("Boo 的test带参方法:" + i);  
    }  
}  

我们再调用：

Java代码 收藏代码

Boo boo = new Boo();//或Aoo boo = new Boo(); 结果都一样  
boo = new Boo(1);  
boo.test();  
boo.test(1);  

打印结果：

Aoo 默认构造器

Boo 默认构造器

Aoo 默认构造器

Boo 带参构造器:1

Boo 的test方法

Boo 的test带参方法:1

说明：

1）子类永远会默认继承父类的默认（不带参）的构造函数，子类每初始化一次，必然会调用一次父类的不带参的默认构造器。

2）当子类和父类都有相同方法声明的函数时，具体调用子类还是父类的方法是看初始化的谁，例如本例中是new B，而与变量类型无关；

3、重载和重写

重载：在一个类里，方法名相同，方法声明不同（参数声明不同，返回值类型也可能不同）；

重写：涉及继承，子类和父类拥有相同的方法名和方法声明，返回值类型必须是父类对应方法返回类型的子类。

重载是一个类里的多态性，重写是子类和父类的多态性体现~

我们先定义2个父子类：

Java代码 收藏代码

class Super {  
    public void t() {  
        System.out.println("Super t()");  
    }  
}   

class Sub extends Super {  
    public void t() {  
        System.out.println("Sub t()");  
    }  
}  

这里Sub子类重写了父类的t()方法，

我们再定义一个类，里面有重载的2个方法：

Java代码 收藏代码

class Goo {  
    public void test(Super obj) {  
        System.out.println("test Super");  
        obj.t();  
    }  

    public void test(Sub obj) {  
        System.out.println("test Sub");  
        obj.t();  
    }  
}  

再调用：

Java代码 收藏代码

Goo goo = new Goo();  
Super obj = new Sub();  
goo.test(obj);  

打印结果：

test Super

Sub t()

这说明：

1）Goo类里有重载的test方法，goo.test(obj);里的参数obj的类型是Super，所以调用的是Goo的第一个test方法；所以打印出：test Super

2）虽然Super obj = new Sub();但调用涉及重写的方法时，看的是真正实例化的类，这里虽然用父类Super定义，但实例化的是子类Sub，所以调用的子类的t()方法~