polimorfismo

Metodi (overloading)

Questo tipo di polimorfismo è noto anche come function overloading.

All'interno di una classe possiamo avere più metodi con lo stesso nome: l'importante è che il numero degli argomenti o il loro tipo non coincidano. Detto in altri termini due metodi sono diversi se hanno un numero di argomenti diversi o se hanno lo stesso numero di argomenti ma di tipi diversi.

Nel caso di java i metodi non possono però essere differenziati in base al tipo ritornato.

Prendiamo per esempio una classe che consente di impostare il lato di una figura che dovrebbe essere un numero in virgola mobile ma che permettiamo di impostare come testo per comodità dell'utilizzatore.

class Quadrato {
    private double lato;

    public void setLato(double d){
        lato = d;
    }

    public void setLato(String l){
        lato = Double.parseDouble(l);
    }
}

Spesso è utile ad esempio avere diversi costruttori per lo stesso oggetto: in questo caso l'oggetto Persona può essere costruito sia fornendo nome e altezza che il solo nome:

class Persona {
    private double altezza;
    private String nome;

    public Persona(String n, double a){
        nome = n;
        altezza = a;
    }

    public Persona(String n){
        nome = n;
    }
}

Classi (overriding)

Una classe figlia eredita tutti i metodi della classe padre, ma può decidere di ridefinirne alcuni. Quando un metodo viene ridefinito (overridden), nella classe figlia prende il posto di quello originale, e ogni volta che quel metodo viene chiamato su un’istanza della classe figlia verrà eseguita la nuova versione invece di quella ereditata.

In java per esplicitare che un metodo sovrascrive quello della classe padre si mette l'annotazione @Override prima della definizione del metodo, questo non è obbligatorio ma fa si che il compilatore controlli che in effetti si stia facendo overriding.

Vediamo un esempio di overriding definendo la classe Animale con un solo metodo.

class Animale {
  public String verso() {
    return "Verso generico";
  }
}

Ora estendiamo la classe e facciamo overriding del metodo verso()

class Cane extends Animale {
  @Override
  public String verso() {
    return "Bau!";
  }
}

Scriviamo una classe di prova per vedere cosa viene stampato quando si chiama il metodo verso() su diversi oggetti:

class Prova {
  public static void main(String[] args) {
    Animale animale = new Animale();
    Cane cane1 = new Cane();
    Animale cane2 = new Cane();

    System.out.println(animale.verso());  // Output: Verso generico
    System.out.println(cane1.verso());    // Output: Bau!
    System.out.println(cane2.verso());    // Output: Bau!
  }
}

Vediamo in ordine il perché dei diversi output:

• Verso generico perché il primo oggetto è di tipo Animale
• Bau! perché l'oggetto cane1 è di tipo Cane
• Bau! perché sebbene la variabile sia di tipo Animale l'oggetto a cui fa riferimento è in realtà un Cane e quindi viene utilizzato il metodo verso() della classe Cane