Un metodo overload viene utilizzato per riutilizzare il nome di un metodo ma con argomenti diversi, opzionalmente con un differente tipo di ritorno.

Regole per overload

Le regole per l’ overload di un metodo sono:

  • I metodi di overload devono cambiare la lista degli argomenti.
  • Possono cambiare il tipo di ritorno.
  • Possono cambiare il modificatore di accesso.
  • Possono dichiarare nuove o più ampie eccezioni.
  • Un metodo può essere sovraccaricato nella stessa classe o in una sottoclasse.

Ecco un metodo cui si desidera fare l’overload:

[code lang=”java”] /**/
public void cambiareMisura(int misura, String nome, float campione) {}
/**/
[/code]
I seguenti metodi sono sovraccarichi legali del metodo cambiareMisura():
[code lang=”java”] /**/
public void cambiareMisura(int misura, String nome) {}
public int cambiareMisura(int misura, float campione) {}
public void cambiareMisura(float campione, String nome) throws IOException {}
/**/
[/code]
Come invocare un metodo overload
Ciò che definisce qual è il metodo da chiamare sono gli argomenti che vengono passati durante la chiamata. Se si invoca un metodo con un String come argomento, si esegue il metodo che accetta un String come argomento; se si chiama lo stesso metodo ma con un float come argomento, viene eseguito il metodo che accetta un float come argomento e così successivamente. Se un metodo viene invocato con un argomento che non è definito in nessuna delle versioni di overload il compilatore genera un messaggio di errore.
Esempio di una classe con un metodo di overload:
[code lang=”java”] /**/
public class SovracCaricho {
public void Numeri(int x, int y){
System.out.println("Metodo che riceve interi.");
}
public void Numeri(double x, double y){
System.out.println("Metodo che riceve float.");
}
public void Numeri(String stringa){
System.out.println("Metodo che riceve una stringa: "+ stringa);
}
public static void main(String[] args) {
SovracCaricho oggetto = new SovracCaricho();
int a = 1;
int b = 2;
double c = 1.3;
double d = 2.4;
String str = new String("una stringa");
oggetto.Numeri(a,b);
oggetto.Numeri(c,d);
oggetto.Numeri(str);
}
}
/**/
[/code]
Quando si esegue il codice di sopra si ottiene quanto segue:
[code lang=”java”] #
Metodo che riceve interi.
Metodo che riceve float.
Metodo che riceve una stringa: una stringa
#
[/code]
Con l’utilizzo di oggetti, al posto dei tipi primitivi o stringhe, tutto diventa più interessante. Vediamo cosa succede quando si ha un metodo di overload che in una versione prende un Animale come parametro e in un’altra un Cavallo.
[code lang=”java”] /**/
class Animale {}

class Cavallo extends Animale {}

class Animali{
public void MetodoSovracCaricho(Animale a){
System.out.println("Metodo di parametro Animale…");
}
public void MetodoSovracCaricato(Cavallo c){
System.out.println("Metodo di parametro Cavallo…");
}
public static void main(String[] args) {
Animali animali = new Animali();
Animale oggettoAnimale = new Animale();
Cavallo oggettoCavallo = new Cavallo();
animali.MetodoSovracCaricato(oggettoAnimale);
animali.MetodoSovracCaricato(oggettoCavallo);
}
}
/**/
[/code]

Quando si esegue il codice di sopra si ottiene:
[code lang=”java”] #
Metodo di parametro Animale…
Metodo di parametro Cavallo…
#
[/code]
Come previsto, ogni oggetto chiama al metodo secondo il tipo di parametro. Cosa succederebbe se creiamo un riferimento ad Animale su un oggetto Cavallo?
[code lang=”java”] Animale oggettoAnimaleRefCavallo = new Cavallo();
animali.MetodoSovracCaricato(oggettoAnimaleRefCavallo);
[/code]
Il risultato è:
[code lang=”java”] #
Metodo di parametro Animale…
#
[/code]
Anche se in fase di esecuzione l’oggetto è Cavallo e non Animale, la scelta di quale metodo di overload invocare non viene eseguita in modo dinamico in fase di esecuzione, il tipo di riferimento, non l’oggetto corrente, è ciò che determina quale metodo deve essere eseguito.
L’unico caso in Java di sovraccarico(overload) di un operatore è +:
[code lang=”java”] /**/
String str1= new String("Una stringa");
String str2= " altra atringa"
String str3 = str1 + str2;
/*
str2 conterrà: Una stringa altra atringa
*/
[/code]
Regole per l'overload e l'override dei metodi
Ora che abbiamo visto entrambe le forme di riscrivere i metodi, passiamo in rassegna le regole e le differenze tra i due tipi di riscrittura:
Argomenti
In un metodo di overload gli argomenti debbono essere cambiati, mentre nel metodo override non dovrebbero cambiare.
Il tipo di restituzione
In un metodo di overload il tipo di ritorno può cambiare; in un metodo di override non può cambiare, se non per i sottotipi del tipo inizialmente dichiarato.
Eccezioni
In un metodo di overload le eccezioni possono cambiare; in un metodo di override possono essere ridotti o eliminati, ma non si debbono generare nuove eccezioni o ampliarle.
Accesso
In un metodo di overload l’accesso può cambiare; in un metodo di override l’accesso non dovrebbe essere più restrittivo (può essere meno restrittivo).
Invocazione
In un metodo di overload gli argomenti sono quelli che determinano quale metodo deve essere invocato; in un metodo override il tipo di oggetto determina il metodo.
Questo è, in sintesi, tutto ciò che riguarda l’ overloading dei metodi in Java. Qualche dubbio? Lascia un commento.