Ontwerppatronen zijn verschillende oplossingen voor software engineering problemen. Softwares kunnen ook zonder deze patronen worden gebouwd, maar het is een stuk moeilijker.
Ik zal een driedelige serie uitbrengen over ontwerppatronen. In deze post, zal ik het hebben over Creational design patterns.
Creational design patterns zijn design patterns die zich bezighouden met object creatie mechanismen, proberen om objecten te creëren op een manier die geschikt is voor de situatie. De basisvorm van objectcreatie kan resulteren in ontwerpproblemen of in extra complexiteit van het ontwerp. Creatieve ontwerppatronen lossen dit probleem op door op de een of andere manier deze objectcreatie te controleren.
Bron: wikipedia.org
Hierna gaan we de vijf creatieve ontwerppatronen bespreken en hoe we ze kunnen gebruiken in swift.
Dit type ontwerppatroon wordt gebruikt om een nieuw object te instantiëren door het klonen van een bestaand object genaamd prototype.
U ziet een abstracte kloonfunctie van het Fruit-protocol dat is geïmplementeerd door de Apple-klasse die in feite het huidige object zelf retourneert.
Laten we de bovenstaande code uitvoeren in de speeltuin.
// Create a prototype
let prototype = Apple(count: 4)// Create a copy of existing object
let redApple: Apple = prototype.clone() as! Apple
redApple.count // 4// add own properties
redApple.set(price: "")
redApple.price // // Create a copy of existing object
let greenApple: Apple = prototype.clone() as! Apple
greenApple.count // 4// add own properties
greenApple.set(price: "")
greenApple.price //
– Wanneer u een object kloont, worden alle eigenschappen van dat object gekopieerd naar
een ander object.
– Dit ontwerppatroon moet worden gebruikt wanneer u een object moet maken zonder de hiërarchie van die klasse te kennen
Het Factory Method Pattern
Het is het meest gebruikte ontwerppatroon. In principe abstraheert het gewoon het maken van een object.
Maak een klasse genaamd FruitFactory die het type van het benodigde object retourneert.
Voeg een statische methode toe die een enum genaamd FruitType als parameter accepteert en het benodigde object retourneert tijdens runtime.
Elke instantie die door de fabriek wordt geretourneerd zou van het type Interface (in swift protocol) zijn dat elke kandidaat-klasse voor de fabriek moet hebben geïmplementeerd.
Na het uitvoeren van de bovenstaande code in de speeltuin:
// get the object of class Orange from the FruitFactory class
let orange = FruitFactory.getFruit(forType: .orange)
orange?.getPrice() // "
orange?.getCount() // 2// get the object of class Grapes from the FruitFactory class
let grapes = FruitFactory.getFruit(forType: .grapes)
grapes?.getPrice() // ""
grapes?.getCount() // 1
– Het type van het gemaakte object wordt bepaald tijdens runtime.
– Dit ontwerppatroon maakt de codebase flexibeler om nieuwe types toe te voegen of te verwijderen.
Dit introduceert ons in het concept van programmeren naar een interface, niet een implementatie.
Dit ontwerppatroon biedt een interface voor het maken van families van gerelateerde objecten zonder hun concrete klassen te specificeren. Ze worden vaak geïmplementeerd met Factory Method pattern.
We hebben een abstracte fabriek genaamd Furniture Factory voor het creëren van verschillende producten. De concrete fabrieksklasse Factory zal het protocol van de meubelfabriek implementeren.
Het uitvoeren van de bovenstaande code.
// create MyChair class object
let chair = Factory.createChair()
chair.count() // 4// create MyTable class object
let table = Factory.createTable()
table.count() // 1
– Onthult de interface, niet de implementatie
– Abstracte fabriek is als een protocol dat we zullen gebruiken op een concrete klasse om objecten te maken
Builder Pattern
Dit ontwerppatroon scheidt het proces van het maken van objecten van het daadwerkelijke gebruik ervan.
Eerst verklaren we een abstract protocol (of interface) voor het maken van het product. In dit geval is dat het ShoeShop protocol.
Class Nike is een concrete bouwer om het produkt creatie proces in te kapselen.
Director maakt object met behulp van het bouwer protocol. Director moet worden geïnitialiseerd met een object dat voldoet aan het ShoeShop-protocol.
Na het uitvoeren van de code.
// create a nike object
let nike = Nike()// instantiate Director with nike object
let director = Director(shoeShop: nike)// encapsulated the process of producing the nike product
director.produce() // "Shoe produced"
– Gebruik het Builder-patroon bij het bouwen van openbare API’s omdat het de implementatiedetails niet onthult
– Verbergt de complexiteit. Het biedt een eenvoudige API achter een complexe taak.
Singleton Design Pattern
In swift definiëren we Singleton-klassen door het statische sleutelwoord te gebruiken. Dit betekent dat het object slechts eenmaal geïnitialiseerd wordt. Statische eigenschappen zijn lui geïnitialiseerd en worden niet geïnstantieerd totdat ze worden aangeroepen.
Er is slechts één kopie van dit object en wordt door de andere objecten globaal gebruikt.
We zien het gebruik in Apple frameworks ook:
// Shared url session
let urlSession = URLSession.shared// user defaults
let userDefaults = UserDefaults.standard
Na het uitvoeren van de code
Vehicle.sharedInstance.getName() // "Car"
– We gebruiken het let keyword om er zeker van te zijn dat de waarde van de shredInstance niet zal veranderen
– Vergeet niet de private initialiser toe te voegen om te voorkomen dat andere klassen de standaard initializers aanroepen
Hier is de link naar de playground bestanden.
De belangrijkste reden om het Creational Design Pattern te gebruiken, is om de logica van het maken van een object los te koppelen van het gebruik ervan. Het helpt de complexiteit te verminderen door objecten te maken op een gecontroleerde manier met reeds genoemde & geteste oplossingen.
Voor het lezen over behavioral design patterns, hier is de link naar de blog.