阅读原文：Java 代码执行顺序
程序中代码执行的顺序非常重要，稍有不慎便会是程序运行出错，那么我将结合实例来分析代码中的执行。
名词解释
首先了解几个名词：
非静态代码块
直接由 {} 包起来的代码，称为非静态代码块
静态代码块
直接由 static {} 包起来的代码，称为静态代码块
形参
比如你定义一个函数 void add（int a, int b），这里的 a 和 b 就是形参。当你进行函数调用的时候，add（1, 2），这里的 1 和 2 就是实参。
向前引用
所谓向前引用，就是在定义类、接口、方法、变量之前使用它们。
成员变量
在类体里面定义的变量称为成员变量；
如果该成员变量有 static 关键字修饰，则该成员变量称为 静态变量 或 类变量；
如果该成员变量没有 static 关键字修饰，则该成员变量被称为 非静态变量 或 实例变量。
局部变量
形参、方法内定义的变量、代码块中定义的变量，都属于局部变量。
类变量（静态变量）
可以向前引用
变量属于类本身
类变量不依赖类的实例，类变量只在初始化时候在方法区中被分配一次空间，无论类的实例被创建几次，都不再为类变量分配空间
通过类的任意一个实例来访问类变量，底层都将将其转为通过类本身来访问类变量，它们的效果是一样的
一旦类变量的值被改变，通过类或类的任意一个实例来访问类变量，得到的都将是被改变后的值
将在类的初始化之前初始化
实例变量（非静态变量）
不能向前引用，如果向前引用，则称为非法向前引用，这是不允许的
变量属于类的实例对象
随着类的实例被创建而分配内存空间
实例演示
public class Parent {
public int parentNum=0;
public static int staticParentNum=0;
{
System.out.println(“Parent— 执行非静态代码块了 1！”);
}
{
System.out.println(“Parent— 执行非静态代码块了 2！”);
}
static{
System.out.println(“Parent— 执行静态代码块了 1！”);
}
static{
System.out.println(“Parent— 执行静态代码块了 2！”);
}
public Parent(){
System.out.println(“Parent— 无参构造函数！”);
}
public Parent(int parentNum){
this.parentNum=parentNum;
System.out.println(“Parent— 有参构造函数！”);
}
public void ParentMethod(int parentNum){
this.parentNum=parentNum;
System.out.println(“Parent— 非静态方法 /parentNum=”+parentNum);
}
public static void staticParentMethod(int staticParentNum){
Parent.staticParentNum=staticParentNum;
System.out.println(“Parent— 静态方法 /staticParentNum=”+staticParentNum);
}
}
public class Child extends Parent{
public int childNum=0;
public static int staticChildNum=0;
{
System.out.println(“Child— 执行非静态代码块了 1！”);
}
{
System.out.println(“Child— 执行非静态代码块了 2！”);
}
static{
System.out.println(“Child— 执行静态代码块了 1！”);
}
static{
System.out.println(“Child— 执行静态代码块了 2！”);
}
public Child(){
super();
System.out.println(“Child— 无参构造函数！”);
}
public Child(int childNum){
super(childNum);
System.out.println(“Child— 有参构造函数！”);
}
public void childMethod(int childNum){
this.childNum=childNum;
System.out.println(“Child– 非静态方法 /childNum=”+childNum);
}
public static void staticChildMethod(int staticChildNum){
Child.staticChildNum=staticChildNum;
System.out.println(“Child— 静态方法 /staticChildNum=”+staticChildNum);
}
}
package test;
public class Test {
// static{
// System.out.println(“Test— 静态代码块！”);
// }
public static void main(String[] args) {
int key=10;
switch (key) {
case 0:
Parent parent=new Parent();
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// Parent— 执行非静态代码块了 1！
// Parent— 执行非静态代码块了 2！
// Parent— 无参构造函数！
// 说明：先加载静态代码块，后加载非静态代码块
case 1:
Child b= new Child();
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// Child— 执行静态代码块了 1！
// Child— 执行静态代码块了 2！
// Parent— 执行非静态代码块了 1！
// Parent— 执行非静态代码块了 2！
// Parent— 无参构造函数！
// Child— 执行非静态代码块了 1！
// Child— 执行非静态代码块了 2！
// Child— 无参构造函数！
// 说明：创建子类，会先执行父类，先执行父类静态——> 子类静态——> 父类非静态——> 父类构造
//——> 子类非静态——> 子类构造
case 2:
Child c= new Child(4);
// 这个构造函数中指明了调用父类的有参构造函数，若不指定，则调用父类无参构造函数
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// Child— 执行静态代码块了 1！
// Child— 执行静态代码块了 2！
// Parent— 执行非静态代码块了 1！
// Parent— 执行非静态代码块了 2！
// Parent— 有参构造函数！
// Child— 执行非静态代码块了 1！
// Child— 执行非静态代码块了 2！
// Child— 有参构造函数！
说明：静态代码块或非静态代码块执行顺序，按照代码前后编写顺序。
case 3:
Child d= new Child();
Child e= new Child(4);
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// Child— 执行静态代码块了 1！
// Child— 执行静态代码块了 2！
// Parent— 执行非静态代码块了 1！
// Parent— 执行非静态代码块了 2！
// Parent— 无参构造函数！
// Child— 执行非静态代码块了 1！
// Child— 执行非静态代码块了 2！
// Child— 无参构造函数！
// Parent— 执行非静态代码块了 1！
// Parent— 执行非静态代码块了 2！
// Parent— 有参构造函数！
// Child— 执行非静态代码块了 1！
// Child— 执行非静态代码块了 2！
// Child— 有参构造函数！
说明：创建多个子类，但父类静态代码块只执行一次。
case 4:
Child.staticChildMethod(4);
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// Child— 执行静态代码块了 1！
// Child— 执行静态代码块了 2！
// Child— 静态方法 /staticChildNum=4
说明：静态方法只可以调用静态变量。
case 5:
Parent.staticParentMethod(5);
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// Parent— 静态方法 /staticParentNum=5
说明：静态方法可通过 父类名. 静态方法 () 调用。
case 6:
System.out.println(“ 父类的静态变量值 staticParentNum=”+Parent.staticParentNum);
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// 父类的静态变量值 staticParentNum=0
说明：调用静态变量时，静态代码块会执行。
case 7:
System.out.println(“ 子类的静态变量值 staticChildNum=”+Child.staticChildNum);
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// Child— 执行静态代码块了 1！
// Child— 执行静态代码块了 2！
// 子类的静态变量值 staticChildNum=0
说明：调用子类静态变量，父类静态代码块和子类静态代码块会被执行。
case 8:
System.out.println(“ 父类的静态变量值 staticParentNum=”+Parent.staticParentNum);
System.out.println(“ 子类的静态变量值 staticChildNum=”+Child.staticChildNum);
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// 父类的静态变量值 staticParentNum=0
// Child— 执行静态代码块了 1！
// Child— 执行静态代码块了 2！
// 子类的静态变量值 staticChildNum=0
case 9:
Child f= new Child();
f.ParentMethod(3);
break;
// Parent— 执行静态代码块了 1！
// Parent— 执行静态代码块了 2！
// Child— 执行静态代码块了 1！
// Child— 执行静态代码块了 2！
// Parent— 执行非静态代码块了 1！
// Parent— 执行非静态代码块了 2！
// Parent— 无参构造函数！
// Child— 执行非静态代码块了 1！
// Child— 执行非静态代码块了 2！
// Child— 无参构造函数！
// Parent— 非静态方法 /parentNum=3
说明：创建子类，用子类调用父类方法，非静态方法可以调用静态变量。
default:
break;
}
}
}
总结
Java 代码初始化顺序
由 static 关键字修饰的（如：类变量 (静态变量)、静态代码块）将在类被初始化创建实例对象之前被初始化，而且是按顺序从上到下依次被执行。静态（类变量、静态代码块）属于类本身，不依赖于类的实例。
没有 static 关键字修饰的（如：实例变量 (非静态变量)、非静态代码块）初始化实际上是会被提取到类的构造器中被执行的，但是会比类构造器中的代码块优先执行到，非静态（实例变量、非静态代码块）的地位是相等的，它们将按顺序被执行。
类变量（静态变量）、实例变量（非静态变量）、静态代码块、非静态代码块的初始化时机
由 static 关键字修饰的（如：类变量 [静态变量]、静态代码块）将在类被初始化创建实例对象之前被初始化，而且是按顺序从上到下依次被执行；
没有 static 关键字修饰的（如：实例变量 [非静态变量]、非静态代码块）初始化实际上是会被提取到类的构造器中被执行的，但是会比类构造器中的 代码块优先执行到，其也是按顺序从上到下依次被执行。
容易混淆的一个知识点静态方法只允许直接访问静态成员，而实例方法中可以访问静态成员和实例成员，原因是类还没有实例化，所实例成员也没有被创建，静态方法中因此也不能用 this。