Java继承中的几道面试题

第一题：

/*
    看程序写结果：
        A:访问成员变量的原则：就近原则。
        B:this和super的问题：
            this     访问本类的成员
            super    访问父类的成员(可以理解为的)
        C:子类的所有构造方法执行前默认先执行父类的无参构造方法。
        D:一个类的初始化过程：
            成员变量进行初始化过程如下：
                默认初始化
                显示初始化
                构造方法初始化
                
    输出的结果是：
        　　　　fu
        　　　　zi
        　　　　30
        　　　　20
        　　　　10
*/
class Fu {
    public int num = 10;
    public Fu() {
        System.out.println("fu");
    }
}

class Zi extends Fu {
    public int num = 20;
    public Zi() {
        System.out.println("zi");
    }
    public void show() {
        int num = 30;
        System.out.println(num); //30
        System.out.println(this.num); //20
        System.out.println(super.num); //10
    }
}
class ExtendsTest {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

第二题：

/*
    看程序写结果：
        A:一个类的静态代码块,构造代码块,构造方法的执行流程：
            静态代码块 > 构造代码块 > 构造方法
        B:静态的内容是随着类的加载而加载，
            即：静态代码块的内容会优先执行。
        C:构造代码块
　            在类中方法外出现(即在类中的成员位置)，可以把多个构造方法方法中相同的代码存放到一起，用于对对象进行初始化，
            每次调用构造方法都执行，并且在构造方法前执行。
        C:子类的所有的构造方法默认都会去访问父类的无参构造方法。
        
    输出结果是：
        　　静态代码块Fu
        　　静态代码块Zi
        　　构造代码块Fu
        　　构造方法Fu
        　　构造代码块Zi
       　　 构造方法Zi
*/
class Fu {
    static {
        System.out.println("静态代码块Fu");
    }

    {
        System.out.println("构造代码块Fu");
    }

    public Fu() {
        System.out.println("构造方法Fu");
    }
}

class Zi extends Fu {
    static {
        System.out.println("静态代码块Zi");
    }

    {
        System.out.println("构造代码块Zi");
    }

    public Zi() {
        System.out.println("构造方法Zi");
    }
}

class ExtendsTest2 {
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}

第三题：

/*
    看程序写结果：
        A:成员变量的问题
            int x = 10; //成员变量x是基本类型
            Student s = new Student(); //成员变量s是引用类型
        B:一个类的初始化过程
            先进行成员变量的初始化：
                默认初始化
                显示初始化
                构造方法初始化
        C:子父类的初始化(分层初始化)
            先进行父类初始化，然后进行子类初始化。
            
    结果：
        YXYZ
        
    问题：
        虽然子类中的构造方法默认有一个 super();
        但初始化的时候，不是按照那个顺序进行的。
        而是按照分层初始化进行的。
        super(); 它仅仅表示要先初始化父类数据，再初始化子类数据。
*/

class X {
    //成员变量(引用类型)
    Y b = new Y();
    //无参构造方法
    X() {
        System.out.print("X");
    }
}

class Y {
    //无参构造方法
    Y() {
        System.out.print("Y");
    }
}

public class Z extends X {
    //成员变量(引用类型)
    Y y = new Y();
    //无参构造方法
    Z() {
        //super(); //它仅仅表示要先初始化父类数据，再初始化子类数据。
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z(); 
    }
}