javascript - 如何添加新类并从类继承重构为行为委托(delegate)设计模式？

Question

在这里我使用类继承模式构建了一个简单的代码(我从我的游戏中获取它只是为了训练):

class BasicGamePiece {
    constructor(param) {
        this.size = param.size  
    }
    fire(){
        console.log('fire')
    }
}

// first and second children . Got different methods move() and attachTo() plus different properties 
class MovingWeaponPiece extends BasicGamePiece {
    constructor(param) {
        super(param)
        this.movementPoints = param.movementPoints
    }
    move(){
        this.movementPoints -= 1
    }
}

class StaticWeaponPiece extends BasicGamePiece {
    constructor(param) {
        super(param)
        this.owner = param.owner
    }
    attachTo(owner){
        this.owner = owner
    }
}

// now children of MovingWeaponPiece

class Squad extends MovingWeaponPiece {
    constructor(param) {
        super(param)

    }
    getUnderCommand(){
        console.log('ready to action')
    }
    fire(){                         // shadowing
        super.fire()
        console.log('as squad')
    }
}

class Vehicle extends MovingWeaponPiece {
    constructor(param) {
        super(param)
    }
    ignition(){
        console.log('at the start!')
    }
}
// and the third step of inheritance :

class Tank extends Vehicle {
    constructor(param) {
        super(param)
        this.orientation = param.orientation
    }
    rotateArmament(where){
        this.orientation = where
    }
}

为了清楚起见，我制定了这个方案:

现在我想添加另一个类 Artyllery :

它必须有方法 attachTo()(与 Weapon 类相同)和属性 this.owner(与 Weapon 类相同)

它必须具有 rotateArmament()(与 Tank 类相同)和属性 this.orientation(与 Tank 类相同)

它不应该有类似车辆的方法 ignition()

所以问题是:

1) 我应该如何正确添加 Artyllery 类？

和

2) 如果我想将所有代码从类继承模式重构为行为委托(delegate)设计模式(与 Kyle Simpson 的书中相同)'你不知道 Java Script')。

在这种情况下添加 Artillery 会更容易吗？

如果有人向我展示重构后的代码，我将不胜感激

Answer 1

经典面向对象编程

经典面向对象语言的标准思维是更喜欢平面类结构而不是深度类结构。正如著名的口头禅所说:“比类继承更喜欢对象组合。”也就是说，最好有一堆相互引用的对象，而不是深度继承结构。为什么？好吧......我认为你的例子很好地证明了为什么首选对象组合。

因此，您可以拥有一个类 position 来管理坐标、移动点等，而不是拥有一个移动的部分和一个静态的部分...可移动的部分将有一个 position 类型的成员，而静态的部分则不会.我们可以使用组合重新实现您的示例:

class Position {

    constructor(movementPoints) {
        this.movementPoints = movementPoints;
    }

    move() {
        this.movementPoints -= 1
    }

}

class Armament {

    constructor(orientation) {
        this.orientation = orientation;
    }

    rotate(where) {
        this.orientation = orientation;
    }

}

class Ownership {

    constructor(owner) {
        this.owner = owner
    }

    set(owner) {
        this.owner = owner
    }

}

class Artillery {

    constructor(config) {
        this.position = new Position(config.movementPoints);
        this.armament = new Armament(config.orientation);
        this.ownership = new Ownership(config.owner);
    }

}

let artillery = new Artillery({
    movementPoints: 4,
    orientation: 3,
    owner: player
});

artillery.position.move(4);
artillery.armament.orient(3);
artillery.ownership.set(otherPlayer);

如您所见，让每个小类负责不同的功能并将它们组合在一起以创造新的东西是非常强大的。这并不意味着你永远不应该使用继承(在我看来拥有一个类 Ownership 有点奇怪)，但你通常应该尽可能地使用组合。 OOP 还提供了其他工具来解决类似的问题 - 多重继承、混入、接口(interface)等。

Javascript

Javascript 的行为与经典的面向对象编程语言截然不同，因为它没有静态类型。您可以使用类并定义成员，但最终 javascript 不关心您如何定义对象。当怪胎带你去的时候，你可以添加或删除属性。因此，javascript 非常灵活。有很多图案可供选择，您必须找到最适合您风格的图案。

行为委托(delegate)通常是原型(prototype)链在 javascript 中的工作方式。如果在对象上找不到属性，则遍历整个原型(prototype)链；从而将行为“委托(delegate)”给其他一些对象。因此你会得到这样的东西。

let Positionable = {
    move() {
        this.movementPoints -= 1;
    }
}

let Attachable = {
    attachTo(owner) {
        this.owner = owner;
    }
}

然后您将使用 Positionable 和 Attachable 作为其他对象的原型(prototype)。

let Tank = Object.create( Positionable );

完全公开我对“你不懂 JS”不是很熟悉，通过它我无法找到 Kyle Simpson 建议如何处理必须重用对象来构造不同原型(prototype)链的情况(我可能错过了什么)。一种选择是简单地为 Tank 和 Artillery 构造一个不同的链原型(prototype)链。

Tank --> Positionable --> Object
Artillery --> Attachable --> Positionable --> Object

但我不认为这是一个特别好的解决方案。我要做的是使用 Object.assign 将对象组合在一起。

let Tank = Object.assign({
    // stuff specific to tank
}, Positionable);

let Artillery = Object.assign({
    // stuff specific to artillery
}, Positionable, Attachable);

let tank1 = Object.assign({
    movementPoints: 1
}, Tank);

let artillery1 = Object.assign({
    movementPoints: 1,
    owner: player
}, Artillery);

这样您就可以随意组合对象并实现非常灵活的代码。

好吧，这是我在这件事上的两分钱。我希望它有用。