3.4 Java中继承和组合

这篇文章阐明了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关系，组合是更好的选择。

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

3.4 Java中继承和组合