JAVA-组合与继承

设计原则：多用组合，少用继承。

     组合和继承，都能实现对类的扩展。

区别如下表所示：

组合	继承
has-a关系	is-a关系
运行期决定	编译期决定
不破坏封装，整体和局部松耦合	破坏封装，子类依赖父类
支持扩展，随意增加组合类	只能继承一个父类，必须包含所有方法，增加系统复杂性
动态选择组合类方法	复用父类方法

下面通过一个例子说明，子类继承必须包含所有父类方法，增加了出错率，修改父类方法会引起所有子类功能变化。

[java]  view plain copy

1. /** 
2.  * 呼叫基类 
3.  *  
4.  * @author peter_wang 
5.  * @create-time 2014-5-20 下午4:30:33 
6.  */  
7. public class SuperCallClass {  
8.   
9.     public void call() {  
10.     }  
11.   
12.     public void operate1() {  
13.         System.out.println("operate1 in super class");  
14.     }  
15.       
16.     public void operate2() {  
17.         System.out.println("operate2 in super class");  
18.     }  
19.   
20.     /** 
21.      * 冗余的函数，导致子类臃肿，破坏了封装，增加了出错机会 
22.      */  
23.     public void redundant() {  
24.         System.out.println("redundant in super class");  
25.     }  
26. }  

[java]  view plain copy

1. /** 
2.  * 呼叫子类 
3.  *  
4.  * @author peter_wang 
5.  * @create-time 2014-5-20 下午4:32:22 
6.  */  
7. public class SubCallClass  
8.     extends SuperCallClass {  
9.   
10.   
11.     @Override  
12.     public void operate1() {  
13.         //破坏了封装，无意中引入了基类方法  
14.         super.operate1();  
15.         System.out.println("operate in sub class");  
16.     }  
17.   
18.   
19.     @Override  
20.     public void call() {  
21.         super.call();  
22.         operate1();  
23.     }  
24. }  

[java]  view plain copy

1. /** 
2.  * 分析继承和组合 
3.  *  
4.  * @author peter_wang 
5.  * @create-time 2014-5-20 下午4:37:31 
6.  */  
7. public class CallClassDemo {  
8.   
9.     /** 
10.      * @param args 
11.      */  
12.     public static void main(String[] args) {  
13.         SubCallClass subCallClass = new SubCallClass();  
14.         subCallClass.operate1();  
15.     }  
16.   
17. }  

组合类的使用

[java]  view plain copy

1. /** 
2.  * 呼叫组合类 
3.  *  
4.  * @author peter_wang 
5.  * @create-time 2014-5-20 下午5:11:34 
6.  */  
7. public class CombineCallClass {  
8.   
9.     private SuperCallClass mSuperCallClass;  
10.   
11.     public CombineCallClass() {  
12.         mSuperCallClass = new SuperCallClass();  
13.     }  
14.   
15.     public void operate1() {  
16.         System.out.println("operate in combine class");  
17.     }  
18.   
19.     /** 
20.      * 只需要使用到SuperCallClass中的operate2方法 
21.      */  
22.     public void operate2() {  
23.         mSuperCallClass.operate2();  
24.     }  
25.   
26.     public void call() {  
27.         operate1();  
28.     }  
29. }  

综上概述：

组合通常优于继承，

1.考虑使用多态，可以用继承。
2.考虑复用父类方法，而且父类很少改动，可以用继承。
其他情况请慎重使用继承。