Java面试中经常遇到的类执行顺序
引言：
记得以前面试的时候，会直接给一段代码，这段代码很多地方都有print，所以让我写出现打印出什么，后打印出什么。今天我整理一下单类的情况，继承的情况和一些特殊情况，希望大家看了之后，在面试过程中举一反三，成功规避错误。笔者目前整理的一些blog针对面试都是超高频出现的。大家可以点击链接：http://blog.csdn.net/u012403290
单类执行顺序：
下面是我写的一个demo：
package com.bw;
/**
* @author brickworker
* 关于类Color的描述：测试单个类的执行顺序问题
*/
public class Color {
//构造函数
public Color() {
System.out.println("构造函数执行");
}
//静态代码块
static{
System.out.println("静态代码块执行");
}
//非静态代码块
{
System.out.println("非静态代码块执行");
}
//一般方法
void run(){
System.out.println("一般方法执行");
}
public static void main(String[] args) {
System.out.println("main方法执行");//这个一定要写在最上面，程序一进入马上就执行，不然会导致结果不准确
Color color = new Color();
color.run();
}
}
//执行结果：
//静态代码块执行
//main方法执行
//非静态代码块执行
//构造函数执行
//一般方法执行
- 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
- 40
- 41
- 42
- 43
- 44
- 45
真的觉得是对的么？因为我们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方法执行
//静态代码块执行
//非静态代码块执行
//构造函数执行
//一般方法执行
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
是吧，是不是main方法执行顺序跑到最前面去了呢？前面一种情况是因为main方法放在了目标类中，如果要执行这个main方法，虚拟机会先初始化这个主类，所以会先执行static静态代码块，关于这部分，以后我会写一篇关于虚拟机类加载机制的博文。总之，在看面试题的时候一定要看清楚main方法到底是放在哪里。
继承类执行顺序：
接下来，我们看看继承的情况是如何的，以下是我写的一个继承的demo,这里要强调一点，有写小伙伴为了看的更清楚，父类用system.err.println来打印，导致结果不同，两种输出方式是存在很大差别的，而且实验一定要建立在公平公正的前提下：
//父类
package com.bw;
/**
*
* @author brickworker
* 关于类Father的描述：测试继承执行顺序父类
*/
public class Father {
//构造函数
public Father() {
System.out.println("父类构造函数执行");
}
//静态代码块
static{
System.out.println("父类静态代码块执行");
}
//非静态代码块
{
System.out.println("父类非静态代码块执行");
}
//一般方法
void run(){
System.out.println("父类一般方法");
}
}
//子类
package com.bw;
/**
*
* @author brickworker
* 关于类Son的描述：测试继承执行顺序子类
*/
public class Son extends Father{
//构造函数
public Son() {
System.out.println("子类构造方法");
}
//静态代码块
static{
System.out.println("子类静态代码块");
}
//非静态代码块
{
System.out.println("子类非静态代码块");
}
//子类重写一般方法
@Override
void run() {
System.out.println("子类重写一般方法执行");
}
public static void main(String[] args) {
System.out.println("main方法执行");
Son son = new Son();
son.run();
}
}
//执行顺序：
//父类静态代码块执行
//子类静态代码块
//main方法执行
//父类非静态代码块执行
//父类构造函数执行
//子类非静态代码块
//子类构造方法
//子类重写一般方法执行
- 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
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
现在，我们把main方法单独拿出来，和上面一样，看看执行结果：
main方法执行
父类静态代码块执行
子类静态代码块
父类非静态代码块执行
父类构造函数执行
子类非静态代码块
子类构造方法
子类重写一般方法执行
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
总结一下：标准的执行顺序是：当前主程序>父类静态代码块>子类静态代码块>父类非静态代码块>父类构造函数>子类非静态代码块>子类构造方法>子类一般方法。那么把上面的顺序中关于父类执行的去掉，其实也符合我们前面讨论的单个类执行顺序。
注意了！注意了！（敲黑板），上面的也许大家在别的文章中看了不止一遍，那么下面的特殊情况你可能就不太清楚了，因为出现的少，但是我们一次看个透彻。
特殊执行顺序：
其实在类加载机制中，类加载存在主动加载和被动加载（可以不用知道，对下面文章理解不妨碍，只是希望知其然更要知其所以然），在被动加载过程中很多并不会触发初始化，所以在判断被动引用的时候，执行顺序会难很多，主要分为3中情况来具体说明：
一、通过子类调用了父类的静态字段，子类不会被初始化
//父类
package com.bw;
/**
*
* @author brickworker
* 关于类Father的描述：测试继承执行顺序父类
*/
public class Father {
public static int father = 100;
//静态代码块
static{
System.out.println("父类静态代码块执行");
}
}
//子类
package com.bw;
/**
*
* @author brickworker
* 关于类Son的描述：测试继承执行顺序子类
*/
public class Son extends Father{
static{
System.out.println("子类静态代码块");
}
}
//测试类：
package com.bw;
public class RunDemo {
public static void main(String[] args) {
System.out.println("main方法执行");
System.out.println(Son.father);//用子类去调去父类的静态字段
}
}
//执行结果：
//main方法执行
//父类静态代码块执行
//100
- 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
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
从上面可以看出，子类的静态代码都没有执行，说明子类完全没有初始化。
二、类作为数组的组件类型不会触发类初始化：
借用上面单类的Color类：
package com.bw;
public class RunDemo {
public static void main(String[] args) {
System.out.println("main方法执行");
Color[] colors = new Color[5];
}
}
//执行结果：
//main方法执行
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
上面用Color做为数组的组件，没有执行color的静态方法，说明也没有被初始化。
三、常量池引用也会导致不初始化类
package com.bw;
/**
* @author brickworker
* 关于类Color的描述：测试单个类的执行顺序问题
*/
public class Color {
public static final String color = "red";//新增一段常量，编译阶段户直接放入常量池
//静态代码块
static{
System.out.println("静态代码块执行");
}
}
//
package com.bw;
public class RunDemo {
public static void main(String[] args) {
System.out.println("main方法执行");
System.out.println(Color.color);
}
}
//执行结果：
//main方法执行
//red
- 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
从上面的结果可以看出，虽然调用了red，但是并有执行color的静态代码块，说明它没有被初始化。
综上所述，如果把类加载时机和顺序进行结合，那么这样的面试题可能就会难倒一大批人，所以合理分析和总结是非常重要的。关于为什么后面类没有初始化，我想后面如果写java虚拟机类加载机制的时候我们再一起探究下。
好啦，如果你看到了这里，谢谢你对我辛苦劳动肯定，同时祝愿你学习进步，事业顺心。