Java继承和构造方法，成员变量的初始化

第一、在子类对象实例化之前必须首相调用父类的构造方法中的构造函数后在调用自己的构造方法。

第二、继承中，方法覆写之后，子类对象调用的将是覆写后的方法。

第三、例子

 1 class Person {
 2     String name = "No name";
 3     public Person(String nm) {
 4         name = nm;
 5     }
 6 }
 7 class Employee extends Person {
 8     String empID = "0000";
 9     public Employee(String id) {
10         empID = id;
11     }
12 }
13 public class Test {
14     public static void main(String args[]) {
15         Employee e = new Employee("123");
16         System.out.println(e.empID);
17     }
18 }

运行结果：报错

分析：子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。

而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。

第四、子类和父类的初始化过程

 1 class X{
 2     Y y=new Y();
 3     public X(){
 4         System.out.print("X");
 5     }
 6 }
 7 class Y{
 8     public Y(){
 9         System.out.print("Y");
10     }
11 }
12 public class Z extends X{
13     Y y=new Y();
14     public Z(){
15         System.out.print("Z");
16     }
17     public static void main(String[] args) {
18         new Z();
19     }
20 }

此段代码输出结果为：YXYZ

分析：

初始化过程：

1. 初始化父类中的静态成员变量和静态代码块 ；

2. 初始化子类中的静态成员变量和静态代码块 ；

3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；

4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

　　所以，程序的执行过程为 ：

（1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y

（2）再执行父类的构造方法；输出X

（3） 初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y

（4）再执行子类的构造方法；输出Z

第五、

 1 class Pe{
 2     {
 3         System.out.println("构造函数之前");
 4     }
 5     public Pe(){
 6         System.out.println("构造函数中");
 7     }    
 8 }
 9 
10 public class InstanceDemo00 {
11     
12     public static void main(String[] args) {
13         Pe p = new Pe();
14     }
15 
16 }

输出结果为：

构造函数之前

构造函数中