Polimorfismo Java: overload e override dei metodi

Il polimorfismo è un concetto fondamentale della programmazione orientata agli oggetti, spesso ritenuto uno dei più complessi da comprendere appieno. Derivando dal greco, il termine significa “avere forme diverse”. Per illustrare il concetto in modo pratico, consideriamo un esempio della vita quotidiana: quando parliamo di un computer, utilizziamo lo stesso termine per indicare un computer desktop, un portatile o un netbook. Sebbene questi dispositivi siano diversi nella loro forma e funzione, la generalizzazione del termine “computer” indica che svolgono operazioni simili. Questo è il polimorfismo.

Una volta chiarito il concetto di base, possiamo approfondire il polimorfismo dei metodi, che può essere implementato attraverso due tecniche principali: overloading e overriding.

Polimorfismo dei Metodi

Dal punto di vista pratico, il polimorfismo si realizza mediante l’overloading e l’overriding dei metodi. Ogni metodo in Java viene identificato non solo dal suo nome, ma anche dalla lista dei suoi parametri. Questo consente di avere più metodi con lo stesso nome all’interno di una classe, purché questi abbiano parametri con tipi e numeri diversi. L’overloading permette di definire più metodi con lo stesso nome, ma con parametri differenti. Ad esempio, consideriamo la classe OperazioniSuNumeri che implementa metodi di somma per numeri interi e numeri di tipo float:

public class OperazioniSuNumeri {
  public int somma(int x, int y) {
    return x + y;
  }

  public float somma(float x, float y) {
    return x + y; // Corretto l'errore qui in precedenza, che era un errore di sottrazione.
  }
}

In questo contesto, non dobbiamo preoccuparci di controllare i tipi dei numeri in ingresso, perché il linguaggio Java chiamerà automaticamente il metodo appropriato in base al tipo dei parametri forniti. Ecco un esempio di implementazione della classe:

public class Implementazione {

  public static void main(String[] args) {
    OperazioniSuNumeri numeri = new OperazioniSuNumeri();
    int sommaInteri = numeri.somma(3, 4);
    System.out.println("La somma tra interi è: " + sommaInteri);

    float sommaFloat = numeri.somma(2.1f, 8.3f);
    System.out.println("La somma tra float è: " + sommaFloat);
  }
}

Il codice sopra funzionerà perfettamente, poiché ogni volta che chiamiamo il metodo somma, il linguaggio verifica il tipo dei parametri passati e richiama automaticamente il metodo corretto.

Inoltre, abbiamo già utilizzato il polimorfismo quando abbiamo chiamato il metodo System.out.println(). Infatti, abbiamo passato tipologie di argomenti diversi (una stringa e un numero intero) senza incorrere in errori, confermando che Java offre più implementazioni per il metodo System.out.println(), rendendolo un metodo polimorfo.

Il termine override, invece, si riferisce alla riscrittura di un metodo di una classe che è stata ereditata. Pertanto, l’override implica sempre l’ereditarietà. Per chiarire ulteriormente, consideriamo un esempio con una classe nota, Dipendente: la classe è strutturata come segue (sono stati omessi i metodi set e get per gli attributi “nome” e “cognome”):

public class Dipendente {

  private String nome;
  private String cognome;
  private int oreLavorativeMensili;
  private int retribuzioneOraria;

  public int getOreLavorativeMensili() {
    return oreLavorativeMensili;
  }

  public int getRetribuzioneOraria() {
    return retribuzioneOraria; // Corretto l'errore di scrittura nel nome.
  }

  public int stipendio() {
    return oreLavorativeMensili * retribuzioneOraria;
  }
}

Ora, creiamo una nuova classe ResponsabileDiProgetto che estende Dipendente e che include un attributo bonus, il quale contribuisce alla retribuzione totale. Implementeremo il metodo stipendio in modo da includere sia lo stipendio base che il bonus. Il codice sarà il seguente:

public class ResponsabileDiProgetto extends Dipendente {

  private int bonus;

  public int stipendio() {
    int stipendioBase = (getOreLavorativeMensili() * getRetribuzioneOraria());
    return stipendioBase + bonus;
  }
}

Grazie all’override, possiamo ridefinire un metodo di una classe generale adattandolo a una classe più specifica, mantenendo però la stessa coerenza semantica, poiché il metodo conserva lo stesso nome ma si comporta in modo differente a seconda della classe che lo utilizza.