Swift Academy · Lektion

Protocol-basierte Abstraktionen

Hängen Sie von Protocols statt von konkreten Typen ab.

Protocol-basierte Abstraktionen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Protokollbasierte Abstraktionen

Wenn Sie statt eines konkreten Typs ein Protokoll injizieren, können Sie Implementierungen frei austauschen. Der Verbraucher hängt nur vom Verhalten ab, nicht von der Klasse.

Ein Protokoll definieren

Beschreiben Sie die Fähigkeit als Protokoll. Jeder konforme Typ kann als Abhängigkeit bereitgestellt werden.

protocol Logging {
    func log(_ message: String)
}
print("Protocol describes behavior, not a concrete class.")

Einen konkreten Typ konform machen

Eine reale Implementierung entspricht dem Protokoll. Sie ist die Abhängigkeit für die Produktion.

protocol Logging { func log(_ m: String) }
struct ConsoleLogger: Logging {
    func log(_ m: String) { print("LOG: \(m)") }
}
ConsoleLogger().log("ready")

Vom Protokoll abhängig sein

Der Eigenschaftstyp des Verbrauchers ist das Protokoll, sodass jeder konforme Wert akzeptiert wird.

protocol Logging { func log(_ m: String) }
struct ConsoleLogger: Logging { func log(_ m: String) { print(m) } }
struct Service {
    let logger: Logging // protocol, not ConsoleLogger
    func run() { logger.log("running") }
}
Service(logger: ConsoleLogger()).run()

Implementierungen austauschen

Da der Typ ein Protokoll ist, können Sie eine andere konforme Implementierung übergeben, ohne den Verbraucher anzupassen.

protocol Logging { func log(_ m: String) }
struct Loud: Logging { func log(_ m: String) { print(m.uppercased()) } }
struct Quiet: Logging { func log(_ m: String) {} }
struct Service { let logger: Logging; func run() { logger.log("hi") } }
Service(logger: Loud()).run()
Service(logger: Quiet()).run()

Gegen Schnittstellen programmieren

Dies ist das Prinzip „von Abstraktionen abhängen, nicht von konkreten Implementierungen“. Dadurch bleibt Code auf höherer Ebene von Details der unteren Ebene abgeschirmt.

protocol Storage { func save(_ v: Int) }
struct MemoryStore: Storage { func save(_ v: Int) { print("kept \(v)") } }
struct Manager { let store: Storage; func add() { store.save(1) } }
Manager(store: MemoryStore()).add()

Mehrere konforme Typen

Mehrere Typen können demselben Protokoll entsprechen, jeweils passend zu einem Kontext wie Netzwerk, Festplatte oder Speicher.

protocol Source { func value() -> Int }
struct Fixed: Source { func value() -> Int { 10 } }
struct Doubler: Source { func value() -> Int { 20 } }
func use(_ s: Source) { print(s.value()) }
use(Fixed())
use(Doubler())

Protokolle mit zusammengehörigem Verhalten

Protokolle können mehrere Methoden deklarieren und so einen klaren Vertrag für die Abhängigkeit bilden.

protocol Cache {
    func get(_ key: String) -> Int?
    func set(_ key: String, _ v: Int)
}
struct Dict: Cache {
    var store: [String: Int] = [:]
    func get(_ k: String) -> Int? { store[k] }
    mutating func set(_ k: String, _ v: Int) { store[k] = v }
}
var c = Dict(); c.set("a", 1)
print(c.get("a") ?? -1)

Generische Einschränkungen

Sie können auch über einen generischen, auf das Protokoll beschränkten Parameter injizieren und so den Overhead eines Existentialtyps vermeiden.

protocol Greeter { func greet() -> String }
struct English: Greeter { func greet() -> String { "Hello" } }
struct Welcome<G: Greeter> {
    let greeter: G
    func show() { print(greeter.greet()) }
}
Welcome(greeter: English()).show()

Stabile Verträge

Solange das Protokoll stabil bleibt, können Implementierungen intern geändert werden, ohne die Verbraucher zu beeinträchtigen.

protocol Formatter { func format(_ n: Int) -> String }
struct Plain: Formatter { func format(_ n: Int) -> String { "\(n)" } }
struct Padded: Formatter { func format(_ n: Int) -> String { String(format: "%03d", n) } }
func render(_ f: Formatter) { print(f.format(7)) }
render(Plain())
render(Padded())

Bereitet Mocking vor

Entscheidend ist, dass Protokolle es Tests ermöglichen, anstelle der echten Implementierung einen simulierten konformen Typ bereitzustellen. Darauf konzentriert sich die nächste Lektion.

protocol Network { func fetch() -> String }
struct Real: Network { func fetch() -> String { "server data" } }
struct VM { let net: Network; func load() { print(net.fetch()) } }
VM(net: Real()).load()

Schnelltest

Warum sollte statt einer konkreten Klasse ein Protokolltyp injiziert werden?

Zusammenfassung

Das Injizieren eines Protokolls abstrahiert vom konkreten Typ, sodass jeder konforme Typ eingesetzt werden kann. Dies folgt dem Prinzip „von Abstraktionen abhängen“ und ermöglicht alternative Implementierungen sowie vor allem Test-Doubles. Als Nächstes geht es um das Mocking von Abhängigkeiten in Tests.

Häufig gestellte Fragen

Ist die Lektion „Protocol-basierte Abstraktionen“ kostenlos?

Ja — der vollständige Text von „Protocol-basierte Abstraktionen“ 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 „Protocol-basierte Abstraktionen“?

Hängen Sie von Protocols statt von konkreten Typen ab. 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 3 von 4.

Wie lange dauert die Lektion „Protocol-basierte Abstraktionen“?

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

← Zurück zu Swift Academy