Come funziona l'ereditarietà nel linguaggio Swift?

In Swift, l'ereditarietà viene realizzata tramite le classi. Una classe può ereditare proprietà e metodi da un'altra classe.

• Classe base: Classe dalla quale altre classi ereditano. Non eredita da nessun'altra classe.
• Classe derivata (sottoclasse): Classe che eredita dalla classe base. Può aggiungere nuove proprietà e metodi, oltre a sovrascrivere quelli ereditati.

Punti chiave:

• Swift supporta solo ereditarietà singola (una classe può ereditare da una sola classe).
• Uso della parola chiave class per definire una classe.
• Uso dei due punti : dopo il nome della classe derivata, seguito dal nome della classe base.
• Sovrascrittura di metodi e proprietà con la parola chiave override.
• Divieto di sovrascrittura con la parola chiave final prima della definizione della classe, metodo o proprietà.

// Classe base
class Vehicle {
    var currentSpeed = 0.0

    func accelerate() {
        currentSpeed += 10
    }

    func description() -> String {
        return "viaggiando a \(currentSpeed) mph"
    }
}

// Classe derivata
class Car: Vehicle {
    var gear = 1

    // Sovrascrittura del metodo
    override func accelerate() {
        super.accelerate() // Chiamata al metodo della classe base
        gear += 1
    }

    // Aggiunta di un nuovo metodo
    func changeGear(to newGear: Int) {
        gear = newGear
    }

    // Sovrascrittura della proprietà (calcolata)
    override func description() -> String {
        return super.description() + " in marcia \(gear)"
    }
}

// Classe vietata all'ereditarietà
final class Motorcycle: Vehicle {
    // Può avere proprie proprietà e metodi, ma non può essere ereditata
}

Vantaggi dell'ereditarietà:

• Riutilizzo del codice: Le classi derivate utilizzano le funzionalità della classe base.
• Polimorfismo: Possibilità di lavorare con oggetti di diverse classi derivate tramite un riferimento alla classe base.
• Estendibilità: Aggiunta di nuove funzionalità nelle classi derivate senza modificare quella base.

Svantaggi dell'ereditarietà:

• Collegamento rigido: Le modifiche alla classe base possono influenzare le classi derivate.
• Problema del diamante (nelle lingue con ereditarietà multipla): Swift non lo presenta grazie all'ereditarietà singola.
• Complessità della gerarchia: Gerarchie profonde possono essere difficili da comprendere e mantenere.

Swift preferisce la composizione all'ereditarietà per raggiungere flessibilità e riutilizzo del codice, specialmente quando si lavora con protocolli ed estensioni. Tuttavia, l'ereditarietà è uno strumento importante per creare strutture gerarchiche e implementare i principi della programmazione orientata agli oggetti.