Quando si utilizza Java @Override di annotazione e perché?

Question

Quali sono le migliori pratiche per l'utilizzo di Java @Override annotazione e perché?

Sembra che sarebbe eccessivo per segno ogni singolo metodo sostituito con il @Override annotazione.Ci sono determinate situazioni di programmazione che si chiama per l'utilizzo del @Override e altri che non dovrebbero mai utilizzare i @Override?

Answer 1

Utilizzare ogni volta che si esegue l'override di un metodo per due benefici.Fare in modo che si può prendere vantaggio di il compilatore controllo per assicurarsi che in realtà sono l'override di un metodo quando si pensa di essere.In questo modo, se si commette un errore più comune di errore di ortografia di un nome di metodo o la non corretta corrispondenza dei parametri, l'utente viene avvertito che è metodo in realtà non ignorare come tu pensi.In secondo luogo, rende il codice più facile da capire, perché è più evidente quando i metodi vengono sovrascritti.

Inoltre, in Java 1.6 è possibile utilizzare per segnalare quando un metodo implementa un'interfaccia per gli stessi benefici.Penso che sarebbe meglio avere una sezione separata annotazione (come @Implements), ma è meglio di niente.

Answer 2

Penso che sia più utile come un tempo di compilazione di promemoria che lo scopo del metodo è quello di eseguire l'override di un metodo di padre.Come esempio:

protected boolean displaySensitiveInformation() {
  return false;
}

Ti capiterà spesso di vedere qualcosa di simile al metodo di cui sopra che esegue l'override di un metodo della classe base.Questo è un importante dettaglio di implementazione di questa classe, non vogliamo che le informazioni sensibili che possono essere visualizzati.

Supponiamo che questo metodo è cambiato nella classe padre per

protected boolean displaySensitiveInformation(Context context) {
  return true;
}

Questo cambiamento non comporterà eventuali errori di compilazione o avvisi - ma cambia completamente il comportamento previsto di sottoclasse.

Per rispondere alla tua domanda:si dovrebbe usare la @Override annotazione se la mancanza di un metodo con la stessa firma in una superclasse è indicativo di un bug.

Answer 3

Ci sono molte buone risposte qui, così mi permetta di offrire un altro modo di guardare...

Non c'è eccessivo quando si esegue la codifica.Non costa nulla, tipo @override, ma il risparmio può essere immenso se hai scritto male il nome di un metodo o ottenuto la firma un po ' male.

Pensate in questo modo:Nel tempo si è passati qui e digitato questo post, è praticamente utilizzato più tempo di quanto si spenderà, digitando @override per il resto della tua vita;ma un errore che impedisce può risparmiare ore di tempo.

Java fa tutto il possibile per assicurarsi che non apportare errori a modificare/tempo di compilazione, questo è praticamente un modo gratuito per risolvere un'intera classe di errori che non sono evitabili in qualsiasi altro modo al di fuori di test approfonditi.

Hai potuto trovare un migliore meccanismo di Java per garantire che, quando l'utente intende eseguire l'override di un metodo, in realtà ha fatto?

Un altro bell'effetto è che se non si forniscono le annotazioni, avviserà al momento della compilazione accidentalmente sovrascritto un metodo di padre, qualcosa che potrebbe essere significativo, se non hai intenzione di farlo.

Answer 4

Io uso sempre il tag.Si tratta di una semplice compilazione di bandiera per la cattura di piccoli errori che potrei fare.

Cattura le cose come tostring() invece di toString()

Le piccole cose di aiuto in progetti di grandi dimensioni.

Answer 5

Utilizzando il @Override annotazione agisce come un tempo di compilazione di salvaguardia contro un comune errore di programmazione.Si genererà un errore di compilazione se avete un'annotazione su un metodo che si sta in realtà non l'override metodo della superclasse.

