Java继承中的几道面试题

第一题：

/*
 看程序写结果：  3  A:访问成员变量的原则：就近原则。  4  B:this和super的问题：  5  this 访问本类的成员  6  super 访问父类的成员(可以理解为的)  7  C:子类的所有构造方法执行前默认先执行父类的无参构造方法。  8  D:一个类的初始化过程：  9  成员变量进行初始化过程如下： 10  默认初始化 11  显示初始化 12  构造方法初始化 13                 
 输出的结果是： 15  　　　　fu 16  　　　　zi 17  　　　　30 18  　　　　20 19  　　　　10 20 */
class Fu { 22     public int num = 10; 23     public Fu() { 24         System.out.println("fu"); 25  } 26 } 27 
class Zi extends Fu { 29     public int num = 20; 30     public Zi() { 31         System.out.println("zi"); 32  } 33     public void show() { 34         int num = 30; 35         System.out.println(num); //30
        System.out.println(this.num); //20
        System.out.println(super.num); //10
 } 39 } 40 class ExtendsTest { 41     public static void main(String[] args) { 42         Zi z = new Zi(); 43  z.show(); 44  } 45 }

第二题：

/*
 看程序写结果：  3  A:一个类的静态代码块,构造代码块,构造方法的执行流程：  4  静态代码块 > 构造代码块 > 构造方法  5  B:静态的内容是随着类的加载而加载，  6  即：静态代码块的内容会优先执行。  7  C:构造代码块  8 　 在类中方法外出现(即在类中的成员位置)，可以把多个构造方法方法中相同的代码存放到一起，用于对对象进行初始化，  9  每次调用构造方法都执行，并且在构造方法前执行。 10  C:子类的所有的构造方法默认都会去访问父类的无参构造方法。 11         
 输出结果是： 13  　　静态代码块Fu 14  　　静态代码块Zi 15  　　构造代码块Fu 16  　　构造方法Fu 17  　　构造代码块Zi 18  　　 构造方法Zi 19 */
class Fu { 21     static { 22         System.out.println("静态代码块Fu"); 23  } 24 
 { 26         System.out.println("构造代码块Fu"); 27  } 28 
    public Fu() { 30         System.out.println("构造方法Fu"); 31  } 32 } 33 
class Zi extends Fu { 35     static { 36         System.out.println("静态代码块Zi"); 37  } 38 
 { 40         System.out.println("构造代码块Zi"); 41  } 42 
    public Zi() { 44         System.out.println("构造方法Zi"); 45  } 46 } 47 
class ExtendsTest2 { 49     public static void main(String[] args) { 50         Zi z = new Zi(); 51  } 52 }

第三题：

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

class X { 25     //成员变量(引用类型)
    Y b = new Y(); 27     //无参构造方法
 X() { 29         System.out.print("X"); 30  } 31 } 32 
class Y { 34     //无参构造方法
 Y() { 36         System.out.print("Y"); 37  } 38 } 39 
public class Z extends X { 41     //成员变量(引用类型)
    Y y = new Y(); 43     //无参构造方法
 Z() { 45         //super(); //它仅仅表示要先初始化父类数据，再初始化子类数据。
        System.out.print("Z"); 47  } 48     public static void main(String[] args) { 49         new Z(); 50  } 51 }