Java代码执行顺序

时间 2019-12-05

标签 java 代码执行顺序栏目 Java 繁體版

原文原文链接

程序中代码执行的顺序很是重要，稍有不慎便会是程序运行出错，那么我将结合实例来分析代码中的执行。函数

名词解释

首先了解几个名词：this

非静态代码块

直接由 { } 包起来的代码，称为非静态代码块

静态代码块

直接由 static { } 包起来的代码，称为静态代码块

形参

好比你定义一个函数void add（int a, int b），这里的a和b就是形参。
当你进行函数调用的时候，add（1, 2），这里的1和2就是实参。spa

向前引用

所谓向前引用，就是在定义类、接口、方法、变量以前使用它们。code

成员变量

在类体里面定义的变量称为成员变量；
若是该成员变量有 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。

欢迎关注公众号交流！
对象