Il caso più comune in cui questo è utile quando si modifica un metodo della classe base per avere un elenco di parametri diverso.Un metodo in una sottoclasse che utilizzate per sostituire metodo della superclasse non potranno più farlo a causa della modifica del sistema di firma.A volte questo può causare strano e inaspettato comportamento, soprattutto quando si tratta di eredità complessa di strutture.Il @Override annotazione garanzie contro questo.

Answer 6

Per trarre vantaggio dal compilatore verifica si dovrebbe sempre usare l'Override di annotazione.Ma non dimenticate che il Compilatore Java 1.5 a non consentire a questa annotazione, quando l'override di metodi di interfaccia.Si può utilizzare per eseguire l'override di metodi di classe (astratta o non).

Alcuni Ide come Eclipse, anche configurato con il Java runtime 1.6 o superiore, essi mantenere la conformità con Java 1.5 e non consentono l'uso @override come descritto sopra.Per evitare che un comportamento che si deve andare in:Proprietà del progetto ->Java Compiler -> Spunta “Abilita Progetto Specifico Impostazioni” -> Scegliere “Compilatore Livello di Conformità” = 6.0 o superiore.

Mi piace usare questa annotazione ogni volta che mi esegue l'override di un metodo in modo indipendente, se la base è un'interfaccia o classe.

Questo consente di evitare alcuni errori tipici, come quando si pensa che si stanno sostituendo un gestore di evento e poi vedi che non succede niente.Immaginate che si desidera aggiungere un listener di eventi per alcuni componenti UI:

someUIComponent.addMouseListener(new MouseAdapter(){
  public void mouseEntered() {
     ...do something...
  }
});

Il codice di cui sopra, si compila e si esegue, ma se si sposta il mouse all'interno someUIComponent il “fare qualcosa” codice nota eseguire, perché in realtà non l'override del metodo di base mouseEntered(MouseEvent ev).È sufficiente creare un nuovo parametro-metodo meno mouseEntered().Invece di questo codice, se hai usato il @Override annotazione di aver visto un errore di compilazione e non state sprecando il tempo di pensare perché il vostro gestore di evento non era in esecuzione.

Answer 7

@Override su implementazione dell'interfaccia è incoerente, in quanto non vi è alcuna cosa come "sostituzione di un'interfaccia" in java.

@Override su implementazione dell'interfaccia è inutile, visto che in pratica si prende senza bug che la compilazione non avrebbe preso comunque.C'è solo una, inverosimile scenario in cui l'override di implementatori effettivamente qualcosa:Se si implementa un'interfaccia, e l'interfaccia RIMUOVE metodi, ti verrà comunicato in fase di compilazione che si deve rimuovere il inutilizzati implementazioni.Si noti che se la nuova versione dell'interfaccia utente è NUOVO o MODIFICATO metodi, ovviamente, di ottenere un errore di compilazione in ogni modo non si tratta di attuare la nuova roba.

@Override su interfaccia implementatori non dovrebbe mai sono stati ammessi in 1.6, e con eclipse purtroppo la scelta di auto-inserire le annotazioni come comportamento predefinito, abbiamo un sacco di ingombra di file di origine.Durante la lettura 1.6 codice, non è possibile vedere dall' @Override annotazione se un metodo in realtà esegue l'override di un metodo nella superclasse o semplicemente implementa un'interfaccia.

Utilizzando @Override quando in realtà l'override di un metodo in una superclasse è bene.

Answer 8

È consigliabile l'utilizzo per ogni metodo inteso come una sostituzione, e Java 6+, ogni metodo inteso come un'implementazione di un'interfaccia.

Prima cattura errori di ortografia come "hashcode()"invece di "hashCode()"a tempo di compilazione.Può essere sconcertante per eseguire il debug perché il risultato del metodo non sembra per abbinare il vostro codice, quando la vera causa è che il codice non viene mai richiamato.

Inoltre, se una superclasse modifiche firma di un metodo, di ignorare la vecchia firma può essere "orfani", ha lasciato dietro di sé, come confusione codice morto.Il @Override annotazione consente di identificare questi bambini in modo che essi può essere modificato per soddisfare la nuova firma.

