Swift Academy · Lezione

Principi della progettazione orientata ai protocolli

Preferire la composizione dei protocolli all’ereditarietà delle classi per una progettazione flessibile.

Principi della progettazione orientata ai protocolli è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Benvenuto

La programmazione orientata ai protocolli (POP) privilegia la composizione dei protocolli rispetto all'ereditarietà tra classi per creare codice Swift flessibile, testabile e riutilizzabile.

Il problema dell'ereditarietà

Le gerarchie profonde di classi causano diversi problemi: • Le sottoclassi ereditano tutto lo stato e il comportamento della superclasse • Una modifica alla superclasse può rompere le sottoclassi • Non è possibile ereditare da due classi I protocolli risolvono tutti e tre questi problemi.

Inizi con un protocollo

```swift protocol Greetable { var greeting: String { get } func greet() } extension Greetable { func greet() { print(greeting) } // default implementation } ``` Le estensioni dei protocolli forniscono implementazioni predefinite che ogni tipo conforme riceve automaticamente.

Composizione dei comportamenti

```swift protocol Persistable { func save() } protocol Networked { func fetch() async throws -> Data } protocol Loggable { func log(_ msg: String) } struct DataService: Persistable, Networked, Loggable { ... } ``` Combini i comportamenti come mattoncini LEGO, senza bisogno di una gerarchia di classi.

Estensioni dei protocolli per la logica condivisa

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

Modellazione retroattiva

I protocolli possono essere applicati a tipi che non si possiedono: ```swift protocol JSONConvertible { func toJSON() -> String } extension Int: JSONConvertible { func toJSON() -> String { "\(self)" } } ``` Può aggiungere conformità ai tipi della libreria standard senza ricorrere all'ereditarietà.

Tipi valore + protocolli

Le struct conformi ai protocolli offrono sia semantica di valore *sia* polimorfismo: ```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 tramite protocollo

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

Quando usare le classi

Preferisca le classi quando: • È necessario uno stato mutabile condiviso (semantica di riferimento) • È richiesta l'integrazione con le API di ObjC/UIKit • L'ereditarietà rappresenta il modello corretto (caso raro) Negli altri casi, scelga come impostazione predefinita protocolli e struct.

Convenzioni per i nomi dei protocolli

• Protocolli che esprimono capacità: suffissi `-able`, `-ible`, `-ing` (Equatable, Hashable, Coding) • Protocolli delegate: suffisso `Delegate` o `DataSource` • Ruoli astratti: sostantivi (`Store`, `Parser`, `Renderer`) I nomi efficaci rendono il codice orientato ai protocolli autoesplicativo.

Verifica rapida

Cosa forniscono le estensioni dei protocolli ai tipi conformi?

Riepilogo

Punti chiave: • Preferisca protocolli e struct alle gerarchie di classi • Le estensioni dei protocolli forniscono implementazioni predefinite condivise • Combini comportamenti a partire da protocolli piccoli e con uno scopo preciso • I protocolli consentono la dependency injection, migliorando la testabilità • Riservi le classi alla semantica di riferimento e all'interoperabilità con ObjC Corso completato! Successivo: tipi valore e tipi riferimento in dettaglio.

Domande Frequenti

La lezione «Principi della progettazione orientata ai protocolli» è gratuita?

Sì — il testo completo di «Principi della progettazione orientata ai protocolli» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Principi della progettazione orientata ai protocolli»?

Preferire la composizione dei protocolli all’ereditarietà delle classi per una progettazione flessibile. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Principi della progettazione orientata ai protocolli»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Composizione di protocolli con &
Conformità condizionale
Requisiti Self e progettazione Equatable
Principi della progettazione orientata ai protocolli

← Torna a Swift Academy