Quando avviene la sovrascrittura di un metodo (overriding)?

La sovrascrittura di metodo (overriding) avviene nella gerarchia di ereditarietà quando una sottoclasse fornisce la propria implementazione di un metodo già definito nella classe genitore con lo stesso nome, firma (coincidenza di tipo e numero di parametri) e tipo di ritorno (o covariante nel caso del tipo di oggetto di ritorno).

Caratteristiche chiave:

• Ereditarietà: La sovrascrittura è possibile solo nel contesto dell'ereditarietà (classi genitore e figlio).
• Firma: Il metodo nella sottoclasse deve avere la stessa firma (nome, numero e tipi di parametri) e lo stesso tipo di ritorno (o il suo sottotipo covariante) rispetto al metodo nella classe genitore.
• Accessibilità: Il metodo che viene sovrascritto deve essere accessibile alla sottoclasse (generalmente public, protected).
• Polimorfismo: La sovrascrittura è alla base del polimorfismo in runtime, consentendo agli oggetti della sottoclasse di rispondere alla chiamata del metodo in modo proprio, anche se vengono riferiti tramite un riferimento alla classe genitore.

Esempio (Java):

// Classe genitore
class Animal {
    // Metodo che sarà sovrascritto
    public void makeSound() {
        System.out.println("L'animale fa un suono");
    }
}

// Classe figlia
class Dog extends Animal {
    // Sovrascrittura del metodo makeSound()
    @Override // L'annotazione @Override è opzionale, ma consigliata
    public void makeSound() {
        System.out.println("Il cane abbaia");
    }
}

Esempio di utilizzo:

// Creiamo un oggetto Dog
Animal myDog = new Dog();
// Chiamiamo il metodo. Verrà chiamata la versione sovrascritta in Dog
myDog.makeSound(); // Output: Il cane abbaia

// Creiamo un oggetto Animal
Animal someAnimal = new Animal();
// Chiamiamo il metodo. Verrà chiamata la versione di Animal
someAnimal.makeSound(); // Output: L'animale fa un suono