装饰器设计模式 (Java) 中的重写方法

Question

我有一个关于装饰器设计模式的问题。

我有这门课：

class SimpleShip<T extends Weapon> implements Comparable<SpaceShip>{

    private T weapon;
    private int points = 100;

    public SimpleShip(T weapon){
        this.weapon = weapon;
    }

    public int <D extends Weapon> compareTo(SpaceShip<?> other){
        return T.quality - D.quality;
    }

    public void attack(SpaceShip<?> other){
        other.gotHit(T.fire());
    }

    public void gotHit(int reduction){
        this.points -= reduction;
    }
}

我想创建两种类型的宇宙飞船（两个附加功能） - 两者都是 gotHit 方法的不同实现，我按照以下方式进行：

abstract class ShipDecorator<T extends Weapon> extends SimpleShip<T>{

    private SimpleShip<T> simpleShip;

    public ShipDecorator(SimpleShip<T> simpleShip){
        this.simpleShip = simpleShip;
    }

    @Override
    public void attack(SpaceShip<?> other){
        simpleShip.attack();
    }

    @Override
    public int <D extends Weapon> compareTo(SpaceShip<?> other){
        return simpleShip.compareTo(other);
    }

    @Override
    public void gotHit(int reduction){
        simpleShip.gotHit(reduction);
    }
}

class GuardedShip<T extends Weapon> extends ShipDecorator<T>{
    public GuardedShip(SimpleShip<T> other, T weapon){
        super(other);
    }

    @Override
    private void gotHit(int reduction){
        simpleShip.gotHit(reduction);
        Random r = new Random();
        simpleShip.gotHit(r.nextInt(1,25));
    }
}

class SneakyShip<T extends Weapon> extends ShipDecorator<T>{
    public SneakyShip(SimpleShip<T> other, T weapon){
        super(other);
    }

    @Override
    private void gotHit(int reduction){
        if(new Random().nextDouble() > 0.25){
            simpleShip.gotHit(reduction);
        }
    }
}

我的问题是 - SimpleShip API 中的所有方法都应该被装饰器覆盖吗？ 我认为他们应该这样做，因为您必须将请求委托给已保存的 SimpleShip 实例，但我为这个问题提供的学校解决方案并没有覆盖它，这让我感到困惑。

Answer 1

装饰器模式应该在您突出显示以向船舶添加附加功能时，因为核心功能已经存在于基本船舶中。这个SimpleShip 总是带有这些功能。

您对装饰器模式的看法大部分是正确的，但是当您装饰船时，您必须保留核心功能以及其他功能。这意味着gotHit 应该做SimpleShip 做的事情+ GuardedShip 做的其他事情。

那么，就代码而言，这意味着什么？

在你装饰的船上做其他事情之前，你应该打电话给原始的gotHit()：

class SneakyShip<T extends Weapon> extends ShipDecorator<T>{
    public SneakyShip(SimpleShip<T> other, T weapon){
        super(other);
    }

    @Override
    private void gotHit(int reduction){
        super.gotHit(reduction); // core behaviour of every ship
        // additional feature of guarded ships
        if(new Random().nextDouble() > 0.25){
            // more damage
        }
    }
}

您在代码中所做的是完全改变有关 gotHit 行为的船舶行为。

这里有一些references

Answer 2

我不会说它必须覆盖SimpleShip的方法，如果它实际上没有在覆盖的方法中做任何事情并且它等于

@Override
public void method() {
  super.method();
}

那么你只会生成更多的代码行。如果你想装饰任何东西，那么你显然需要覆盖。

重用你的例子，虽然有点奇怪：

class SneakyShip<T extends Weapon> extends ShipDecorator<T>{
    public SneakyShip(SimpleShip<T> other, T weapon){
        super(other);
    }

    // This is fine, it adds functionality.
    @Override
    private void gotHit(int reduction){
        super.gotHit(reduction); // You forgot to call the methods of the superclasses.
        if(new Random().nextDouble() > 0.25){
            simpleShip.gotHit(reduction);
        }
    }

    // This is unnecessary, because it is implicitly done.
    @Override
    public void attack(SpaceShip<?> other){
        super.attack(other);
    }
}

如果给你的编程语言不会自动调用被覆盖的方法而不明确告诉它，你将被要求这样做。

有关更多信息，请参阅四人组的《设计模式》一书。