Protokolle als Verträge
Definieren Sie Verhaltensverträge unabhängig von konkreten Typen.
Protokolle als Verträge ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Was ist ein Protokoll?
Ein Protokoll definiert einen Bauplan aus Methoden, Eigenschaften und anderen Anforderungen, die ein konformer Typ implementieren muss. Es ist ein Vertrag: Jeder Typ, der es übernimmt, verspricht, alles bereitzustellen, was das Protokoll festlegt.
protocol Greetable {
var name: String { get }
func greet() -> String
}Konformität mit einem Protokoll
Ein Typ wird konform, indem er das Protokoll übernimmt und jede Anforderung bereitstellt. Hier erfüllt eine Struktur sowohl die Eigenschaft name als auch die Methode greet().
protocol Greetable {
var name: String { get }
func greet() -> String
}
struct Person: Greetable {
let name: String
func greet() -> String { "Hello, I am " + name }
}
let p = Person(name: "Ada")
print(p.greet())Anforderungen an Eigenschaften
Protokolle legen fest, ob eine Eigenschaft lesbar ({ get }) oder sowohl lesbar als auch beschreibbar ({ get set }) sein muss. Eine gespeicherte oder berechnete Eigenschaft kann eine Anforderung erfüllen, die nur das Lesen erlaubt.
protocol Identifiable {
var id: String { get }
}
struct User: Identifiable {
let id: String
}
print(User(id: "u-1").id)Anforderungen an Methoden
Methodenanforderungen führen den Namen, die Parameter und den Rückgabetyp auf, enthalten aber keinen Methodenkörper. Konforme Typen stellen die Implementierung bereit.
protocol Shape {
func area() -> Double
}
struct Square: Shape {
let side: Double
func area() -> Double { side * side }
}
print(Square(side: 3).area())mutating-Anforderungen
Bei Werttypen müssen Methoden, die self ändern, mit mutating gekennzeichnet werden. Deklarieren Sie die Anforderung mit mutating, damit Strukturen sie erfüllen können.
protocol Toggleable {
mutating func toggle()
}
struct Switch: Toggleable {
var isOn = false
mutating func toggle() { isOn.toggle() }
}
var s = Switch()
s.toggle()
print(s.isOn)Protokolle als Typen
Ein Protokoll ist ein vollwertiger Typ. Sie können es für Variablen, Parameter und Rückgabewerte verwenden und dabei jeden konformen Wert akzeptieren.
protocol Animal { func sound() -> String }
struct Dog: Animal { func sound() -> String { "Woof" } }
struct Cat: Animal { func sound() -> String { "Meow" } }
let animals: [Animal] = [Dog(), Cat()]
for a in animals { print(a.sound()) }Polymorphismus mit Protokollen
Beim Aufruf einer Protokollmethode wird die Methode des konkreten Typs hinter dem Wert aufgerufen. So können Sie über einen einzigen Vertrag Code schreiben, der mit vielen Typen funktioniert.
protocol Describable { func describe() -> String }
struct Book: Describable { let t: String; func describe() -> String { "Book: " + t } }
struct Film: Describable { let t: String; func describe() -> String { "Film: " + t } }
func show(_ d: Describable) { print(d.describe()) }
show(Book(t: "Swift"))
show(Film(t: "Inception"))Anforderungen an Initialisierer
Protokolle können Initialisierer verlangen. Klassen müssen die Implementierung mit required kennzeichnen, damit Unterklassen sie ebenfalls bereitstellen.
protocol FromInt {
init(value: Int)
}
struct Wrapper: FromInt {
let value: Int
init(value: Int) { self.value = value }
}
print(Wrapper(value: 42).value)Protokollvererbung
Ein Protokoll kann von einem oder mehreren anderen Protokollen erben und zusätzlich zu den geerbten Anforderungen weitere festlegen.
protocol Named { var name: String { get } }
protocol Aged: Named { var age: Int { get } }
struct Member: Aged {
let name: String
let age: Int
}
let m = Member(name: "Lin", age: 30)
print(m.name, m.age)Nur für Klassen geltende Protokolle
Kennzeichnen Sie ein Protokoll mit AnyObject, um die Konformität auf Klassen zu beschränken. Das ist für Anforderungen mit Referenzsemantik wie Delegation nützlich.
protocol Counter: AnyObject {
var count: Int { get set }
}
class Box: Counter {
var count = 0
}
let b = Box()
b.count = 5
print(b.count)Konformität prüfen
Verwenden Sie is und as?, um zur Laufzeit zu prüfen, ob ein Wert mit einem Protokoll konform ist.
protocol Flyer { func fly() }
struct Bird: Flyer { func fly() { print("flap") } }
struct Rock {}
let things: [Any] = [Bird(), Rock()]
for t in things {
if let f = t as? Flyer { f.fly() } else { print("grounded") }
}Kurztest
Testen Sie Ihr Verständnis der Protokollanforderungen.
Zusammenfassung
Sie haben gelernt, dass ein Protokoll ein Vertrag ist: Es deklariert Anforderungen an Eigenschaften, Methoden, mutating-Methoden und Initialisierer, ohne Implementierungen bereitzustellen. Typen werden konform, indem sie jede Anforderung erfüllen. Protokolle können als Typen für Polymorphismus verwendet werden, von anderen Protokollen erben und mit AnyObject auf Klassen beschränkt werden.
Lerne Swift mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 122
- Lektionen
- 409
Häufig gestellte Fragen
Ist die Lektion „Protokolle als Verträge“ kostenlos?
Ja — der vollständige Text von „Protokolle als Verträge“ 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 „Protokolle als Verträge“?
Definieren Sie Verhaltensverträge unabhängig von konkreten Typen. 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 1 von 4.
Wie lange dauert die Lektion „Protokolle als Verträge“?
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
- Protokolle als Verträge
- Standardimplementierungen in Extensions
- Protocol Composition
- Bedingte Konformität