黑马程序员技术交流社区

标题: 类的组合与继承哪个对系统的开销更大？ [打印本页]
作者: mytongyong    时间: 2014-7-10 17:50
标题: 类的组合与继承哪个对系统的开销更大？
类的组合：
  1. class Animals {
  2.         private void beat() {
  3.                 System.out.println("心脏跳动。。。");
  4.         }

  6.         public void breath() {
  7.                 beat();
  8.                 System.out.println("呼吸中。。。");
  9.         }
  10. }

  12. class Dog {
  13.         // 将Animal嵌入到类里面
  14.         private Animals animals;

  16.         public Dog(Animals animals) {
  17.                 this.animals = animals;
  18.         }

  20.         // 定义一个自己的breath()方法
  21.         public void breath() {
  22.                 // 直接复用Animals提供的方法
  23.                 animals.breath();
  24.         }

  26.         public void Run() {
  27.                 System.out.println("陆地上奔跑");
  28.         }
  29. }

  31. class Bird {
  32.         // 将Animal嵌入到类里面
  33.         private Animals animals;

  35.         public Bird(Animals animals) {
  36.                 this.animals = animals;
  37.         }

  39.         // 定义一个自己的breath()方法
  40.         public void breath() {
  41.                 // 直接复用Animal提供的方法
  42.                 animals.breath();
  43.         }

  45.         // 定义自己的fly方法
  46.         public void fly() {
  47.                 System.out.println("天空里面飞翔！");
  48.         }
  49. }

  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.         }

  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. }
复制代码

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


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

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

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

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2