构造函数链constructor chaining

构造函数链，首先对类的构造函数明确几点：

1.类的构造函数可以重载

2.类的构造函数访问修饰符不一定是public，也可以为private等其他访问修饰符

3.类的构造函数无返回值

4.类的构造函数名与类名保持一致

以下是具体的实例：

类：Person类

类：Employee类(继承Person类)

类：Manager类(继承Employee类)

首先是Person类：

[java]  view plain  copy

1. package JavaConstructorFunChain;  
2.   
3. public class Person {  
4.     private String pname;  
5.       
6.     //建立空参构造函数  
7.     public Person()  
8.     {  
9.         System.out.println("创建人类");  
10.     }  
11.   
12.     public Person(String pname) {  
13.         //super();  
14.         this.pname = pname;  
15.         System.out.println(getPname());  
16.     }  
17.   
18.     public String getPname() {  
19.         return pname;  
20.     }  
21.   
22.     public void setPname(String pname) {  
23.         this.pname = pname;  
24.     }  
25. }  

其次是Employee类：

[java]  view plain  copy

1. package JavaConstructorFunChain;  
2.   
3. public class Employee extends Person {  
4.     private double salary;  
5.       
6.     public Employee()  
7.     {  
8.         //隐式调用父类空参构造函数  
9.         //注意"隐式","空参"这两个关键字  
10.         System.out.println("创建员工");  
11.     }  
12.       
13.     public Employee(String pname,double s)  
14.     {  
15.         //this()和super()不能同时存在，因为都要在第一行  
16.         //带不带参数视具体情况而定  
17.         //this()自己调用自己的构造函数  
18.         //就这种情况，有pname这个参数，如果不用super()，则会隐式调用父类空参构造函数，那结果就是null  
19.         //super()调用父类的空参构造函数  
20.         //super(**)----父类的带参构造函数  
21.         super(pname);//显式调用父类带参构造函数  
22.         this.salary = s;  
23.         System.out.println(pname+"的工资是："+getSalary());  
24.     }  
25.   
26.     public double getSalary() {  
27.         return salary;  
28.     }  
29.   
30.     public void setSalary(double salary) {  
31.         this.salary = salary;  
32.     }  
33. }  

最后是Manager类：

[java]  view plain  copy

1. package JavaConstructorFunChain;  
2.   
3. public class Manager extends Employee {  
4.     private double benfit;  
5.       
6.     public Manager(String pname, double s,double b) {  
7.         super(pname, s);  
8.         this.benfit = b;  
9.         System.out.println(pname+"的工资是："+s+","+"奖金是"+getBenfit());  
10.     }  
11.   
12.     public Manager() {  
13.         System.out.println("创建经理");  
14.     }  
15.   
16.     public double getBenfit() {  
17.         return benfit;  
18.     }  
19.   
20.     public void setBenfit(double benfit) {  
21.         this.benfit = benfit;  
22.     }  
23. }  

我们用Test类测试一下这三个类之间的联系以及怎样实现的构造函数链：

[java]  view plain  copy

1. package JavaConstructorFunChain;  
2.   
3. public class Test {  
4.     public static void main(String[] args) {  
5.         //子类的构造函数一定会  
6.         //隐式或显式调用父类的构造函数  
7.         Manager m = new Manager();  
8.         Manager m2 = new Manager("汤姆克鲁斯",10000000,300000);  
9.     }  
10. }  

结果展示：(特别要注意先输出的是父类的还是子类的。这边输出顺序要注意)

其中比较重要的一点是：

如果在一个类中自己定义了有参数的构造函数，那这个类原先默认的无参构造函数就会

被覆盖掉。

(如果把Person类的无参构造函数，那么Employee中无参构造函数就会报错)

子类的构造函数会隐式调用父类的无参构造函数。

所以如果有子类继承这个类，一旦子类中要隐式调用父类无参构造函数的时候会报错，

因此需要自己补好父类的无参构造函数。

还有就是在Employee类中关于this()和super()的用法：

//this()和super()不能同时存在，因为都要在第一行

//带不带参数视具体情况而定

//this()自己调用自己的构造函数

//super()调用父类的空参构造函数

//this(**)----自己的带参构造函数

//super(**)----父类的带参构造函数