Answer 9

Se vi trovate a override (non astratta) dei metodi molto spesso, probabilmente si desidera dare un'occhiata al tuo design.È molto utile quando il compilatore non altrimenti recuperare l'errore.Per esempio, cercando di ignorare initValue() in ThreadLocal, cosa che ho fatto.

Utilizzando @Override quando l'attuazione di metodi di interfaccia (1.6+) e sembra un po ' eccessivo per me.Se si sono un sacco di metodi, alcuni dei quali ignora e alcuni non, che probabilmente la cattiva progettazione di nuovo (e il vostro editor probabilmente mostrerà che è che se non si conosce).

Answer 10

@Override sulle interfacce in realtà sono utili, perché si otterrà avvertenze se si modifica l'interfaccia.

Answer 11

Un'altra cosa che fa è che si rende più evidente quando la lettura di un codice che cambia il comportamento della classe padre.Che possono aiutare in fase di debug.

Inoltre, in Giosuè Blocco libro Efficace Java (2 ° edizione), articolo 36 fornisce maggiori dettagli sui benefici dell'annotazione.

Answer 12

Si rende assolutamente alcun senso utilizzare @Override quando l'attuazione di un metodo di interfaccia.Non c'è nessun vantaggio a usarlo in questo caso, il compilatore sarà già prendere il tuo errore, quindi è solo di cose inutili.

Answer 13

Ogni volta che un metodo sostituisce un altro metodo, o di un metodo che implementa una firma in un'interfaccia.

Il @Override annotazione assicura che si ha, infatti, ignorare qualcosa.Senza l'annotazione è il rischio di un errore di ortografia o la differenza tra i tipi di parametro e numero.

Answer 14

Io lo uso ogni volta.Più informazioni che posso usare per capire cosa sta succedendo quando ho rivisitare il codice in un anno e ho dimenticato quello che stavo pensando la prima volta.

Answer 15

