面向对象-父类、子类、静态代码初始化顺序!

2023-12-30 18:54:33
初始化顺序

类初始化顺序

代码

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;
        }
    }
}

结论

  1. 实例化一个对象:先加载静态代码块,后加载非静态代码块
  2. 实例化子类对象:父类静态——>子类静态——>父类非静态——>父类构造——>子类非静态——>子类构造;
  3. 实例化多个子类对象:父类静态代码块只执行一次,非静态和构造都执行多次;
  4. 调用子类静态变量:父类静态代码块->子类静态代码块->静态变量
  5. 实例化子类对象

文章来源:https://blog.csdn.net/CSDN_WHO/article/details/135307375
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。