In quali situazioni l'ereditarietà nella programmazione orientata agli oggetti è utile e in quali casi dovrebbe essere evitata?

L'eredità è utile per:

• Riutilizzo del codice: La funzionalità comune viene inserita in una classe base.
• Creazione di gerarchie di tipi (relazione is-a): Quando una classe figlia è una variante della classe genitore.
• Polimorfismo: La capacità di trattare oggetti di diversi tipi tramite un'interfaccia comune della classe base.
• Estensione delle funzionalità: Aggiunta di nuovi metodi o campi a una classe esistente.

Da evitare l'ereditarietà quando:

• Viene violato il principio di sostituzione di Liskov: La classe figlia non può sostituire completamente la classe base senza modificare la correttezza del programma.
• Viene creata una relazione rigida tra le classi: Le modifiche alla classe base possono influenzare indesideratamente tutte le classi figlie.
• È necessario combinare funzionalità di fonti non correlate (relazione has-a): È meglio usare la composizione.
• Eccessiva complessità della gerarchia: Le catene profonde di ereditarietà sono difficili da mantenere e comprendere.
• L'ereditarietà per il riutilizzo del codice quando la funzionalità non è un "tipo" comune: È meglio usare classi di utilità o delega.

// Esempio, quando l'ereditarietà è utile
open class Animal {
    open fun makeSound() {
        println("Suono generico dell'animale")
    }
}

class Dog : Animal() { // Dog È-UN Animal
    override fun makeSound() {
        println("Bau")
    }
}

class Cat : Animal() { // Cat È-UN Animal
    override fun makeSound() {
        println("Miao")
    }
}

// Esempio, quando la composizione è preferibile all'ereditarietà per la relazione "has-a"
class Engine {
    fun start() { println("Motore avviato") }
}

// Invece di ereditare da Engine per Car
// class Car : Engine() // Progetto sbagliato, Car NON È-UN Engine

class Car {
    private val engine = Engine() // Car HA-UN Engine
    fun drive() {
        engine.start()
        println("Auto in movimento")
    }
}