I migliori practive è quello di utilizzare sempre (o dispone l'IDE di riempimento per voi)

@Override utilità è quello di rilevare i cambiamenti nelle classi padre che non è stato segnalato giù per la gerarchia.Senza di essa, si può cambiare la firma di un metodo e dimenticare di modificare le sue sostituzioni, con @Override, il compilatore lo cattura per voi.

Che tipo di rete di sicurezza è sempre bene avere.

Answer 16

Io lo uso ovunque.Sul tema dell'impegno per i metodi di marcatura, ho lasciato Eclipse per me è così, non senza sforzi aggiuntivi.

Sto religiosi di una continua rielaborazione....quindi, io lo uso ogni piccola cosa per farlo andare più agevolmente.

Answer 17

• Utilizzato solo su dichiarazioni di metodo.
• Indica che il metodo annotato dichiarazione sostituisce una dichiarazione in supertipo.

Se utilizzato in modo coerente, si protegge da una vasta classe di nefasto bug.

Utilizzare @Override di annotazione per evitare questi errori:(Posto il bug nel codice riportato di seguito:)

public class Bigram {
    private final char first;
    private final char second;
    public Bigram(char first, char second) {
        this.first  = first;
        this.second = second;
    }
    public boolean equals(Bigram b) {
        return b.first == first && b.second == second;
    }
    public int hashCode() {
        return 31 * first + second;
    }

    public static void main(String[] args) {
        Set<Bigram> s = new HashSet<Bigram>();
        for (int i = 0; i < 10; i++)
            for (char ch = 'a'; ch <= 'z'; ch++)
                s.add(new Bigram(ch, ch));
        System.out.println(s.size());
    }
}

fonte: Efficace Java

Answer 18

Prestare attenzione quando si utilizza Ignorare, perché non si può fare reverse engineering in starUML dopo;fare uml prima.

Answer 19

Sembra che la saggezza qui sta cambiando.Ho installato oggi IntelliJ IDEA 9 e ho notato che la sua "mancanti @Override di ispezione"ora la cattura non appena implementato i metodi astratti, ma interfaccia implementata metodi di ricerca.Nel mio datore di lavoro codice di base e nei miei progetti, ho sempre avuto l'abitudine di usare solo @Override per l'ex -- implementato i metodi astratti.Tuttavia, ripensare l'abitudine, il merito di annotazioni in entrambi i casi diventa chiaro.Pur essendo più dettagliato, proteggere contro il fragile base class problema (non grave come il C++relativi esempi) in cui il metodo di interfaccia cambiamenti di nome, isolare l'implementazione di un metodo in una classe derivata.

Naturalmente, questo scenario è in gran parte l'iperbole;la classe derivata non sarà più possibile compilare, ora manca un'implementazione della rinominato metodo di interfaccia, e oggi sarebbe probabilmente utilizzare un Rinominare Il Metodo operazione di refactoring per affrontare l'intera base di codice in massa.

Dato che l'IDEA di ispezione non è configurabile per ignorare implementato i metodi di interfaccia, oggi ho intenzione di cambiare anche il mio abito e la mia squadra del codice dei criteri di esame.

Answer 20

L'annotazione @Override è usato per aiutare a verificare se il committente che per eseguire l'override del metodo corretto in classe genitore o di interfaccia.Quando il nome di super metodi di modifica, il compilatore è in grado di informare che il caso, che è solo per mantenere la coerenza con la super e la sottoclasse.

BTW, se non annunciare l'annotazione @Override nella sottoclasse, ma che ci fai l'override di alcuni metodi di super, quindi la funzione è in grado di lavorare come che uno con le @Override.Ma questo metodo non può informare lo sviluppatore quando il super metodo è stato cambiato.Perché non conosceva la developer scopo -- override super metodo o definire un nuovo metodo?

Così, quando si desidera eseguire l'override di questo metodo per rendere l'uso del Polimorfismo, abbiamo di meglio da aggiungere @Override di sopra del metodo.

Answer 21

Io lo uso per quanto possibile per identificare quando un metodo viene sovrascritto.Se si guarda alla Scala linguaggio di programmazione, hanno anche la parola chiave override.Io la trovo utile.

Answer 22

Essa permette (beh, il compilatore) per prendere quando hai usato l'sbagliato l'ortografia di un nome di metodo si esegue l'override.

Answer 23

Eseguire l'Override di annotazione viene utilizzato per sfruttare il compilatore, per verificare se effettivamente sono override di un metodo della classe padre.Esso viene utilizzato per notificare se si commette qualche errore, come errore di errore di ortografia di un nome di metodo, errore di non corretta corrispondenza dei parametri

Answer 24

io credo sia meglio il codice @override ogni volta che permesso.aiuta per la codifica.tuttavia, per essere notato, per ecipse Helios, sia sdk 5 o 6, l' @override di annotazione per implementati i metodi dell'interfaccia è consentito.come per Galileo, 5 o 6, @override annotazione non è consentito.

Answer 25

Annotazioni fornire metadati relativi a il codice per il Compilatore e l'annotazione @Override è utilizzato in caso di successione quando si esegue l'override di qualsiasi metodo della classe base.Ci dice solo che il compilatore che si esegue l'override del metodo.Si riescono a evitare alcuni tipi di errori comuni che possiamo fare come non seguire il corretto firma del metodo o hai scritto erroneamente nel nome del metodo, etc.Quindi è una buona pratica di utilizzare @Override di annotazione.

Answer 26

Per me l' @Override assicura di me, io sono la firma del metodo corretto.Se ho messo l'annotazione e il metodo non è corretto, quindi il compilatore si lamenta avermi fatto sapere che qualcosa è sbagliato.

Answer 27

Semplice, quando si desidera eseguire l'override di un metodo presente nella superclasse, utilizzare @Override annotazione per una corretta sostituzione.Il compilatore ti avvisano se non l'override di esso correttamente.