Swift Academy · Lezione

override, final e prevenzione delle sottoclassi

Sovrascrivere metodi e proprietà e rendere non estendibili le classi con final.

override, final e prevenzione delle sottoclassi è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 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 parola chiave `override` consente alle sottoclassi di sostituire le implementazioni della superclasse. `final` impedisce ulteriori override o sottoclassificazioni, proteggendo il contratto della propria API.

Metodi override

```swift class Animal { func speak() { print("...") } } class Cat: Animal { override func speak() { print("Meow") } } Cat().speak() // "Meow" ``` `override` è obbligatorio: il compilatore rifiuta l'oscuramento accidentale.

Proprietà override

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

Chiamare super nell'override

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

Metodi e proprietà final

Contrassegni un metodo o una proprietà come `final` per impedirne l'override: ```swift class BankAccount { final func transfer(amount: Double) { ... } // cannot override var balance: Double = 0 } ```

Classi final

Contrassegni un'intera classe come `final` per impedirne la sottoclassificazione: ```swift final class Singleton { static let shared = Singleton() private init() {} } // class Sub: Singleton { } ❌ ``` `final` abilita anche le ottimizzazioni: il compilatore può effettuare il dispatch statico delle chiamate.

Perché usare final?

Vantaggi di `final`: 1. Prestazioni: dispatch statico invece della ricerca nella tabella virtuale 2. Sicurezza: il contratto dell'API viene applicato e le sottoclassi non possono violare le invarianti 3. Documentazione: segnala che la classe non è progettata per essere ereditata

Override di proprietà calcolate

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

Override degli osservatori delle proprietà

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

Prevenzione dell'override accidentale

Senza `override`, una ridefinizione accidentale genera un errore di compilazione: ```swift class Parent { func greet() { } } class Child: Parent { func greet() { } // ❌ must write 'override' } ``` Questo protegge dai bug silenziosi quando le API della superclasse evolvono.

Verifica rapida

Quale parola chiave impedisce a una classe di essere sottoclassificata?

Riepilogo

Concetti chiave: • `override` è obbligatorio quando si sostituisce un metodo o una proprietà della superclasse • `super.method()` chiama la versione della classe padre • `final func/var` — impedisce l'override di quel membro specifico • `final class` — impedisce qualsiasi sottoclassificazione • `final` abilita il dispatch statico: un miglioramento gratuito delle prestazioni Prossimo argomento: conversione di tipo con is, as? e as!

Domande Frequenti

La lezione «override, final e prevenzione delle sottoclassi» è gratuita?

Sì — il testo completo di «override, final e prevenzione delle sottoclassi» è 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 «override, final e prevenzione delle sottoclassi»?

Sovrascrivere metodi e proprietà e rendere non estendibili le classi con final. 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 2 di 4.

Quanto tempo richiede la lezione «override, final e prevenzione delle sottoclassi»?

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

Ereditarietà delle classi e parola chiave super
override, final e prevenzione delle sottoclassi
Conversione dei tipi: is, as?, as! e as
Deinizializzatori e ciclo di vita della memoria

← Torna a Swift Academy