子父类之间的继承关系和代码的执行流程

1. 使用父类对象调用了子类创建了Son对象

Base base = new Son();

1. 父类代码

public class Base {
    /**
     * 父类无参构造方法
     */
    public Base() {
        System.out.println("父类构造方法执行");
        test();
    }

    // 父类成员方法
    public void test(){
        System.out.println("Base_test");
    }
}

2. 子类代码

public class Son extends Base {
    public static void main(String[] args) {
        Base base = new Son();
        base.test();
        /*base.test1();*/
    }

    // 子类构造方法
    public Son() {
        System.out.println("子类构造方法执行");
    }

    // 子类重写的父类成员方法
    public void test(){
        System.out.println("Son Test");
    }

    // 子类成员方法
    public void test1(){
        System.out.println("Son Test");
    }
}

代码执行流程如下：

父类构造方法执行
Son Test
子类构造方法执行
Son Test

1. Base base=new Son(); 是多态的表示形式。
2. 父类对象调用了子类创建了Son对象。
3. base可以调用子类中重写的父类方法
4. 此时base还是属于Base对象，base调用父类中没有的而子类中拥有的方法，编译不通过。

2. 子父类间的参数传递关系

待执行代码如下：

在这里插入代码片public class Demo {
    /**
     * 父类
     */
    class Super{
        // 成员变量
        int flag = 1;
        // 父类构造方法
        Super(){
            test();
        }

        // 父类成员方法
        void test(){
            System.out.println("Super.test flag = " + flag);
        }
    }

    class Sub extends Super{

        // 子类构造方法
        Sub(int i){
            // 子类可以使用（共有）父类的成员变量
            flag = i;
            System.out.println("Sub.Sub() flag = " + flag);
        }

        // 子类成员方法
        void test(){
            System.out.println("Sub.test() flag = " + flag);
        }
    }

    public static void main(String[] args) {
        new Demo().new Sub(5);
    }
}

流程分析

1. 执行main()方法。使用匿名对象 new 一个子类对象Sub
2. 在执行父类的构造方法之前就已经初始化了flag = 1。
3. 执行test()方法时，执行的是子类重写的test方法此时flag = 1,所以输出：Sub.test() flag = 1。
4. 之后再执行子类的有参构造方法，使flag = 5;所以输出：Sub.Sub() flag = 5。
5. 结果为：
   Sub.test() flag = 1
   Sub.Sub() flag = 5

测试代码：

public class Demo {
    /**
     * 父类
     */
    class Super{
        // 成员变量
        int flag = 1;
        // 父类构造方法
        Super(){
            System.out.println("父类构造方法执行");
            System.out.println(flag);
            test();
        }

        // 父类成员方法
        void test(){
            System.out.println("Super.test flag = " + flag);
        }
    }

    class Sub extends Super{

        // 子类构造方法
        Sub(int i){
            // 子类可以使用（共有）父类的成员变量
            System.out.println("子类构造方法执行");
            flag = i;
            System.out.println("Sub.Sub() flag = " + flag);
        }

        // 子类成员方法
        void test(){
            System.out.println("Sub.test() flag = " + flag);
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.new Sub(5);
    }
}

3. 关于子父类中成员变量的使用

待执行代码如下：

public class Base {
    //父类成员变量
    private String baseName = "base";
    // 父类构造方法
    public Base(){
        callName();
    }

    // 父类成员方法
    public void callName(){
        System.out.println(baseName);
    }
    
    //子类
    static class Sub extends Base{
        // 子类成员变量
        private String baseName = "sub";
        // 子类成员方法
        public void callName(){
            System.out.println(baseName);
        }
    }

    public static void main(String[] args) {
        Base b = new Sub();
    }
}

程序运行结果如下：

null

代码分析

1. 先初始化父类成员变量 baseName = “base”。
2. 再执行父类构造方法，调用callName()方法，该方法被子类重写，所以调用的是子类中的callName()方法。
3. 但是子类中的baseName = "sub"此时并没有完成初始化，所以baseName = null。
4. 因此代码执行的结果为：null

测试代码：

public class Base {
    //父类成员变量
    private String baseName = "base";
    // 父类构造方法
    public Base(){
        System.out.println("父类构造方法执行");
        System.out.println(baseName);
        callName();
    }

    // 父类成员方法
    public void callName(){
        System.out.println(baseName);
    }

    //子类
    static class Sub extends Base{
        // 子类成员变量
        private String baseName = "sub";
        // 子类成员方法
        public void callName(){
            System.out.println(baseName);
        }
    }

    public static void main(String[] args) {
        Base b = new Sub();
    }
}

4. 子父类的构造方法，代码块和静态代码块的执行顺序

具体测试代码如下：

public class BaseClass {
    // 父类构造方法
    public BaseClass(){
        System.out.println("父类构造方法");
    }

    //父类非静态代码块
    {
        System.out.println("父类非静态代码块");
    }

    // 父类静态代码块
    static {
        System.out.println("父类静态代码块");
    }


}

class Base extends BaseClass{

    // 子类构造方法
    public Base(){}
    {
        System.out.println("子类构造方法");
    }

    //子类非静态代码块
    {
        System.out.println("子类非静态代码块");
    }

    //子类静态代码块
    static {
        System.out.println("子类静态代码块");
    }

    public static void main(String[] args) {
        new Base();
    }
}

运行结果如下：

父类静态代码块
子类静态代码块
父类非静态代码块
父类构造方法
子类构造方法
子类非静态代码块