Quando avviene la sovrascrittura di un metodo…

La sovrascrittura di metodo nella programmazione orientata agli oggetti avviene quando una sottoclasse ha un metodo con lo stesso nome, firma (lista di parametri) e tipo di ritorno di un metodo nella sua classe padre. Questo permette alla sottoclasse di fornire la propria implementazione del metodo ereditato.

Condizioni principali per la sovrascrittura:

Ereditarietà: La sottoclasse deve ereditare dalla classe padre.
Firma del metodo: Il metodo che viene sovrascritto nella sottoclasse deve avere la stessa firma (nome del metodo e lista dei tipi di parametri, loro ordine e quantità) del metodo nella classe padre. In alcuni linguaggi (ad esempio Java) è anche richiesto che il tipo di ritorno corrisponda o sia covariante.
Modificatori di accesso: Il modificatore di accesso del metodo sovrascritto nella sottoclasse non può essere più restrittivo di quello del metodo nella classe padre.
Non si può sovrascrivere: Metodi statici (static), finali (final in Java, sealed in C#) e privati (private) non partecipano al polimorfismo tramite ereditarietà.

Esempio in Java:

// Classe padre
class Animal {
    public void sound() {
        // Implementazione di default
        System.out.println("L'animale fa un suono");
    }
}

// Sottoclasse che sovrascrive il metodo sound()
class Dog extends Animal {
    @Override // Annotazione per verifica del compilatore
    public void sound() {
        // Implementazione specifica per Dog
        System.out.println("Il cane abbaia");
    }
}

class Main {
    public static void main(String[] args) {
        Animal mioAnimale = new Animal();
        Animal mioCaneComeAnimale = new Dog(); // Polimorfismo
        Dog mioCane = new Dog();

        mioAnimale.sound();      // Chiama sound() di Animal
        mioCaneComeAnimale.sound(); // Chiama il sound() sovrascritto di Dog (grazie al polimorfismo)
        mioCane.sound();         // Chiama il sound() sovrascritto di Dog
    }
}

Esempio in Python:

# Classe padre
class Animal:
    def sound(self):
        # Implementazione di default
        print("L'animale fa un suono")

# Sottoclasse che sovrascrive il metodo sound()
class Dog(Animal):
    def sound(self):
        # Implementazione specifica per Dog
        print("Il cane abbaia")

# Uso
mio_animale = Animal()
mio_caneComeAnimale = Dog() # Polimorfismo
mio_cane = Dog()

mio_animale.sound()       # Chiama sound() di Animal
mio_caneComeAnimale.sound()  # Chiama il sound() sovrascritto di Dog (grazie al polimorfismo)
mio_cane.sound()          # Chiama il sound() sovrascritto di Dog

La sovrascrittura viene utilizzata per ottenere il polimorfismo in fase di esecuzione, consentendo di eseguire azioni diverse a seconda del tipo effettivo dell'oggetto, nonostante si utilizzi un riferimento alla classe padre. Questo è un principio chiave della programmazione orientata agli oggetti per costruire sistemi flessibili ed estensibili.

Quando avviene la sovrascrittura di un metodo (Overriding)?