Java编程：组合、继承和代理的区别

组合、继承和代理三者的定义：

1. 组合：在新类中new 另外一个类的对象，以添加该对象的特性。
2. 继承：从基类继承得到子类，获得基类的特性。
3. 代理：在代理类中创建某功能的类，调用类的一些方法以获得该类的部分特性。

2. 使用场合：

• 组合：各部件之间没什么关系，只需要组合即可。like组装电脑，需要new CPU(),new RAM(),new Disk()……
  
• 继承：子类需要具有父类的功能，各子类之间有所差异。like Shape类作为基类，子类有Rectangle，CirCle，Triangle……代码不写了，大家都经常用。
• 代理：飞机控制类，我不想暴露太多飞机控制的功能，只需部分前进左右转的控制（而不需要暴露发射导弹功能）。通过在代理类中new一个飞机控制对象，然后在方法中添加飞机控制类的各个需要暴露的功能。

一：继承

　　继承按现有类创建一个对象，不改变现有类，采用现有类的形式向其中添加新代码；（编译器强制你去初始化基类，是is_a 的关系，比如说Student继承Person,则说明Student is a Person。

继承的优点是子类可以重写父类的方法来方便地实现对父类的扩展。

　　继承的缺点有以下几点：

　　①：父类的内部细节对子类是可见的。

　　②：子类从父类继承的方法在编译时就确定下来了，所以无法在运行期间改变从父类继承的方法的行为。

　　③：如果对父类的方法做了修改的话（比如增加了一个参数），则子类的方法必须做出相应的修改。所以说子类与父类是一种高耦合，违背了面向对象思想。

二：组合

　　组合是在新类中使用现有类的对象，也就是设计类的时候把要组合的类的对象加入到该类中作为自己的成员变量。组合是has_a 的关系。

　　组合的优点：

　　①：当前对象只能通过所包含的那个对象去调用其方法，所以所包含的对象的内部细节对当前对象时不可见的。

　　②：当前对象与包含的对象是一个低耦合关系，如果修改包含对象的类中代码不需要修改当前对象类的代码。

　　③：当前对象可以在运行时动态的绑定所包含的对象。可以通过set方法给所包含对象赋值。

　　组合的缺点：①：容易产生过多的对象。②：为了能组合多个对象，必须仔细对接口进行定义。

由此可见，组合比继承更具灵活性和稳定性，所以在设计的时候优先使用组合。

只有当下列条件满足时才考虑使用继承：

子类是一种特殊的类型，而不只是父类的一个角色 
子类的实例不需要变成另一个类的对象 
子类扩展，而不是覆盖或者使父类的功能失效

InheritTest.java 使用继承方式实现目标

[java]  view plain  copy

1. //InheritTest.java 使用继承方式实现目标  
2. class Animal{  
3.     private void beat(){  
4.         System.out.println("心脏跳动...");  
5.     }  
6.     public void breath(){  
7.         beat();  
8.         System.out.println("吸一口气，呼一口气，呼吸中...");  
9.     }  
10. }  
11. //继承Animal，直接复用父类的breath()方法  
12. class Bird extends Animal{  
13.     //创建子类独有的方法fly()  
14.     public void fly(){  
15.         System.out.println("我是鸟，我在天空中自由的飞翔...");  
16.     }  
17. }  
18. //继承Animal，直接复用父类的breath()方法  
19. class Wolf extends Animal{  
20.     //创建子类独有的方法run()  
21.     public void run(){  
22.         System.out.println("我是狼，我在草原上快速奔跑...");  
23.     }  
24. }  
25. public class InheritTest{  
26.     public static void main(String[] args){  
27.         //创建继承自Animal的Bird对象新实例b  
28.         Bird b=new Bird();  
29.         //新对象实例b可以breath()  
30.         b.breath();  
31.         //新对象实例b可以fly()  
32.         b.fly();  
33.         Wolf w=new Wolf();  
34.         w.breath();  
35.         w.run();  
36. /* 
37. ---------- 运行Java程序 ---------- 
38. 心脏跳动... 
39. 吸一口气，呼一口气，呼吸中... 
40. 我是鸟，我在天空中自由的飞翔... 
41. 心脏跳动... 
42. 吸一口气，呼一口气，呼吸中... 
43. 我是狼，我在草原上快速奔跑... 
44.  
45. 输出完毕 (耗时 0 秒) - 正常终止 
46. */  
47.     }  
48. }  

CompositeTest.java 使用组合方式实现目标

[java]  view plain  copy

