Ada alasan untuk lebih suka getClass () daripada instanceof saat membuat .equals ()?

Saya menggunakan Eclipse untuk menghasilkan .equals()dan .hashCode(), dan ada opsi berlabel "Gunakan 'instanceof' untuk membandingkan jenis". Defaultnya adalah opsi ini tidak dicentang dan digunakan .getClass()untuk membandingkan jenis. Apakah ada alasan aku harus lebih .getClass()lebih instanceof?

Tanpa menggunakan instanceof:

if (obj == null)
  return false;
if (getClass() != obj.getClass())
  return false;

Menggunakan instanceof:

if (obj == null)
  return false;
if (!(obj instanceof MyClass))
  return false;

Saya biasanya memeriksa instanceofopsi, lalu masuk dan menghapus if (obj == null)centang " ". (Itu mubazir karena objek nol akan selalu gagal instanceof.) Apakah ada alasan itu ide yang buruk?

Jika Anda menggunakan instanceof, membuat Anda equalspelaksanaannya finalakan melestarikan kontrak simetri metode: x.equals(y) == y.equals(x). Jika finaltampaknya membatasi, hati-hati memeriksa gagasan Anda tentang kesetaraan objek untuk memastikan bahwa implementasi utama Anda sepenuhnya mempertahankan kontrak yang ditetapkan oleh Objectkelas.

Josh Bloch mendukung pendekatan Anda:

Alasan yang saya sukai instanceofpendekatan adalah bahwa ketika Anda menggunakan getClasspendekatan, Anda memiliki batasan bahwa objek hanya sama dengan objek lain dari kelas yang sama, tipe run time yang sama. Jika Anda memperluas kelas dan menambahkan beberapa metode tidak berbahaya ke dalamnya, maka periksa untuk melihat apakah beberapa objek subclass sama dengan objek kelas super, bahkan jika objek sama di semua aspek penting, Anda akan mendapatkan jawaban mengejutkan bahwa mereka tidak sama. Bahkan, ini melanggar interpretasi ketat dari prinsip substitusi Liskov , dan dapat menyebabkan perilaku yang sangat mengejutkan. Di Jawa, ini sangat penting karena sebagian besar koleksi (HashTable, dll.) didasarkan pada metode sama dengan. Jika Anda menempatkan anggota kelas super di tabel hash sebagai kunci dan kemudian mencarinya menggunakan contoh subclass, Anda tidak akan menemukannya, karena mereka tidak sama.

Lihat juga jawaban SO ini .

Java bab 3 yang efektif juga membahas hal ini.

Angelika Langers Rahasia yang sederajat membahas hal itu dengan diskusi panjang dan terperinci untuk beberapa contoh umum dan terkenal, termasuk oleh Josh Bloch dan Barbara Liskov, menemukan beberapa masalah di sebagian besar dari mereka. Dia juga masuk ke dalam instanceofvs getClass. Beberapa kutipan darinya

Kesimpulan

Setelah membedah empat contoh yang dipilih secara sewenang-wenang dari implementasi equals (), apa yang kita simpulkan?

Pertama-tama: ada dua cara yang berbeda secara substansial untuk melakukan pemeriksaan kecocokan jenis dalam implementasi equals (). Kelas dapat memungkinkan perbandingan tipe campuran antara objek super dan subkelas dengan menggunakan instance dari operator, atau kelas dapat memperlakukan objek dengan tipe yang berbeda sebagai tidak sama dengan menggunakan uji getClass (). Contoh di atas menggambarkan dengan baik bahwa implementasi equals () menggunakan getClass () umumnya lebih kuat daripada implementasi yang menggunakan instanceof.

Instanceof test hanya benar untuk kelas akhir atau jika setidaknya metode sama dengan () adalah final dalam superclass. Yang terakhir pada dasarnya menyiratkan bahwa tidak ada subclass yang harus memperpanjang status superclass, tetapi hanya dapat menambahkan fungsionalitas atau bidang yang tidak relevan untuk keadaan dan perilaku objek, seperti bidang transien atau statis.

Implementasi yang menggunakan uji getClass () di sisi lain selalu mematuhi kontrak equals (); mereka benar dan kuat. Mereka, bagaimanapun, secara semantik sangat berbeda dari implementasi yang menggunakan tes instanceof. Implementasi menggunakan getClass () tidak memungkinkan perbandingan objek sub-dengan superclass, bahkan ketika subkelas tidak menambahkan bidang apa pun dan bahkan tidak ingin menimpa sama dengan (). Ekstensi kelas "sepele" seperti itu misalnya akan menjadi tambahan metode debug-cetak dalam subkelas yang ditentukan untuk tujuan "sepele" ini. Jika superclass melarang perbandingan tipe campuran melalui cek getClass (), maka ekstensi sepele tidak akan sebanding dengan superclassnya. Apakah masalah ini sepenuhnya atau tidak tergantung pada semantik kelas dan tujuan ekstensi.

