Override

Da Wikipedia, l'enciclopedia libera.
(Reindirizzamento da Overriding)

Nella programmazione ad oggetti override è l'operazione di riscrittura di un metodo ereditato.

Nella programmazione ad oggetti assume notevole importanza la possibilità di creare classi a partire da classi già esistenti (ereditarietà). La classe nuova che eredita quella esistente può avere metodi ereditati che possono essere riscritti per le nuove necessità.

Esempio in java[modifica | modifica wikitesto]

Definiamo ora la prima classe, Punto:

public class Punto {
     private int a, b;

     public Punto (int a, int b) { 
           this.a = a;
           this.b = b;
    }

     public void setA (int a) {
           this.a = a;
    }

     public int getA () {
           return a;
    }

     public void setB (int b) {
           this.b = b;
    }

     public int getB () {
           return b;
    }

     public double distanza_origine () {
           int x = (a*a)+(b*b);
           return Math.sqrt(x);
    }

}

Ora implementiamo invece la classe Punto3D che eredita dalla classe Punto

public class Punto3D extends Punto {
     private int c;

     public Punto3D (int a, int b, int c) { 
           super (a,b);
           this.c = c;
    }

     public void setC (int c) {
           this.c = c;
    }

     public int getC () {
           return c;
    }

     public double distanza_origine () {
           int x = (getA()*getA())+(getB()*getB())+(c*c);
           return Math.sqrt(x);
    }

}

È stato possibile ridefinire il blocco di codice del metodo distanza_origine() per introdurre la terza coordinata (variabile c), affinché il calcolo della distanza sia eseguito correttamente nella classe Punto3D. La chiamata al costruttore della superclasse è avvenuta attraverso una sintassi speciale che sfrutta il reference super. Tale istruzione (super(a,b)) deve essere la prima del costruttore e non potrà essere inserita all'interno di un metodo che non sia un costruttore.

L'override impone delle regole da seguire:

  • Il metodo ridefinito ha la stessa firma del metodo originale della superclasse;
  • Il metodo ridefinito nella sottoclasse non deve essere meno accessibile del metodo originale della superclasse. Per esempio, se un metodo ereditato è dichiarato protetto, non si può ridefinire privato, semmai pubblico;
  • Il tipo di ritorno del metodo deve coincidere con quello del metodo che si sta riscrivendo.

In realtà, dalla versione 5 di java in poi, il tipo di ritorno del metodo può coincidere anche con una sottoclasse del tipo di ritorno del metodo originale. In questo caso si parla di "tipo di ritorno covariante". Per esempio, sempre considerando il rapporto di ereditarietà che sussiste tra le classi Punto e Punto3D, se nella classe Punto fosse presente il seguente metodo:

public Punto getAddress() {
     return this;
    }

allora sarebbe legale implementare il seguente override nella classe Punto3D

public Punto3D getAddress() {
     return this;
    }

Annotazione sull'override[modifica | modifica wikitesto]

Uno degli errori più comuni che può commettere un programmatore è sbagliare un override. Ovvero ridefinire in maniera non corretta un metodo che si vuole riscrivere in una sottoclasse, magari digitando una lettera minuscola piuttosto che maiuscola, o sbagliando il numero di parametri in input. in tali casi il compilatore non segnalerà errori, dal momento che non può intuire il tentativo di override in atto. Quindi, per esempio, il seguente codice in java:

public class MiaClasse {
     ...
     public String tostring() { // per avere l'override, si dovrebbebbe scrivere toString e non tostring
           ...
    }
}

è compilato correttamente, ma non sussisterà nessun override in MiaClasse. Il grosso problema è che questo errore si presenterà in fase di esecuzione e non è detto che lo si riesca a correggere velocemente. Per ovviare a questo problema, occorre utilizzare l'annotazione Override presente nel package java.lang.. Tale annotazione serve a marcare i metodi che vogliono essere la riscrittura di metodi ereditati. Essa richiede l'uso di un carattere del tutto nuovo alla sintassi Java: @. Nel nostro esempio, il metodo verrà marcato nel seguente modo:

public class MiaClasse {
     ...
     @Override
     public String toString() { 
           ...
    }
}

Se si violasse qualche regola dell'override, otterremo un errore direttamente in compilazione. Avere un errore in compilazione, ovviamente, è molto meglio che averlo in fase di esecuzione.