Haruskah kita meng-override implementasi metode antarmuka?

Haruskah metode yang mengimplementasikan metode antarmuka dijelaskan dengan @Override?

The javadoc dari Overridepenjelasan mengatakan:

Menunjukkan bahwa deklarasi metode dimaksudkan untuk mengganti deklarasi metode dalam superclass. Jika suatu metode dianotasi dengan tipe anotasi ini tetapi tidak mengesampingkan metode superclass, kompiler diperlukan untuk menghasilkan pesan kesalahan.

Saya tidak berpikir bahwa antarmuka secara teknis adalah superclass. Atau itu?

Question Elaboration

Anda harus menggunakan @Override kapan pun memungkinkan. Itu mencegah kesalahan sederhana yang dibuat. Contoh:

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

Ini tidak dikompilasi karena tidak menimpa dengan benar public boolean equals(Object obj).

Hal yang sama akan berlaku untuk metode yang mengimplementasikan antarmuka (hanya 1,6 ke atas ) atau mengganti metode kelas Super.

Saya percaya bahwa perilaku javac telah berubah - dengan 1,5 itu melarang anotasi, dengan 1,6 tidak. Anotasi tersebut memberikan pemeriksaan waktu kompilasi ekstra, jadi jika Anda menggunakan 1,6, saya akan melakukannya.

Anda harus selalu membubuhi keterangan metode @Overridejika tersedia.

Dalam JDK 5 ini berarti metode overriding dari superclasses, dalam JDK 6, dan 7 itu berarti metode overriding dari superclasses, dan menerapkan metode antarmuka. Alasannya, seperti yang disebutkan sebelumnya, adalah memungkinkan kompiler untuk menangkap kesalahan di mana Anda pikir Anda mengganti (atau mengimplementasikan) metode, tetapi sebenarnya mendefinisikan metode baru (tanda tangan berbeda).

Contoh equals(Object)vs. equals(YourObject)adalah contoh standar, tetapi argumen yang sama dapat dibuat untuk implementasi antarmuka.

Saya membayangkan alasan mengapa tidak wajib menjelaskan metode implementasi antarmuka adalah bahwa JDK 5 menandai ini sebagai kesalahan kompilasi. Jika JDK 6 membuat anotasi ini wajib, itu akan merusak kompatibilitas.

Saya bukan pengguna Eclipse, tetapi di IDE lain (IntelliJ), @Overrideanotasi hanya ditambahkan ketika menerapkan metode antarmuka jika proyek ditetapkan sebagai proyek JDK 6+. Saya akan membayangkan bahwa Eclipse serupa.

Namun, saya lebih suka melihat anotasi yang berbeda untuk penggunaan ini, mungkin @Implementsanotasi.

Saya akan menggunakannya di setiap kesempatan. Lihat Kapan Anda menggunakan anotasi @Override Java dan mengapa?

JDK 5.0 tidak memungkinkan Anda untuk menggunakan @Overrideanotasi jika Anda menerapkan metode yang dinyatakan dalam antarmuka (kesalahan kompilasi), tetapi JDK 6.0 memungkinkannya. Jadi mungkin Anda dapat mengkonfigurasi preferensi proyek Anda sesuai dengan kebutuhan Anda.

Jika kelas konkret tidak menimpa metode abstrak, menggunakan @Overrideuntuk implementasi adalah hal yang terbuka karena kompiler akan selalu memperingatkan Anda tentang metode yang tidak diimplementasikan. Dalam kasus ini, dapat dibuat argumen yang mengurangi keterbacaan - lebih banyak hal dibaca pada kode Anda dan, pada tingkat yang lebih rendah, disebut @Overridedan tidak @Implement.

Mengganti metode Anda sendiri yang diwarisi dari kelas Anda sendiri biasanya tidak akan berhenti pada refactorings menggunakan ide. Tetapi jika Anda mengganti metode yang diwarisi dari perpustakaan, disarankan untuk menggunakannya. Jika tidak, Anda sering tidak mendapatkan kesalahan pada perubahan pustaka nanti, tetapi bug yang tersembunyi dengan baik.

Ini bukan masalah dengan JDK. Dalam Eclipse Helios, ini memungkinkan anotasi @Override untuk metode antarmuka yang diterapkan, mana pun JDK 5 atau 6. Sedangkan untuk Eclipse Galileo, anotasi @Override tidak diperbolehkan, mana pun JDK 5 atau 6.

Bagi saya, sering kali ini adalah satu-satunya alasan beberapa kode memerlukan Java 6 untuk dikompilasi. Tidak yakin apakah itu layak.

Dengan membaca javadoc di java8, Anda dapat menemukan yang berikut di deklarasi antarmuka Override:

Jika suatu metode dijelaskan dengan kompiler jenis penjelasan ini diperlukan untuk menghasilkan pesan kesalahan kecuali setidaknya salah satu dari kondisi berikut ini berlaku:

• Metode tidak mengesampingkan atau menerapkan metode yang dinyatakan dalam supertype.
• Metode ini memiliki tanda tangan yang menimpa-setara dengan metode publik apa pun yang dinyatakan dalam {@linkplain Object}.

Jadi, setidaknya di java8, Anda harus menggunakan @Override pada implementasi metode antarmuka.

Eclipse sendiri akan menambahkan @Overrideanotasi ketika Anda mengatakannya untuk "menghasilkan metode yang tidak diimplementasikan" selama pembuatan kelas yang mengimplementasikan antarmuka.

Masalah dengan menyertakan @Overrideadalah bahwa hal itu membuat Anda berpikir bahwa Anda lupa memanggil super.theOverridenMethod()metode, yang sangat membingungkan . Ini harus sebening kristal. Mungkin Java harus menawarkan @Interfaceuntuk digunakan di sini. Oh well, kekhasan Jawa setengah-setengah ...

Di java 6 dan versi yang lebih baru, Anda bisa menggunakan @Overridemetode yang mengimplementasikan antarmuka.

Tapi, saya tidak berpikir itu masuk akal: menimpa berarti Anda memiliki metode di kelas super, dan Anda menerapkannya di sub kelas.

Jika Anda mengimplementasikan antarmuka, saya pikir kita harus menggunakan @Implementatau sesuatu yang lain, tetapi tidak @Override.

Untuk antarmuka, menggunakan @Override menyebabkan kesalahan kompilasi. Jadi, saya harus menghapusnya.

Pesan kesalahan masuk " The method getAllProducts() of type InMemoryProductRepository must override a superclass method".

Itu juga membaca " One quick fix available: Remove @Override annotation."

Itu di Eclipse 4.6.3, JDK 1.8.0_144.

Jika kelas yang mengimplementasikannya interfaceadalah abstractkelas, @Overrideberguna untuk memastikan bahwa implementasi adalah untuk suatu interfacemetode; tanpa @Overridesuatu abstractkelas hanya akan mengkompilasi denda bahkan jika tanda tangan metode implementasi tidak cocok dengan metode yang dinyatakan dalam interface; interfacemetode yang tidak cocok akan tetap tidak diterapkan. Dokumen Java dikutip oleh @Zhao

Metode tidak mengesampingkan atau menerapkan metode yang dinyatakan dalam supertype

jelas mengacu pada abstractkelas super; sebuah interfacetidak bisa disebut supertype. Jadi, @Overrideitu berlebihan dan tidak masuk akal untuk interfaceimplementasi metode di kelas konkret.