0Pricing
Swift Academy · Lektion

Prinzipien des protokollorientierten Entwurfs

Bevorzugen Sie für flexible Entwürfe die Protokollkomposition gegenüber Klassenvererbung.

Prinzipien des protokollorientierten Entwurfs ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Protocol-Oriented Programming (POP) setzt beim Aufbau flexibler, testbarer und wiederverwendbarer Swift-Programme eher auf die Komposition von Protokollen als auf Klassenvererbung.

Das Problem der Vererbung

Tiefe Klassenhierarchien führen zu Problemen: • Unterklassen erben den gesamten Zustand und das gesamte Verhalten der Oberklasse • Änderungen an einer Oberklasse können Unterklassen beschädigen • Eine Klasse kann nicht von zwei Klassen erben Protokolle lösen alle drei Probleme.

Mit einem Protokoll beginnen

```swift protocol Greetable { var greeting: String { get } func greet() } extension Greetable { func greet() { print(greeting) } // default implementation } ``` Protokollerweiterungen stellen Standardimplementierungen bereit, die jeder konforme Typ automatisch erhält.

Verhalten kombinieren

```swift protocol Persistable { func save() } protocol Networked { func fetch() async throws -> Data } protocol Loggable { func log(_ msg: String) } struct DataService: Persistable, Networked, Loggable { ... } ``` Kombinieren Sie Verhalten wie LEGO-Bausteine – ganz ohne Klassenhierarchie.

Gemeinsame Logik in Protokollerweiterungen

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

Nachträgliche Modellierung

Protokolle können auf Typen angewendet werden, die Sie nicht selbst besitzen: ```swift protocol JSONConvertible { func toJSON() -> String } extension Int: JSONConvertible { func toJSON() -> String { "\(self)" } } ``` Fügen Sie Standardbibliothekstypen Konformitäten hinzu, ohne sie zu unterklassen.

Werttypen + Protokolle

Structs, die Protokollen entsprechen, bieten sowohl Wertsemantik *als auch* Polymorphie: ```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] ```

Dependency Injection über ein Protokoll

```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 } } ```

Wann Klassen verwendet werden sollten

Bevorzugen Sie Klassen, wenn: • Sie einen gemeinsam genutzten veränderlichen Zustand benötigen (Referenzsemantik) • Sie eine Integration mit ObjC/UIKit-APIs benötigen • Vererbung das passende Modell ist (selten) Verwenden Sie standardmäßig Protokolle und Structs für alles andere.

Namenskonventionen für Protokolle

• Protokolle für Fähigkeiten: Endungen wie `-able`, `-ible`, `-ing` (Equatable, Hashable, Coding) • Delegate-Protokolle: Endung `Delegate` oder `DataSource` • Abstrakte Rollen: Substantive (`Store`, `Parser`, `Renderer`) Gute Namen machen protocol-orientierten Code selbstdokumentierend.

Kurze Überprüfung

Was stellen Protokollerweiterungen für konforme Typen bereit?

Zusammenfassung

Wichtige Erkenntnisse: • Bevorzugen Sie Protokolle und Structs gegenüber Klassenhierarchien • Protokollerweiterungen stellen gemeinsame Standardimplementierungen bereit • Kombinieren Sie Verhalten aus kleinen Protokollen mit jeweils einer Aufgabe • Protokolle ermöglichen Dependency Injection und verbessern die Testbarkeit • Verwenden Sie Klassen nur für Referenzsemantik und ObjC-Interoperabilität Kurs abgeschlossen! Als Nächstes: Werttypen und Referenztypen im Detail.

Häufig gestellte Fragen

Ist die Lektion „Prinzipien des protokollorientierten Entwurfs“ kostenlos?

Ja — der vollständige Text von „Prinzipien des protokollorientierten Entwurfs“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Prinzipien des protokollorientierten Entwurfs“?

Bevorzugen Sie für flexible Entwürfe die Protokollkomposition gegenüber Klassenvererbung. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Prinzipien des protokollorientierten Entwurfs“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Protokollkomposition mit &
  2. Bedingte Protokollkonformität
  3. Self-Anforderungen und Equatable-Entwurf
  4. Prinzipien des protokollorientierten Entwurfs
← Zurück zu Swift Academy