Swift Academy · Les

Principes van protocolgeoriënteerd ontwerp

Protocolcompositie verkiezen boven klassenovererving voor een flexibel ontwerp.

Les 4 van 412 stappen

Principes van protocolgeoriënteerd ontwerp is een gratis Swift Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Swift Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Swift Academy bevat in totaal 4 lessen.

Welkom

Protocolgeoriënteerd programmeren (POP) geeft de voorkeur aan protocolcompositie boven klasse-overerving om flexibele, testbare en herbruikbare Swift-code te bouwen.

Het probleem met overerving

Diepe klassehiërarchieën veroorzaken problemen: • Subklassen erven alle toestand en alle gedrag van de superklasse • Wijzigingen in een superklasse kunnen subklassen breken • Je kunt niet van twee klassen erven Protocollen lossen alle drie deze problemen op.

Begin met een protocol

```swift protocol Greetable { var greeting: String { get } func greet() } extension Greetable { func greet() { print(greeting) } // default implementation } ``` Protocolextensies bieden standaardimplementaties die elke conformerende type gratis krijgt.

Gedrag combineren

```swift protocol Persistable { func save() } protocol Networked { func fetch() async throws -> Data } protocol Loggable { func log(_ msg: String) } struct DataService: Persistable, Networked, Loggable { ... } ``` Combineer gedrag als LEGO-blokken — een klassehiërarchie is niet nodig.

Protocolextensies voor gedeelde logica

```swift extension Loggable { func log(_ msg: String) { print("[\(type(of: self))] \(msg)") } } // Every Loggable type gets this for free ```

Retrospectief modelleren

Protocollen kunnen worden toegepast op typen die je niet zelf beheert: ```swift protocol JSONConvertible { func toJSON() -> String } extension Int: JSONConvertible { func toJSON() -> String { "\(self)" } } ``` Voeg conformiteit toe aan typen uit de standaardbibliotheek zonder subklassen te gebruiken.

Waarden en protocollen

Structuren die aan protocollen voldoen geven je zowel waardesemantiek als polymorfisme: ```swift protocol Shape { var area: Double { get } } struct Circle: Shape { var radius: Double; var area: Double { .pi * radius * radius } } struct Square: Shape { var side: Double; var area: Double { side * side } } let shapes: [any Shape] = [Circle(radius:3), Square(side:4)] shapes.map { $0.area } // [28.27, 16] ```

Afhankelijkheidsinjectie via een protocol

```swift protocol DataStore { func save(_ data: Data) } struct FileStore: DataStore { func save(_ d: Data) { /* disk */ } } struct MockStore: DataStore { func save(_ d: Data) { /* test log */ } } class Service { let store: DataStore init(store: DataStore) { self.store = store } } ```

Wanneer gebruik je klassen?

Geef de voorkeur aan klassen wanneer: • Je gedeelde veranderlijke toestand nodig hebt (referentiesemantiek) • Je integratie met ObjC/UIKit-API's nodig hebt • Overerving het juiste model is (zelden) Kies in alle andere gevallen standaard voor protocollen en structuren.

Naamgevingsconventies voor protocollen

• Protocollen voor mogelijkheden: achtervoegsel `-able`, `-ible` of `-ing` (Equatable, Hashable, Coding) • Delegateprotocollen: achtervoegsel `Delegate` of `DataSource` • Abstracte rol: zelfstandig naamwoord (`Store`, `Parser`, `Renderer`) Goede namen maken protocolgeoriënteerde code zelfbeschrijvend.

Korte controle

Wat bieden protocolextensies aan typen die eraan voldoen?

Beantwoord dit in de interactieve les

Samenvatting

Belangrijkste punten: • Geef de voorkeur aan protocollen en structuren boven klassehiërarchieën • Protocolextensies bieden gedeelde standaardimplementaties • Combineer gedrag uit kleine protocollen met één duidelijk doel • Protocollen maken afhankelijkheidsinjectie mogelijk voor testbaarheid • Gebruik klassen alleen voor referentiesemantiek en interoperabiliteit met ObjC Cursus voltooid! Volgende: waardetypen versus referentietypen in detail.

Gratis beginnen

Leer Swift met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 122
Lessen: 409

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Principes van protocolgeoriënteerd ontwerp” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Swift Academy, waaronder “Principes van protocolgeoriënteerd ontwerp”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Swift Academy bevat in totaal 4 lessen.

Wat leer ik in “Principes van protocolgeoriënteerd ontwerp”?

Protocolcompositie verkiezen boven klassenovererving voor een flexibel ontwerp. Je oefent met Swift Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Swift Academy te beginnen?

Ervaring vooraf is niet nodig. Swift Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Principes van protocolgeoriënteerd ontwerp”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Swift Academy?

Ja. Elke les over Swift Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Protocolcompositie met &
Conditionele conformance
Self-vereisten en Equatable-ontwerp
Principes van protocolgeoriënteerd ontwerp

← Terug naar Swift Academy