初学者的体系结构或为什么您不需要在剑侠中插入标志

注解：

1. 通过添加“标志”在类中实现新功能的示例。
2. 效果。
3. 替代方法和结果比较。
4. 如何避免这种情况：“建筑过度杀伤”？
5. 是时候改变一切了。

class Hero {
    func strike() {
        //   1
    }
    //   
}

class Hero {
    enum WeaponTypes {
        case sword:
        case club:
    }
	
    var weaponType: WeaponTypes?

    func strike() {
        guard let weaponType = weaponType else {
            assertionFailure()
            return	
        }
        //  : switch  Swift  if- -    !
        switch (weaponType) {
            case .sword: //     
            case .club:  //     
        }
    }
    //  
}

1. 好像不错：我们俩都能兑现。我们交付-从创造价值一词或从有趣（通过眼泪）代码一词。
2. 坏的一面：没有瓦西里，kapets项目。

var weight: Stone {
    return meatbagWeight + pantsWeight + helmetWeight + swordWeight
}

var weight: Stone {
    //   guard let weaponType
    let weightWithoutWeapon = meatbagWeight + pantsWeight + helmetWeight
    switch (weaponType) {
        case .sword: return weightWithoutWeapon + swordWeight
        case .club:  return weightWithoutWeapon + clubWeight
    }
}

var spells: [Spells] {
    //   guard let weaponType 
    // ,   let spellsWithoutWeapon: [Spells]
    switch (weaponType) {
        case .sword:
            //  let swordSpells: [Spells]
            return spellsWithoutWeapon + swordSpells
	case .club:
            //  let clubSpells: [Spells]
            return spellsWithoutWeapon + clubSpells
    }
}

func strike() {
    //guard let weaponType
    switch (weaponType) {
        case .sword: //        weaponGrade
        case .club:  //        weaponGrade
    }
}

var weight: Stone {
    // guard let weaponType
    let weightWithoutWeapon = meatbagWeight + pantsWeight + helmetWeight
    switch (weaponType) {
        case .sword: return weightWithoutWeapon + swordWeight / grade
	case .club:  return weightWithoutWeapon + pow(clubWeight, 1 / grade)
    }
}

var spells: [Spells] {
    //     , ! 
    // ,     .    ,    ,   .   !
}

过早的优化是万恶之源！

1. 第一种方法是“天真”。我们刚看到他。添加一个复选框。增加责任。膨胀类。
2. 第二种方法是继承。每个人都知道重用代码的强大机制。例如，可以这样：
   
   • 从英雄（持有一把剑，但现在没有反映在英雄类的名称中）的杜比娜手中的弓和英雄那里继承新的英雄。然后在继承人中，覆盖更改的方法。这条路非常糟糕（请相信我）。
   • 使基类（或协议）成为英雄，并删除与特定类型的武器相关的所有功能作为继承人
     ：带
     剑的英雄：英雄，带有弓箭的英雄：英雄，带有
     杜比纳的英雄：英雄。
     这样做更好，但是这些类的名称本身以某种方式使我们感到不悦，激烈，同时又感到悲伤和困惑。如果他们不看这样的人，那么我将尝试写另一篇文章，除了无聊的男性英雄之外，他们还将...
3. 第三种方式是通过依赖注入来分离责任。它可以是通过协议关闭的依赖项，也可以是关闭（就像被签名关闭）一样的东西。最主要的是，新职责的执行应该离开主体。

class Hero {
    let weapon: Weapon //   , ..    

    init (_ weapon: Weapon) { //     
        self.weapon = weapon
    }
	
    func strike() {
        weapon.strike()
    }

    var weight: Stone {
        return meatbagWeight + pantsWeight + helmetWeight + weapon.weight
    }

    var spells: [Spells] {
        //   
        return spellsWithoutWeapon + weapon.spells
    }
}

protocol Weapon {
    func strike()
    var weight: Stone {get}
    var spells: [Spells] {get}
}

class Sword: Weapon {
    func strike() {
        // ,     Hero  switch   .sword
    }

    var weight: Stone {
        // ,     Hero  switch   .sword
    }

    var spells: [Spells] {
        // ,     Hero  switch   .sword
    }
}

let lastHero = Hero()

class HeroFactory {
    static func makeSwordsman() -> Hero { // ,  static -  
        let weapon = Sword(/*  */)
        return Hero(weapon)
    }

    static func makeClubman() -> Hero {
        let weapon = Club(/*  */)
        return Hero(weapon)
    }
}

好吧，事实证明，规范。读取和扩展很方便，但是所有这些工厂/协议/依赖项都是一堆开销吗？一种代码，它在功能方面不提供任何内容，而仅用于组织代码。“用于组织代码的代码”，mgm。真的有必要随时随地围着这个花园吗？

是的，这是企业非常喜欢的功能的开销。

剑侠的哲学或“你什么时候必须统治？”

1. 人+对剑的依赖（需要剑）；
2. 人+对俱乐部的依赖（需要俱乐部）。

1. 在标志中添加标志和第一个“ if”（或“ switch”或其他分支机制）。局势正在威胁，但可以忍受：英雄倾倒了放射性废料，但他克服了。
2. «if» , . . — . , - - .

1. 看到标志了吗？
2. 做个男人，该死！删除它！
3. 成瘾注射
4. ...
5. 利润！11