先用继承实现以下 Animal  ,Bird ,Wolf之间的关系

1. class Animal
   
2. {
   
3. private void beat()
   
4. {
   
5. System.out.println("心脏跳动.........");
   
6. }
   
7. public void breath()
   
8. {
   
9. beat();
   
10. System.out.println("呼吸.......");
    
11. }
    
12. 
    
13. }
    
14. 
    
15. class Bird extends Animal
    
16. {
    
17. public void fly()
    
18. {
    
19. System.out.println("flying.......");
    
20. }
    
21. 
    
22. }
    
23. 
    
24. class Wolf extends Animal
    
25. {
    
26. public void run()
    
27. {
    
28. System.out.println("running.......");
    
29. 
    
30. }
    
31. 
    
32. }
    
33. 
    
34. public class InheritTest
    
35. {
    
36. public static void main(String[] args)
    
37. {
    
38. Bird b=new Bird();
    
39. b.breath();
    
40. b.fly();
    
41. 
    
42. Wolf w=new Wolf();
    
43. w.breath();
    
44. w.run();
    
45. 
    
46. }
    
47. 
    
48. }

复制代码

先不考虑别的，如果用组合的方式实现代码复用：

1. class Animal
   
2. {
   
3. private void beat()
   
4. {
   
5. System.out.println("心脏跳动........");
   
6. }
   
7. public void breath()
   
8. {
   
9. beat();
   
10. System.out.println("呼吸........");
    
11. }
    
12. }
    
13. 
    
14. 
    
15. class Bird   
    
16. {
    
17. private Animal a;
    
18. public Bird(Animal a)
    
19. {
    
20. this.a=a;
    
21. }
    
22. public void breath()
    
23. {
    
24. a.breath();
    
25. }
    
26. public void fly()
    
27. {
    
28. System.out.println("flying.......");
    
29. }
    
30. }
    
31. 
    
32. class Wolf
    
33. {
    
34. private Animal a;
    
35. public Wolf(Animal a)
    
36. {
    
37. this.a=a;
    
38. }
    
39. public void breath()
    
40. {
    
41. a.breath();
    
42. }
    
43. 
    
44. public void run()
    
45. {
    
46. System.out.println("running.......");
    
47. 
    
48. }
    
49. 
    
50. }
    
51. 
    
52. public class CompositeTest
    
53. {
    
54. public static void main(String[] args)
    
55. {
    
56. Animal a1=new Animal();
    
57. Bird b=new Bird(a1);
    
58. b.breath();
    
59. b.fly();
    
60. 
    
61. Animal a2=new Animal();
    
62. Wolf w=new Wolf(a2);
    
63. w.breath();
    
64. w.run();
    
65. 
    
66. 
    
67. }
    
68. 
    
69. }

复制代码

代码比较简单，但能表达组合就是将原来父类Animal嵌入进子类中，从而成为了子类中的一部分，就是"has a"关系，在内存空间上，组合比继承多一个在栈内存中的引用那个父类对象的引用变量，当然这里还是用继承好一些，那个关于聚合的例子谁给一个，最好能简单说明问题滴，视频里只是说了一下聚合和组合的紧密程度不同，那聚合的实现方式也应该和组合一样吧，谁给一个详细实现方式的例子

赵兵锋 发表于 2012-6-11 20:48
额，我也不知了，请其他兄弟来看吧。
顺便问一下，你看的什么书？哪一页？ ...

java 讲义 精粹版的
第四章 4.8.2 利用组合实现复用 那一节

庄星睿 发表于 2012-6-11 20:45
老大，他们的关系我知道，就是用代码怎样实现出来啊，我那个例子是在书上看的，他也描述了，但没描述聚合 ...

额，我也不知了，请其他兄弟来看吧。
顺便问一下，你看的什么书？哪一页？

赵兵锋 发表于 2012-6-11 19:59
聚合关系是“has-a”关系，组合关系是“contains-a”关系；聚合关系表示整体与部分的关系比较弱，而组合比 ...

老大，他们的关系我知道，就是用代码怎样实现出来啊，我那个例子是在书上看的，他也描述了，但没描述聚合，而且代码注明的是用组合实现复用，我就想问他既然组合是这么用的，那聚合该怎么用啊，悲催的书上没写，而你给的那个代码，聚合用的和我写的一样，感觉正好颠倒了，你和书上到底哪个正确啊

聚合关系是“has-a”关系，组合关系是“contains-a”关系；聚合关系表示整体与部分的关系比较弱，而组合比较强；聚合关系中代表部分事物的对象与代表聚合事物的对象的生存期无关，一旦删除了聚合对象不一定就删除了代表部分事物的对象。组合中一旦删除了组合对象，同时也就删除了代表部分事物的对象。
可以这样通俗理解：
你和你女朋友是聚合关系，是"has-a"
你和你的身体的组合关系，是"contains-a"
你要是死了，你身体肯定也没用了，一损俱损，但是你的女朋友不一定，她还可以跟别人搞聚合关系去

赵兵锋 发表于 2012-6-11 18:22

哥们，你写的聚合怎么和我写的组合是一样的啊，我看的书上写的那种方式是利用组合实现的啊，但书上没介绍聚合，如果按你写的那样  this.animal=new Animal()  他依赖Animal类更紧密些了，难道是书上写错了，啊啊啊，求解啊......

1. public class Main {
   
2.         public static void main(String[] args) throws Exception {
   
3.                 Animal a = new Animal();
   
4.                 Cat c = new Cat(a);//将创建的Animal对象传递给Cat对象，此为聚合
   
5.         }
   
6. }
   
7. class Animal{}
   
8. class Cat{
   
9.         private Animal animal;
   
10.         public Cat(Animal animal){//此种方式为聚合，Animal对象并不由Cat创建，由外部传递引用，这样就避免了当Cat对象被销毁时，其中的Animal对象也会被销毁。
    
11.                 this.animal = animal;
    
12.         }
    
13.         public Cat(){
    
14.                 this.animal = new Animal();//此种方式为组合，Cat对象销毁时，其中的Animal对象也会被销毁。
    
15.         }
    
16. }

复制代码