关于面向对象设计中继承与组合的选择

这个标题似乎有些奇怪，初学者可能会无法理解。

先来看看面向对象中组合和继承的基本概念：

组合——在某个类中定义了另一个类的实例，对其进行数据维护和操作。

继承——某个类从另一个类继承，则自动“拥有”了父类的的数据和方法。

可见，在本质上两者是有很大的共性的，就是利用另一个类已有的数据和方法。

看看下面的例子——

首先，我们来定义一个常见的类Point。

1. public class Point
2. {
3.     public float x;
4.     public float y;
6.     public Point(float x, float y)
7.     {
8.         this.x = x;
9.         this.y = y;
10.     }
12.     public void MoveTo(float x, float y)
13.     {
14.         this.x = x;
15.         this.y = y;
16.     }
18.     public void Move(float dx, float dy)
19.     {
20.         this.x += dx;
21.         this.y += dy;
22.     }
23. }

接着我们用组合和继承来分别定义Circle类。

1. // 组合
2. public class Circle
3. {
4.     public Point Center;
5.     public float Radius;
7.     public Circle(Point center, float radius)
8.     {
9.         this.Center = center;
10.         this.Radius = radius;
11.     }
13.     public void MoveTo(Point center)
14.     {
15.         this.Center = center;
16.     }
17. }
19. // 继承
20. public class Circle : Point
21. {
22.     public float Radius;
24.     public Circle(Point center)
25.     {
26.         this.x = center.x;
27.         this.y = center.y;
28.     }
30.     public Point Center
31.     {
32.         get { return this; }
33.         set { this.x = value.x; this.y = value.y; }
34.     }
35. }

从使用者的角度来看，组合更加接近“逻辑”，这是很明显的。但是，对于复杂的应用，可能找不到明显的“逻辑”，这个时候可以采用下面的两个原则来判断：

1、如果一个类可以直接应用另一个类中绝大多数的方法，可以考虑用继承减少代码量

2、如果继承后给使用者带来额外的麻烦（比如部分函数的继承容易引发异常），建议用组合方式