Erkläre protokollorientierte Programmierung mit Protokollen und Extensions.

Question

IT Interview Practice · Accepted Answer

**Protocol-Oriented Programming (POP)** ist Swifts bevorzugte Art, Verhalten zu teilen: Statt von einer Basisklasse zu erben, **erfüllen** Typen **Protokolle**, und **Protocol Extensions** liefern wiederverwendbare Standardimplementierungen. Das ermöglicht Komposition und Code-Wiederverwendung ohne die Starrheit der Einfachvererbung.

## Wie es funktioniert

Ein Protokoll deklariert Anforderungen; eine Extension auf diesem Protokoll liefert Standardverhalten, das jeder Konformer kostenlos erbt.

```swift
protocol Identifiable {
    var id: String { get }          // requirement
}

protocol Describable {
    var name: String { get }
}

// Default implementation shared by ALL conformers
extension Describable {
    func describe() -> String { "Item: \(name)" }
}

struct Product: Identifiable, Describable {   // composes multiple protocols
    let id: String
    let name: String
}

Product(id: "1", name: "Book").describe()     // => "Item: Book" (free)
```

## Protocol Extensions vs. Klassenvererbung

- **Structs und Enums können konform sein** — POP funktioniert mit Value Types, Klassenvererbung nicht.
- **Mehrfachkonformität**: Ein Typ kann viele Protokolle übernehmen; eine Klasse hat nur eine Superklasse.
- **Constrained Extensions** fügen Verhalten nur dort hinzu, wo es sinnvoll ist:

```swift
extension Collection where Element: Numeric {
    func total() -> Element { reduce(0, +) }   // only for numeric collections
}
[1, 2, 3].total()   // => 6
```

## Fallstricke

- **Static vs. Dynamic Dispatch:** Eine Methode, die *nur* in der Extension (nicht im Protokoll) definiert ist, wird statisch anhand des deklarierten Typs der Variable dispatcht — ein Override in einem Konformer wird also über eine protokolltypisierte Referenz möglicherweise nicht aufgerufen. Deklariere sie im Protokoll, um Dynamic Dispatch zu erhalten.

## Warum es wichtig ist

POP ist das Rückgrat der Swift-Standardbibliothek (`Equatable`, `Collection`, `Codable`) und testbarer Architektur — du hängst von Protokollen ab und tauschst Konformer gegen Mocks aus. Interviewer prüfen das, um zu sehen, ob du Verhalten mit Protokollen komponierst, statt tiefe, brüchige Klassenhierarchien zu bauen.

Wie es funktioniert

Protocol Extensions vs. Klassenvererbung

Fallstricke

Warum es wichtig ist

Ähnliche Fragen