类的组合：

1. class Animals {
   
2.         private void beat() {
   
3.                 System.out.println("心脏跳动。。。");
   
4.         }
   
5. 
   
6.         public void breath() {
   
7.                 beat();
   
8.                 System.out.println("呼吸中。。。");
   
9.         }
   
10. }
    
11. 
    
12. class Dog {
    
13.         // 将Animal嵌入到类里面
    
14.         private Animals animals;
    
15. 
    
16.         public Dog(Animals animals) {
    
17.                 this.animals = animals;
    
18.         }
    
19. 
    
20.         // 定义一个自己的breath()方法
    
21.         public void breath() {
    
22.                 // 直接复用Animals提供的方法
    
23.                 animals.breath();
    
24.         }
    
25. 
    
26.         public void Run() {
    
27.                 System.out.println("陆地上奔跑");
    
28.         }
    
29. }
    
30. 
    
31. class Bird {
    
32.         // 将Animal嵌入到类里面
    
33.         private Animals animals;
    
34. 
    
35.         public Bird(Animals animals) {
    
36.                 this.animals = animals;
    
37.         }
    
38. 
    
39.         // 定义一个自己的breath()方法
    
40.         public void breath() {
    
41.                 // 直接复用Animal提供的方法
    
42.                 animals.breath();
    
43.         }
    
44. 
    
45.         // 定义自己的fly方法
    
46.         public void fly() {
    
47.                 System.out.println("天空里面飞翔！");
    
48.         }
    
49. }
    
50. 
    
51. public class Combination {
    
52.         public static void main(String[] args) {
    
53.                 Dog dog = new Dog(new Animals());
    
54.                 dog.breath();
    
55.                 dog.Run();
    
56.                 Bird bird = new Bird(new Animals());
    
57.                 bird.breath();
    
58.                 bird.fly();
    
59.         }
    
60. }
    

复制代码

类的继承：

1. class Animals {
   
2.         private void beat() {
   
3.                 System.out.println("心脏跳动。。。");
   
4.         }
   
5. 
   
6.         public void breath() {
   
7.                 beat();
   
8.                 System.out.println("呼吸中。。。");
   
9.         }
   
10. }
    
11. class Dog extends Animals {
    
12.        
    
13.         public void Run() {
    
14.                 System.out.println("陆地上奔跑");
    
15.         }
    
16. }
    
17. class Bird extends Animals{
    
18.        
    
19.         // 定义自己的fly方法
    
20.         public void fly() {
    
21.                 System.out.println("天空里面飞翔！");
    
22.         }
    
23. }
    
24. public class Inheritance {
    
25.         public static void main(String[] args) {
    
26.                 Dog dog = new Dog();
    
27.                 dog.breath();
    
28.                 dog.Run();
    
29.                 Bird bird = new Bird();
    
30.                 bird.breath();
    
31.                 bird.fly();
    
32.         }
    
33. }
    

复制代码

以上输出的结果都是一样的，那么那种对系统的开销最小呢？？

这个要请高人来回答了。我觉得比起开销，哪一种设计更合理才是更加重要的问题：is a VS has a

fantacyleo 发表于 2014-7-10 18:03
这个要请高人来回答了。我觉得比起开销，哪一种设计更合理才是更加重要的问题：is a VS has a ...

这个倒是没什么错，我主要还是想搞懂这两种方式的实现细节，比如在内存中是如何分配的？类的组合和内部类有什么区别？

mytongyong 发表于 2014-7-10 18:10
这个倒是没什么错，我主要还是想搞懂这两种方式的实现细节，比如在内存中是如何分配的？类的组合和内部类 ...

这个，初学者真没必要搞得太细，没有对底层的基本了解是很难搞明白的。内存分配倒是不太难，老毕视频里教的内存分析知识就足够把图画出来了。内存占用应该差不多（因为还有些更底层的细节，比如字节对齐，不敢肯定100%相同）。但内存分配只是一方面，还有比如方法调用时的搜寻开销，也就是说，如果一个方法在本类找不到，那么虚拟机沿着继承体系往上寻找的开销有多大，这我就不清楚了

fantacyleo 发表于 2014-7-10 18:25
这个，初学者真没必要搞得太细，没有对底层的基本了解是很难搞明白的。内存分配倒是不太难，老毕视频里教 ...

嗯，初学Java，路还很长，受教了。