java 执行顺序_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。

欢迎关注公众号交流！