本文阐述了Java中继承与组合的概念。 首先展示了一个继承的例子，然后展示了如何使用组合来改进继承设计。 最后总结如何在它们之间进行选择。
1. 继承
假设我们有一个Insect 类。 这个类包含两个方法：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类，它是一种Insect类型，但具有不同的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();
}
}
类层次结构图如下所示：
inheritance-vs-composition-1.jpg
输出：
Fly
Fly
Attack
“Fly”被打印了两次，这表明move()被调用了两次，但它应该只能被调用一次。
问题是由super.attack() 方法引起的。 Insect的attack() 方法调用move() 方法。 当子类调用super.attack() 时，它也会调用重写的move() 方法。
为了解决这个问题，我们可以：
- 消除子类的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函数被提取，Insect不再做任何与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是Insect的子类，并实现attack接口。
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();
}
}
类图：
inheritance-vs-composition-2.jpg
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关系，并且类想要将所有接口公开给另一个类，那么继承可能是首选。
- 如果存在HAS-A关系，则组合是优选的。
总之，继承和组合都有它们的用途，并且了解它们的相对优点是值得的。