1. //CompositeTest.java  使用组合方式实现目标  
2. class Animal{  
3.     private void beat(){  
4.         System.out.println("心脏跳动...");  
5.     }  
6.     public void breath(){  
7.         beat();  
8.         System.out.println("吸一口气，呼一口气，呼吸中...");  
9.     }  
10. }  
11. class Bird{  
12.     //定义一个Animal成员变量，以供组合之用  
13.     private Animal a;  
14.     //使用构造函数初始化成员变量  
15.     public Bird(Animal a){  
16.         this.a=a;  
17.     }  
18.     //通过调用成员变量的固有方法（a.breath()）使新类具有相同的功能（breath()）  
19.     public void breath(){  
20.         a.breath();  
21.     }  
22.     //为新类增加新的方法  
23.     public void fly(){  
24.         System.out.println("我是鸟，我在天空中自由的飞翔...");  
25.     }  
26. }  
27. class Wolf{  
28.     private Animal a;  
29.     public Wolf(Animal a){  
30.         this.a=a;  
31.     }  
32.     public void breath(){  
33.         a.breath();  
34.     }  
35.     public void run(){  
36.         System.out.println("我是狼，我在草原上快速奔跑...");       
37.     }  
38. }  
39. public class CompositeTest{  
40.     public static void main(String[] args){  
41.         //显式创建被组合的对象实例a1  
42.         Animal a1=new Animal();  
43.         //以a1为基础组合出新对象实例b  
44.         Bird b=new Bird(a1);  
45.         //新对象实例b可以breath()  
46.         b.breath();  
47.         //新对象实例b可以fly()  
48.         b.fly();  
49.         Animal a2=new Animal();  
50.         Wolf w=new Wolf(a2);  
51.         w.breath();  
52.         w.run();  
53. /* 
54. ---------- 运行Java程序 ---------- 
55. 心脏跳动... 
56. 吸一口气，呼一口气，呼吸中... 
57. 我是鸟，我在天空中自由的飞翔... 
58. 心脏跳动... 
59. 吸一口气，呼一口气，呼吸中... 
60. 我是狼，我在草原上快速奔跑... 
61.  
62. 输出完毕 (耗时 0 秒) - 正常终止 
63. */  
64.     }  
65. }  

关于组合和继承的总结：

组合和继承都允许在新的类中放置子对象，组合是显式地这样做，而继承则是隐式地这样做。

继承是"is-a"关系

组合是"has-a"关系

1）组合(has-a)关系可以显式地获得被包含类（继承中称为父类）的对象，而继承(is-a)则是隐式地获得父类的对象，被包含类和父类对应，而组合外部类和子类对应。

2）组合关系在运行期决定，而继承关系在编译期就已经决定了。

3）组合是在组合类和被包含类之间的一种松耦合关系，而继承则是父类和子类之间的一种紧耦合关系。

4）当选择使用组合关系时，在组合类中包含了外部类的对象，组合类可以调用外部类必须的方法，而使用继承关系时，父类的所有方法和变量都被子类无条件继承，子类不能选择。

5）最重要的一点，使用继承关系时，可以实现类型的回溯，即用父类变量引用子类对象，这样便可以实现多态，而组合没有这个特性。

6）还有一点需要注意，如果你确定复用另外一个类的方法永远不需要改变时，应该使用组合，因为组合只是简单地复用被包含类的接口，而继承除了复用父类的接口外，它甚至还可以覆盖这些接口，修改父类接口的默认实现，这个特性是组合所不具有的。

7）从逻辑上看，组合最主要地体现的是一种整体和部分的思想，例如在电脑类是由内存类，CPU类，硬盘类等等组成的，而继承则体现的是一种可以回溯的父子关系，子类也是父类的一个对象。

 

8）这两者的区别主要体现在类的抽象阶段，在分析类之间的关系时就应该确定是采用组合还是采用继承。

 

9）引用网友的一句很经典的话应该更能让大家分清继承和组合的区别：组合可以被说成“我请了个老头在我家里干活” ，继承则是“我父亲在家里帮我干活"。

 10）组合技术通常是用于在新类中使用现有类的功能而非它的接口的情形。

三、代理

代理是继承和组合的中庸之道。将一个成员对象置于要构造的类中（就像组合），与此同时在新类中暴露了该类成员所有的方法（就像继承）。

（组合+继承）java中没有直接的支持代理，（将基类对象作为代理类的成员，而代理类有对应于基类的所有方法，各方法内使用基类对象成员调用基类的方法。）

代理的实例一：

[java]  view plain  copy

1. public class test {    
2.     public static void main(String[] args) {    
3.         Demo2 d2=new Demo2();    
4.         d2.print();    
5.         //组合    
6.         Demo1 d1=new Demo1();    
7.         d1.method();    
8.         //代理    
9.         Demo3 d3=new Demo3();    
10.         d3.stop();    
11.     }    
12. }    
13. class Demo{    
14.     Demo(){System.out.println("hello world!");}    
15.     public static void stop(){System.out.println("Hello stop!");}    
16. }    
17. class Demo1{//组合机制    
18.     public static void method(){    
19.         Demo d=new Demo();//在新类中创建现有类的对象    
20.     }    
21. }    
22. class Demo2 extends Demo{//继承机制，按照现有类来创建新类，无需改变现有类的形式，采用现有类的形式并且在其中添加新代码    
23.     public static void print(){    
24.         System.out.println("YES!");    
25.     }    
26. }    
27. class Demo3{    
28.     private Demo d=new Demo();    
29.     public void stop(){//代理，既有继承功能 又有组合功能    
30.         System.out.println("Hello 继承！");    
31.         d.stop(); }}  

输出结果：

hello world!

YES!

hello world!

hello world!

hello 继承!

hello stop!

图文总结：