A volte trovo utile avere una singola classe con più istanze (configurate in modo diverso tramite le loro proprietà), piuttosto che più classi (ereditarietà).

??? Modello

• Classe singola (Frutta)
• Diversi tipi di frutta sono istanze di Fruit, con proprietà configurate correttamente.
• Comportamento implementato come blocchi.

class Fruit {
    var name: String
    var color: UIColor
    var averageWeight: Double
    var eat: () -> ()
}

class FruitFactory {
    static func apple() -> Fruit {
        let fruit = Fruit()
        fruit.name = "Apple"
        fruit.color = UIColor.redColor()
        fruit.averageWeight = 50
        fruit.eat = {
            washFruit(fruit)
            takeBite(fruit)
        }
        return fruit
    }

    static func orange() -> Fruit {
        let fruit = Fruit()
        fruit.name = "Orange"
        fruit.color = UIColor.orangeColor()
        fruit.averageWeight = 70
        fruit.eat = {
            peelFruit(fruit)
            takeBite(fruit)
        }
        return fruit
    }
}

Modello di ereditarietà

Per riferimento, lo stesso avrebbe potuto essere implementato usando l'ereditarietà:

• Classi multiple (frutta, mela, arancione)
• Diversi tipi di frutta sono classi che ereditano da Fruit .
• Comportamento implementato usando metodi standard che sono sovrascritti in sottoclassi.

class Fruit {
    var name: String
    var color: UIColor
    var averageWeight: Double
    func eat() {
        // abstract method
    }
}

class Apple: Fruit {
    var name = "Apple"
    var color = UIColor.redColor()
    var averageWeight = 50

    override func eat() {
        washFruit(self)
        takeBite(self)
    }
}

class Orange: Fruit {
    var name = "Orange"
    var color = UIColor.orangeColor()
    var averageWeight = 70

    override func eat() {
        peelFruit(self)
        takeBite(self)
    }
}

class FruitFactory {
    static func apple() -> Fruit {
        return Apple()
    }

    static func orange() -> Fruit {
        return Orange()
    }
}

Qual è il primo pattern chiamato?

Esistono risorse per aiutarmi a decidere quando utilizzare uno di questi modelli rispetto all'altro?

Al di sopra della mia testa, posso pensare ad almeno un motivo per preferire l'ereditarietà:

• Immagina di dover aggiungere una nuova proprietà ad Apple, ma non a Orange (ad esempio averageCoreWeight ). Se usi l'ereditarietà, questo è banale. Se usi il primo pattern, ti verrà lasciata una proprietà che viene usata solo a volte.