Overriding dei Metodi in Java

Concetti Chiave

L'override dei metodi in Java consente a una sottoclasse di fornire una specifica implementazione di un metodo già definito nella sua superclasse.
Quando un metodo viene sovrascritto, la versione della sottoclasse viene chiamata, nascondendo la versione della superclasse.
Per accedere alla versione della superclasse di un metodo sovrascritto, si può utilizzare la parola chiave super.
L'override avviene solo quando i nomi e le firme di tipo dei metodi sono identici; altrimenti, si tratta di un caso di overloading dei metodi.
L'overloading dei metodi consente di definire più metodi con lo stesso nome ma con firme di tipo diverse, permettendo una maggiore flessibilità nell'utilizzo dei metodi.

Override dei Metodi

In una gerarchia di classi, quando un metodo in una sottoclasse ha lo stesso nome e la stessa firma di tipo di un metodo nella sua superclasse, allora si dice che il metodo nella sottoclasse esegue un override del metodo nella superclasse oppure che il metodo sovrascrive il metodo della superclasse.

Quando un metodo sovrascritto viene chiamato tramite la sua sottoclasse, si farà sempre riferimento alla versione di quel metodo definita dalla sottoclasse. La versione del metodo definita dalla superclasse verrà nascosta.

Si consideri il seguente esempio:

// Override dei metodi.
class A {
    int i, j;

    A(int a, int b) {
        i = a;
        j = b;
    }

    // mostra i e j
    void mostra() {
        System.out.println("i e j: " + i + " " + j);
    }
}

class B estende A {
    int k;

    B(int a, int b, int c) {
        super(a, b);
        k = c;
    }

    // mostra k - questo esegue l'override di mostra() in A
    void mostra() {
        System.out.println("k: " + k);
    }
}

class Override {
    public static void main(String[] argomenti) {
        B sottoOggetto = new B(1, 2, 3);

        sottoOggetto.mostra(); // questo chiama mostra() in B
    }
}

L'output prodotto da questo programma è mostrato qui:

k: 3

Quando mostra() viene invocato su un oggetto di tipo B, viene utilizzata la versione di mostra() definita all'interno di B. Cioè, la versione di mostra() all'interno di B esegue l'override della versione dichiarata in A.

Se si desidera accedere alla versione della superclasse di un metodo sovrascritto, è possibile farlo utilizzando super. Per esempio, in questa versione di B, viene invocata la versione della superclasse di mostra() all'interno della versione della sottoclasse. Questo consente di visualizzare tutte le variabili di istanza.

class B estende A {
    int k;

    B(int a, int b, int c) {
        super(a, b);
        k = c;
    }

    void mostra() {
        super.mostra(); // questo chiama mostra() di A
        System.out.println("k: " + k);
    }
}

Se si sostituisce questa versione di A nel programma precedente, si otterrà il seguente output:

i e j: 1 2
k: 3

Qui, super.mostra() chiama la versione della superclasse di mostra().

Il metodo di override avviene solo quando i nomi e le firme di tipo dei due metodi sono identici.

Se non lo sono, allora i due metodi sono semplicemente sovraccarichi, ossia si tratta di un caso di overloading dei metodi.

Ad esempio, si consideri questa versione modificata dell'esempio precedente:

// Metodi con firme di tipo differenti sono sovraccarichi - non sovrascritti.
class A {
    int i, j;

    A(int a, int b) {
        i = a;
        j = b;
    }

    // mostra i e j
    void mostra() {
        System.out.println("i e j: " + i + " " + j);
    }
}

// Crea una sottoclasse estendendo la classe A.
class B estende A {
    int k;

    B(int a, int b, int c) {
        super(a, b);
        k = c;
    }

    // sovraccarica mostra()
    void mostra(String msg) {
        System.out.println(msg + k);
    }
}

class Override {
    public static void main(String[] argomenti) {
        B sottoOggetto = new B(1, 2, 3);

        sottoOggetto.mostra("Questo è k: "); // questo chiama mostra() in B
        sottoOggetto.mostra();               // questo chiama mostra() in A
    }
}

L'output prodotto da questo programma è mostrato qui:

Questo è k: 3
i e j: 1 2

La versione di mostra() in B accetta un parametro di tipo stringa. Questo rende la sua firma di tipo diversa da quella nella classe A, che non accetta parametri. Pertanto, non avviene alcun override (né occultamento del nome). Invece, la versione di mostra() in B semplicemente sovraccarica la versione di mostra() in A.