Java面试中经常遇到的类执行顺序



单类执行顺序：

下面是我写的一个demo：

package com.bw;
/** * @author brickworker * 关于类Color的描述：测试单个类的执行顺序问题 */
public classColor {
    //构造函数
    public Color() {
        System.out.println("构造函数执行");
    }
    //静态代码块
    static{
        System.out.println("静态代码块执行");
    }
    //非静态代码块
    {
        System.out.println("非静态代码块执行");
    }
    //一般方法
    void run(){
        System.out.println("一般方法执行");
    }
    public staticvoid main(String[] args) { System.out.println("main方法执行");//这个一定要写在最上面，程序一进入马上就执行，不然会导致结果不准确
        Color color = new Color();
        color.run();
    }
}
//执行结果：
//静态代码块执行
//main方法执行
//非静态代码块执行
//构造函数执行
//一般方法执行 

真的觉得是对的么？因为我们main的入口写在了类本身之中。导致结果其实是不准确的。我们换个方式，信建立一个Rundemo来触发执行：

package com.bw;

public class RunDemo {

    public static void main(String[] args) {
        System.out.println("main方法执行");//这个一定要写在最上面，程序一进入马上就执行，不然会导致结果不准确
        Color color = new Color();
        color.run();
    }
}
//执行结果：
//main方法执行
//静态代码块执行
//非静态代码块执行
//构造函数执行
//一般方法执行

是吧，是不是main方法执行顺序跑到最前面去了呢？前面一种情况是因为main方法放在了目标类中，如果要执行这个main方法，虚拟机会先初始化这个主类，所以会先执行static静态代码块，关于这部分，以后我会写一篇关于虚拟机类加载机制的博文。总之，在看面试题的时候一定要看清楚main方法到底是放在哪里。

继承类执行顺序：

接下来，我们看看继承的情况是如何的，以下是我写的一个继承的demo,这里要强调一点，有写小伙伴为了看的更清楚，父类用system.err.println来打印，导致结果不同，两种输出方式是存在很大差别的，而且实验一定要建立在公平公正的前提下：

//父类
package com.bw;

/** * * @author brickworker * 关于类Father的描述：测试继承执行顺序父类 */
public classFather {
    //构造函数
    public Father() {
        System.out.println("父类构造函数执行");
    }
    //静态代码块
    static{
        System.out.println("父类静态代码块执行");
    }
    //非静态代码块
    {
        System.out.println("父类非静态代码块执行");
    }
    //一般方法
    void run(){
        System.out.println("父类一般方法");
    }
}
//子类
package com.bw;
/** * * @author brickworker * 关于类Son的描述：测试继承执行顺序子类 */
public classSon extends Father{
    //构造函数
    public Son() {
        System.out.println("子类构造方法");
    }
    //静态代码块
    static{
        System.out.println("子类静态代码块");
    }
    //非静态代码块
    {
        System.out.println("子类非静态代码块");
    }
    //子类重写一般方法
    @Override
    void run() {
        System.out.println("子类重写一般方法执行");
    }
    public staticvoid main(String[] args) {
        System.out.println("main方法执行");
        Son son = new Son();
        son.run();
    }
}
//执行顺序：
//父类静态代码块执行
//子类静态代码块
//main方法执行
//父类非静态代码块执行
//父类构造函数执行
//子类非静态代码块
//子类构造方法
//子类重写一般方法执行

现在，我们把main方法单独拿出来，和上面一样，看看执行结果：

main方法执行
父类静态代码块执行
子类静态代码块
父类非静态代码块执行
父类构造函数执行
子类非静态代码块
子类构造方法
子类重写一般方法执行

总结一下：标准的执行顺序是：当前主程序>父类静态代码块>子类静态代码块>父类非静态代码块>父类构造函数>子类非静态代码块>子类构造方法>子类一般方法。那么把上面的顺序中关于父类执行的去掉，其实也符合我们前面讨论的单个类执行顺序。

注意了！注意了！（敲黑板），上面的也许大家在别的文章中看了不止一遍，那么下面的特殊情况你可能就不太清楚了，因为出现的少，但是我们一次看个透彻。

特殊执行顺序：

其实在类加载机制中，类加载存在主动加载和被动加载（可以不用知道，对下面文章理解不妨碍，只是希望知其然更要知其所以然），在被动加载过程中很多并不会触发初始化，所以在判断被动引用的时候，执行顺序会难很多，主要分为3中情况来具体说明：

一、通过子类调用了父类的静态字段，子类不会被初始化

//父类
package com.bw;
/** * * @author brickworker * 关于类Father的描述：测试继承执行顺序父类 */
public classFather {
    public staticint father = 100;
    //静态代码块
    static{
        System.out.println("父类静态代码块执行");
    }
}
//子类
package com.bw;
/** * * @author brickworker * 关于类Son的描述：测试继承执行顺序子类 */
public classSon extends Father{
    static{
        System.out.println("子类静态代码块");
    }
}
//测试类：
package com.bw;
public classRunDemo {
    public staticvoid main(String[] args) {
        System.out.println("main方法执行");
        System.out.println(Son.father);//用子类去调去父类的静态字段
    }
}
//执行结果：
//main方法执行
//父类静态代码块执行
//100

从上面可以看出，子类的静态代码都没有执行，说明子类完全没有初始化。

二、类作为数组的组件类型不会触发类初始化：

借用上面单类的Color类：

package com.bw;
public classRunDemo {
    public staticvoid main(String[] args) {
        System.out.println("main方法执行");
        Color[] colors = new Color[5];
    }
}
//执行结果：
//main方法执行

上面用Color做为数组的组件，没有执行color的静态方法，说明也没有被初始化。

package com.bw;
/** * @author brickworker * 关于类Color的描述：测试单个类的执行顺序问题 */
public classColor {
    public staticfinal String color = "red";//新增一段常量，编译阶段户直接放入常量池
    //静态代码块
    static{
        System.out.println("静态代码块执行");
    }
}

//
package com.bw;
public classRunDemo {
    public staticvoid main(String[] args) { System.out.println("main方法执行");
        System.out.println(Color.color);
    }
}
//执行结果：
//main方法执行
//red
从上面的结果可以看出，虽然调用了red，但是并有执行color的静态代码块，说明它没有被初始化。

三、常量池引用也会导致不初始化类