Dovremmo @Override l’implementazione del metodo di un’interfaccia?

Un metodo che implementa un metodo di interfaccia dovrebbe essere annotato con @Override ?

Javadoc dell’annotazione Override dice:

Indica che una dichiarazione di metodo è destinata a sostituire una dichiarazione di metodo in una superclass. Se un metodo è annotato con questo tipo di annotazione ma non sovrascrive un metodo superclass, i compilatori sono obbligati a generare un messaggio di errore.

Non penso che un’interfaccia sia tecnicamente una superclass. O è?

Elaborazione di domande

Dovresti usare @Override quando ansible. Impedisce che si commettano semplici errori. Esempio:

 class C { @Override public boolean equals(SomeClass obj){ // code ... } } 

Questo non viene compilato perché non sovrascrive correttamente gli public boolean equals(Object obj) .

Lo stesso vale per i metodi che implementano un’interfaccia (solo 1.6 e successive ) o sovrascrivono il metodo di una class Super.

Credo che il comportamento di javac sia cambiato – con 1.5 ha proibito l’annotazione, con 1.6 no. L’annotazione fornisce un controllo extra in fase di compilazione, quindi se si sta usando 1.6, lo farei.

Dovresti sempre annotare i metodi con @Override se disponibile.

In JDK 5 questo significa sovrascrivere i metodi delle superclassi, in JDK 6 e 7 significa sovrascrivere i metodi delle superclassi e implementare i metodi delle interfacce. Il motivo, come accennato in precedenza, è che consente al compilatore di rilevare gli errori in cui si pensa di sovrascrivere (o implementare) un metodo, ma in realtà stanno definendo un nuovo metodo (firma diversa).

L’esempio equals(Object) vs. equals(YourObject) è un caso standard, ma lo stesso argomento può essere fatto per le implementazioni dell’interfaccia.

Immagino che il motivo per cui non è obbligatorio annotare i metodi di implementazione delle interfacce è che JDK 5 lo ha contrassegnato come un errore di compilazione. Se JDK 6 rendesse questa annotazione obbligatoria, avrebbe rotto la compatibilità all’indietro.

Non sono un utente Eclipse, ma in altri IDE (IntelliJ), l’annotazione @Override viene aggiunta solo quando si implementano i metodi dell’interfaccia se il progetto è impostato come progetto JDK 6+. Immagino che Eclipse sia simile.

Tuttavia, avrei preferito vedere un’annotazione diversa per questo utilizzo, forse un’annotazione @Implements .

Lo userei in ogni occasione. Vedi Quando usi l’annotazione @Override di Java e perché?

JDK 5.0 non ti permette di usare @Override annotazione @Override se stai implementando il metodo dichiarato nell’interfaccia (il suo errore di compilazione), ma JDK 6.0 lo consente. Quindi potrebbe essere ansible configurare le preferenze del progetto in base alle proprie esigenze.

Sovrascrivere i propri metodi ereditati dalle proprie classi non si interromperà in genere sui refactoring utilizzando un ide. Ma se si sostituisce un metodo ereditato da una libreria, si consiglia di usarlo. Se non lo fai, spesso non riceverai alcun errore in una modifica successiva della libreria, ma un bug ben nascosto.

Non è un problema con JDK. In Eclipse Helios, consente l’annotazione @ Override per i metodi di interfaccia implementati, a prescindere da JDK 5 o 6. Come per Eclipse Galileo, l’annotazione @Override non è consentita, a prescindere da JDK 5 o 6.

Per me, spesso questa è l’unica ragione per cui un codice richiede la compilazione di Java 6. Non sono sicuro se ne valga la pena.

Lo stesso Eclipse aggiungerà l’annotazione @Override quando gli dirai di “generare metodi non implementati” durante la creazione di una class che implementa un’interfaccia.

Se una class concreta non sovrascrive un metodo astratto, l’uso di @Override per l’ implementazione è un argomento aperto poiché il compilatore invariabilmente ti avviserà di qualsiasi metodo non implementato. In questi casi, si può argomentare che riduce la leggibilità: sono più le cose da leggere sul codice e, in misura minore, si chiama @Override e non @Implement .

Il problema con l’ @Override è che ti fa pensare di aver dimenticato di chiamare il metodo super.theOverridenMethod() , che è molto confuso . Questo dovrebbe essere cristallino. Forse Java dovrebbe offrire una @Interface da utilizzare qui. Oh bene, ancora un’altra particolarità di Java semi-assed …

In java 6 e versioni successive, è ansible utilizzare @Override per un metodo che implementa un’interfaccia.

Ma, non credo che abbia senso: l’override significa che hai un metodo nella super class, e lo stai implementando nella sottoclass.

Se stai implementando un’interfaccia, penso che dovremmo usare @Implement o qualcos’altro, ma non @Override .

Leggendo javadoc in java8, puoi trovare quanto segue alla dichiarazione dell’interfaccia Ignora:

Se un metodo è annotato con questo tipo di annotazione, i compilatori sono obbligati a generare un messaggio di errore, a meno che almeno una delle seguenti condizioni sia valida:

  • Il metodo esegue l’override o implementa un metodo dichiarato in un supertipo.
  • Il metodo ha una firma che è equivalente a quella di qualsiasi metodo pubblico dichiarato in {@linkplain Object}.

Quindi, almeno in java8, dovresti usare @Override su un’implementazione di un metodo di interfaccia.

Per l’interfaccia, l’uso di @Override ha causato un errore di compilazione. Quindi, ho dovuto rimuoverlo.

Messaggio di errore andato ” The method getAllProducts() of type InMemoryProductRepository must override a superclass method “.

Leggi anche ” One quick fix available: Remove @Override annotation.One quick fix available: Remove @Override annotation.

Era su Eclipse 4.6.3, JDK 1.8.0_144.