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();
    }
}

输出：