这篇文章阐明了Java中继承和组合的概念。首先展示了继承的例子，接着显示如何通过组合来改进继承。最后总结如何在它们之间做选择。

1. 继承

想下，我们有个叫 insert 的类，这个类包含两个方法：1) move() 和2） attack() .

 class Insect {
 private int size;
 private String color;
 
 public Insect(int size, String color) {
  this.size = size;
  this.color = color;
 }
 
 public int getSize() {
  return size;
 }
 
 public void setSize(int size) {
  this.size = size;
 }
 
 public String getColor() {
  return color;
 }
 
 public void setColor(String color) {
  this.color = color;
 }
 
 public void move() {
  System.out.println("Move");
 }
 
 public void attack() {
  move(); //assuming an insect needs to move before attacking
  System.out.println("Attack");
 }
}
  

现在你需要定义一个 Bee 类，它是 Insert 类子类，但是有 attack() 和 move() 不同实现。它可以按照继承如下设计：

 class Bee extends Insect {
 public Bee(int size, String color) {
  super(size, color);
 }
 
 public void move() {
  System.out.println("Fly");
 }
 
 public void attack() {
  move();
  super.attack();
 }
}
  

 public class InheritanceVSComposition {
 public static void main(String[] args) {
  Insect i = new Bee(1, "red");
  i.attack();
 }
}
  

类型继承关系图简单如下：

输出：

 Fly
Fly
Attack
  

“Fly” 被打印两次，它显示了 move() 被调用了两次。但是它应该只被调用一次。

问题是由super.attack()方法导致。 Insert 的 attack() 方法调用了 move() 方法。当子类调用super.attack(),它也调用了被覆盖的 move() 方法。

为了解决这个问题，我们可以： 1、除去子类的 attack 方法。它将会使子类完全依赖父类实现的 attack() 方法。如果父类的 attack 方法在后面被改变了（这不是你所控制的），例如，父类的 attack() 方法调用另外的方法去移动，子类也需要改变。这是个失败的封装。

2.如下重写 attack() 方法。

 public void attack() {
 move();
 System.out.println("Attack");
}
  

因为子类不再依赖父类信息，所以可以保证结果的正确性。但是，父类的代码是重复的。（想下 attack() 方法调用了更复杂的方法二不是仅仅打印一个字符串）它对于软件工程师重用规则来说的时候是不被准许的。

继承设计是不好的，因为子类依赖了父类的实现细节。如果父类改变了，子类也需要改变。

2.组合

在这个例子中，可以用组合而不是继承。让我们先看看组合的解决方案。

attack函数被抽象作为一个接口。

 interface Attack {
 public void move();
 public void attack();
}
  

Attack 接口可以被定义为多个不同种类的 attack 实现。

 class AttackImpl implements Attack {
 private String move;
 private String attack;
 
 public AttackImpl(String move, String attack) {
  this.move = move;
  this.attack = attack;
 }
 
 @Override
 public void move() {
  System.out.println(move);
 }
 
 @Override
 public void attack() {
  move();
  System.out.println(attack);
 }
}
  

因为attack函数被抽象了， Insert 类将不再与attack有任何关系。

 class Insect {
 private int size;
 private String color;
 
 public Insect(int size, String color) {
  this.size = size;
  this.color = color;
 }
 
 public int getSize() {
  return size;
 }
 
 public void setSize(int size) {
  this.size = size;
 }
 
 public String getColor() {
  return color;
 }
 
 public void setColor(String color) {
  this.color = color;
 }
}
  

Bee是一个 Insert 类型，它可以attack。

 // This wrapper class wrap an Attack object
class Bee extends Insect implements Attack {
 private Attack attack;
 
 public Bee(int size, String color, Attack attack) {
  super(size, color);
  this.attack = attack;
 }
 
 public void move() {
  attack.move();
 }
 
 public void attack() {
  attack.attack();
 }
}
  

类结构图如下：

 public class InheritanceVSComposition2 {
 public static void main(String[] args) {
  Bee a = new Bee(1, "black", new AttackImpl("fly", "move"));
  a.attack();
 
  // if you need another implementation of move()
  // there is no need to change Insect, we can quickly use new method to attack
 
  Bee b = new Bee(1, "black", new AttackImpl("fly", "sting"));
  b.attack();
 }
}
  

输出：

 fly
move
fly
sting
  

3. 什么使用用它们

下面两点可以指导继承和组合之间的选择：

1. 如果是IS-A关系，一个类想要对另外一个类暴露所有接口，继承看起来是更好的选择。 2.如果是HAS-A关系，组合是更好的选择。

总之，继承和组合都有它们的应用场景，理解它们的关系是值得的。