Swift Academy · Lektion

override, final und das Verhindern von Unterklassen

Überschreiben Sie Methoden und Eigenschaften und versiegeln Sie Klassen mit final.

override, final und das Verhindern von Unterklassen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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

Mit dem Schlüsselwort `override` können Unterklassen Implementierungen der Oberklasse ersetzen. `final` verhindert weiteres Überschreiben oder die Bildung von Unterklassen und schützt so Ihren API-Vertrag.

override-Methoden

```swift class Animal { func speak() { print("...") } } class Cat: Animal { override func speak() { print("Meow") } } Cat().speak() // "Meow" ``` `override` ist obligatorisch — der Compiler weist versehentliches Überschatten zurück.

override-Eigenschaften

```swift class Shape { var area: Double { 0 } } class Square: Shape { var side: Double init(_ s: Double) { side = s } override var area: Double { side * side } } print(Square(4).area) // 16 ```

super in einer Überschreibung aufrufen

```swift class Logger { func log(_ msg: String) { print("[LOG] \(msg)") } } class TimedLogger: Logger { override func log(_ msg: String) { print(Date(), terminator: " ") super.log(msg) } } ```

final-Methoden und -Eigenschaften

Kennzeichnen Sie eine Methode oder Eigenschaft mit `final`, um das Überschreiben zu verhindern: ```swift class BankAccount { final func transfer(amount: Double) { ... } // cannot override var balance: Double = 0 } ```

final-Klassen

Kennzeichnen Sie eine gesamte Klasse mit `final`, um die Bildung von Unterklassen zu verhindern: ```swift final class Singleton { static let shared = Singleton() private init() {} } // class Sub: Singleton { } ❌ ``` `final` ermöglicht außerdem Optimierungen — der Compiler kann Aufrufe statisch dispatchen.

Warum final verwenden?

Vorteile von `final`: 1. Performance: statischer Dispatch statt einer Suche in der virtuellen Methodentabelle 2. Sicherheit: Der API-Vertrag wird durchgesetzt — Unterklassen können Ihre Invarianten nicht verletzen 3. Dokumentation: Signalisiert, dass die Klasse nicht für Vererbung vorgesehen ist

Berechnete Eigenschaften überschreiben

```swift class Vehicle { var description: String { "Vehicle" } } class Tesla: Vehicle { override var description: String { "Tesla - " + super.description } } print(Tesla().description) // "Tesla - Vehicle" ```

Eigenschaftsbeobachter überschreiben

```swift class A { var x = 0 } class B: A { override var x: Int { didSet { print("B.x changed to \(x)") } } } var b = B() b.x = 5 // "B.x changed to 5" ```

Versehentliches Überschreiben verhindern

Ohne `override` ist versehentliches Überschatten ein Kompilierungsfehler: ```swift class Parent { func greet() { } } class Child: Parent { func greet() { } // ❌ must write 'override' } ``` Dies schützt vor unbemerkten Fehlern, wenn sich die APIs der Oberklasse weiterentwickeln.

Kurze Überprüfung

Welches Schlüsselwort verhindert, dass eine Klasse als Unterklasse verwendet wird?

Zusammenfassung

Wichtige Erkenntnisse: • `override` ist erforderlich, wenn Sie eine Methode oder Eigenschaft der Oberklasse ersetzen • `super.method()` ruft die Version der Oberklasse auf • `final func/var` — verhindert das Überschreiben dieses bestimmten Members • `final class` — verhindert jede Unterklassenbildung • `final` ermöglicht statischen Dispatch — ein kostenloser Performancegewinn Als Nächstes: Typ-Casting mit is, as? und as!

Häufig gestellte Fragen

Ist die Lektion „override, final und das Verhindern von Unterklassen“ kostenlos?

Ja — der vollständige Text von „override, final und das Verhindern von Unterklassen“ 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 „override, final und das Verhindern von Unterklassen“?

Überschreiben Sie Methoden und Eigenschaften und versiegeln Sie Klassen mit final. 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 2 von 4.

Wie lange dauert die Lektion „override, final und das Verhindern von Unterklassen“?

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

Klassenvererbung und das Schlüsselwort super
override, final und das Verhindern von Unterklassen
Typumwandlung: is, as?, as! und as
Deinitialisierer und Speicherlebenszyklus

← Zurück zu Swift Academy