这篇文章阐明了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. 什么使用用它们
下面两点可以指导继承和组合之间的选择：
- 如果是IS-A关系，一个类想要对另外一个类暴露所有接口，继承看起来是更好的选择。
2.如果是HAS-A关系，组合是更好的选择。
总之，继承和组合都有它们的应用场景，理解它们的关系是值得的。