Alasan penggunaannya getClassadalah untuk memastikan properti simetris dari equalskontrak. Dari equals 'JavaDocs:

Ini simetris: untuk nilai referensi non-null x dan y, x.equals (y) harus mengembalikan true jika dan hanya jika y.equals (x) mengembalikan true.

Dengan menggunakan instanceof, mungkin tidak simetris. Perhatikan contohnya: Anjing memanjang Hewan. Animal equalsmelakukan instanceofpengecekan Animal. Anjing equalstidak sebuah instanceofcek dari anjing. Berikan Animal sebuah and Dog d (dengan bidang lain yang sama):

a.equals(d) --> true
d.equals(a) --> false

Ini melanggar properti simetris.

Untuk benar-benar mengikuti kontrak equal, simetri harus dipastikan, dan karenanya kelas harus sama.

Ini adalah semacam perdebatan agama. Kedua pendekatan memiliki masalah mereka.

• Gunakan instanceof dan Anda tidak pernah dapat menambahkan anggota signifikan ke subclass.
• Gunakan getClass dan Anda melanggar prinsip substitusi Liskov.

Bloch memiliki saran lain yang relevan dalam Effective Java Second Edition :

• Butir 17: Desain dan dokumen untuk warisan atau melarangnya

Perbaiki saya jika saya salah, tetapi getClass () akan berguna ketika Anda ingin memastikan instance Anda BUKAN subkelas dari kelas yang Anda bandingkan. Jika Anda menggunakan instanceof dalam situasi itu Anda TIDAK bisa tahu itu karena:

class A { }

class B extends A { }

Object oA = new A();
Object oB = new B();

oA instanceof A => true
oA instanceof B => false
oB instanceof A => true // <================ HERE
oB instanceof B => true

oA.getClass().equals(A.class) => true
oA.getClass().equals(B.class) => false
oB.getClass().equals(A.class) => false // <===============HERE
oB.getClass().equals(B.class) => true

Jika Anda ingin memastikan hanya kelas yang cocok maka gunakan getClass() ==. Jika Anda ingin mencocokkan subclass maka instanceofdiperlukan.

Juga, instanceof tidak akan cocok dengan nol tetapi aman untuk dibandingkan dengan nol. Jadi Anda tidak perlu membatalkannya.

if ( ! (obj instanceof MyClass) ) { return false; }

Itu tergantung jika Anda mempertimbangkan apakah subkelas dari kelas yang diberikan sama dengan induknya.

class LastName
{
(...)
}


class FamilyName
extends LastName
{
(..)
}

di sini saya akan menggunakan 'instanceof', karena saya ingin LastName dibandingkan dengan FamilyName

class Organism
{
}

class Gorilla extends Organism
{
}

di sini saya akan menggunakan 'getClass', karena kelas sudah mengatakan bahwa dua instance tidak setara.

instanceof berfungsi untuk instance dari kelas yang sama atau subkelasnya

Anda dapat menggunakannya untuk menguji apakah suatu objek adalah turunan dari kelas, turunan dari subkelas, atau turunan dari kelas yang mengimplementasikan antarmuka tertentu.

ArryaList dan RoleList keduanya adalah instance dari List

Sementara

getClass () == o.getClass () akan benar hanya jika kedua objek (ini dan o) milik kelas yang persis sama.

Jadi tergantung pada apa yang Anda perlu membandingkan Anda bisa menggunakan satu atau yang lain.

Jika logika Anda adalah: "Satu objek sama dengan yang lain hanya jika mereka berdua kelas yang sama" Anda harus pergi untuk "sama", yang saya pikir sebagian besar kasus.

Kedua metode memiliki masalah mereka.

Jika subkelas mengubah identitas, maka Anda perlu membandingkan kelas mereka yang sebenarnya. Jika tidak, Anda melanggar properti simetris. Misalnya, berbagai jenis Persons tidak boleh dianggap setara, bahkan jika mereka memiliki nama yang sama.

Namun, beberapa subclass tidak mengubah identitas dan ini perlu digunakan instanceof. Sebagai contoh, jika kita memiliki banyak Shapeobjek yang tidak dapat diubah , maka a Rectangledengan panjang dan lebar 1 harus sama dengan unit Square.

Dalam praktiknya, saya pikir kasus sebelumnya lebih mungkin benar. Biasanya, subclassing adalah bagian mendasar dari identitas Anda dan menjadi persis seperti orang tua Anda, kecuali Anda dapat melakukan satu hal kecil tidak membuat Anda sama.

Sebenarnya instanceof memeriksa di mana objek milik beberapa hierarki atau tidak. mis: Objek mobil milik kelas Vehical. Jadi "Mobil baru () instance dari Vehical" mengembalikan true. Dan "Mobil baru (). GetClass (). Sama dengan (Vehical.class)" mengembalikan false, meskipun objek Mobil milik kelas Vehical tetapi dikategorikan sebagai tipe yang terpisah.