Dovremmo @ Sovrascrivere l'implementazione del metodo di un'interfaccia?

StackOverflow https://stackoverflow.com/questions/212614

Domanda

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

Il javadoc del Override annotazione dice:

  

Indica che una dichiarazione di metodo ha lo scopo di sovrascrivere una dichiarazione di metodo in una superclasse. Se un metodo è annotato con questo tipo di annotazione ma non sostituisce un metodo superclasse, i compilatori sono tenuti a generare un messaggio di errore.

Non penso che un'interfaccia sia tecnicamente una superclasse. O è?

Elaborazione di domande

È stato utile?

Soluzione

Dovresti usare @Override quando possibile. Impedisce che vengano fatti semplici errori. Esempio: 

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

Questo non viene compilato perché non sostituisce correttamente valore booleano pubblico (Object obj) .

Lo stesso vale per i metodi che implementano un'interfaccia ( solo 1.6 e versioni successive ) o hanno la precedenza sul metodo di una classe Super.

Altri suggerimenti

Credo che il comportamento di javac sia cambiato - con 1.5 ha vietato l'annotazione, con 1.6 no. L'annotazione fornisce un ulteriore controllo in fase di compilazione, quindi se stai usando 1.6 lo farei.

Dovresti sempre annotare i metodi con @Override se è disponibile.

In JDK 5 questo significa scavalcare i metodi delle superclassi, in JDK 6 e 7 significa scavalcare i metodi delle superclasse e implementare metodi di interfacce. Il motivo, come menzionato in precedenza, è che consente al compilatore di rilevare errori laddove si ritiene che si stia sovrascrivendo (o implementando) un metodo, ma in realtà si sta definendo un nuovo metodo (firma diversa).

L'esempio equals (Object) vs. equals (YourObject) è un caso standard al punto, 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 sia che JDK 5 lo abbia contrassegnato come errore di compilazione. Se JDK 6 rendesse obbligatoria questa annotazione, si romperebbe la compatibilità all'indietro.

Non sono un utente Eclipse, ma in altri IDE (IntelliJ), l'annotazione @Override viene aggiunta solo quando si implementano metodi di 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 .

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

Sovrascrivere i propri metodi ereditati dalle proprie classi in genere non si romperà sui refactoring usando un ide. Ma se si ignora un metodo ereditato da una libreria, si consiglia di utilizzarlo. Se non lo fai, spesso non otterrai alcun errore in una successiva modifica 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.

Se una classe concreta non è ignora un metodo astratto, usare @Override per implementazione è un metodo aperto importa dal momento che il compilatore ti invariabilmente avviserà di eventuali metodi non implementati. In questi casi, si può argomentare che toglie la leggibilità: sono più cose da leggere sul tuo codice e, in misura minore, si chiama @Override e non @ implementare .

Per me, spesso questo è l'unico motivo per cui alcuni codici richiedono la compilazione di Java 6. Non sono sicuro se ne valga la pena.

Eclipse stesso aggiungerà l'annotazione @Override quando dici di "generare metodi non implementati" durante la creazione di una classe che implementa un'interfaccia.

Il problema con l'inclusione del @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 un @Interface da utilizzare qui. Vabbè, l'ennesima peculiarità di Java a metà culo ...

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

Ma non credo abbia senso: l'override significa che hai un metodo nella super classe e lo stai implementando nella sottoclasse.

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

Leggendo javadoc in java8, è possibile trovare quanto segue nella dichiarazione di override dell'interfaccia:

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

  • Il metodo ha la precedenza o implementa un metodo dichiarato in un supertipo.
  • Il metodo ha una firma che ha la precedenza 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.

Il messaggio di errore è andato " Il metodo getAllProducts () di tipo InMemoryProductRepository deve sovrascrivere un metodo superclasse " ;.

Legge anche " Una soluzione rapida disponibile: rimuovi l'annotazione @Override. "

Era su Eclipse 4.6.3, JDK 1.8.0_144.

Se la classe che sta implementando l'interfaccia è una classe abstract , @Override è utile per garantire che l'implementazione sia per un < metodo code> interface ; senza la @Override una classe abstract sarebbe semplicemente compilata bene anche se la firma del metodo di implementazione non corrispondesse al metodo dichiarato nell'interfaccia ; il metodo interface non corrispondente rimarrebbe non implementato. Il documento Java citato da @Zhao

  

Il metodo ignora o implementa un metodo dichiarato in un supertipo

si riferisce chiaramente a una super classe abstract ; un interfaccia non può essere chiamato il supertipo. Pertanto, @Override è ridondante e non è sensato per le implementazioni del metodo interface in classi concrete.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top