เหตุผลใดที่จะชอบ getClass () มากกว่า instanceof เมื่อสร้าง. equals ()?

ฉันกำลังใช้ Eclipse เพื่อสร้าง.equals()และ.hashCode()มีตัวเลือกที่มีข้อความว่า "ใช้ 'อินสแตนซ์ของ' เพื่อเปรียบเทียบประเภท" ค่าเริ่มต้นสำหรับตัวเลือกนี้จะไม่ถูกตรวจสอบและใช้.getClass()เพื่อเปรียบเทียบประเภท มีเหตุผลใด ๆ ที่ฉันจะชอบ.getClass()มากกว่าinstanceof?

โดยไม่ต้องใช้instanceof:

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

การใช้instanceof:

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

ฉันมักจะตรวจสอบinstanceofตัวเลือกจากนั้นเข้าไปข้างในและลบเครื่องหมาย " if (obj == null)" (มันซ้ำซ้อนเนื่องจากวัตถุ null จะล้มเหลวเสมอinstanceof) มีเหตุผลใดบ้างที่เป็นความคิดที่ไม่ดี?

ถ้าคุณใช้instanceofทำให้การequalsดำเนินการจะรักษาสัญญาสมมาตรของวิธีการ:final x.equals(y) == y.equals(x)หากfinalดูเหมือนว่ามีข้อ จำกัด ให้ตรวจสอบความคิดเกี่ยวกับการเทียบเท่าวัตถุของคุณอย่างรอบคอบเพื่อให้แน่ใจว่าการใช้งานที่ถูกต้องของคุณจะรักษาสัญญาที่กำหนดโดยObjectชั้นเรียนอย่างเต็มที่

Josh Blochสนับสนุนแนวทางของคุณ:

เหตุผลที่ฉันชอบinstanceofวิธีนี้คือเมื่อคุณใช้getClassวิธีนี้คุณมีข้อ จำกัด ว่าวัตถุจะเท่ากับวัตถุอื่น ๆ ในคลาสเดียวกันเท่านั้นประเภทเวลาทำงานเดียวกัน หากคุณขยายคลาสและเพิ่มวิธีการที่ไม่มีอันตรายสองสามอย่างให้ตรวจสอบเพื่อดูว่าวัตถุบางอย่างของคลาสย่อยนั้นเท่ากับวัตถุของคลาสซูเปอร์แม้ว่าวัตถุนั้นจะมีความสำคัญเท่าเทียมกันในทุกด้านคุณจะได้รับ คำตอบที่น่าประหลาดใจที่พวกเขาไม่เท่ากัน ในความเป็นจริงสิ่งนี้เป็นการละเมิดการตีความที่เข้มงวดของหลักการทดแทน Liskovและสามารถนำไปสู่พฤติกรรมที่น่าประหลาดใจมาก ใน Java มันมีความสำคัญอย่างยิ่งเพราะคอลเล็กชันส่วนใหญ่ (HashTableเป็นต้น) ขึ้นอยู่กับวิธีที่เท่าเทียมกัน หากคุณใส่สมาชิกของคลาส super ในตารางแฮชเป็นคีย์แล้วค้นหาโดยใช้อินสแตนซ์คลาสย่อยคุณจะไม่พบมันเพราะพวกมันไม่เท่ากัน

ดูคำตอบ SO นี้ด้วย

Java บทที่ 3 ที่มีประสิทธิภาพยังครอบคลุมถึงสิ่งนี้

Angelika Langers ความลับของการเท่าเทียมกันนั้นมีการพูดคุยกันอย่างยาวนานและมีรายละเอียดสำหรับตัวอย่างทั่วไปและเป็นที่รู้จักเช่น Josh Bloch และ Barbara Liskov ค้นพบปัญหาสองสามอย่างในนั้น นอกจากนี้เธอยังได้รับในVSinstanceof getClassบางคนอ้างจากมัน

สรุปผลการวิจัย

เมื่อตัดตัวอย่างสี่ตัวอย่างที่เลือกโดยพลการของการใช้งานของ equals () เราจะสรุปได้อย่างไร

ประการแรก: มีสองวิธีที่แตกต่างกันอย่างมากในการดำเนินการตรวจสอบการจับคู่ประเภทในการดำเนินการเท่ากับ () คลาสสามารถอนุญาตให้ทำการเปรียบเทียบแบบผสมระหว่างออบเจ็กต์ super และ subclass โดยใช้ตัวดำเนินการ instanceof หรือคลาสสามารถจัดการกับออบเจ็กต์ประเภทต่าง ๆ ที่ไม่เท่ากันโดยใช้วิธีการทดสอบ getClass () ตัวอย่างข้างต้นแสดงให้เห็นอย่างชัดเจนว่าการใช้งานของ equals () โดยใช้ getClass () โดยทั่วไปมีความแข็งแกร่งกว่าการใช้งานเหล่านั้นโดยใช้ instanceof

การทดสอบ instanceof นั้นถูกต้องเฉพาะสำหรับคลาสสุดท้ายหรืออย่างน้อยเมธอดเท่ากับ () ถือเป็นที่สิ้นสุดในซูเปอร์คลาส ส่วนหลังหมายถึงว่าไม่มีคลาสย่อยต้องขยายสถานะของซูเปอร์คลาส แต่สามารถเพิ่มฟังก์ชันการทำงานหรือฟิลด์ที่ไม่เกี่ยวข้องกับสถานะและพฤติกรรมของวัตถุเช่นฟิลด์ชั่วคราวหรือสแตติก

การใช้งานโดยใช้การทดสอบ getClass () ในทางกลับกันปฏิบัติตามสัญญาเท่ากับ () เสมอ พวกเขาถูกต้องและแข็งแกร่ง อย่างไรก็ตามมันแตกต่างอย่างมากจากการนำไปใช้ที่ใช้การทดสอบอินสแตนซ์ การใช้งานโดยใช้ getClass () ไม่อนุญาตให้ทำการเปรียบเทียบ sub- กับออบเจ็กต์ superclass แม้กระทั่งเมื่อ subclass ไม่ได้เพิ่มฟิลด์ใด ๆ และไม่ต้องการแทนที่ overals () ตัวอย่างเช่นการขยายคลาส "เล็กน้อย" จะเป็นการเพิ่มวิธีการแก้ไขข้อบกพร่องในคลาสย่อยที่กำหนดไว้สำหรับจุดประสงค์ "เล็กน้อย" นี้ หากซูเปอร์คลาสห้ามทำการเปรียบเทียบแบบผสมผ่านการตรวจสอบ getClass () แสดงว่าส่วนขยายเล็กน้อยจะไม่สามารถเทียบเคียงกับซูเปอร์คลาสได้ ปัญหานี้หรือไม่นั้นขึ้นอยู่กับความหมายของคลาสและจุดประสงค์ของการขยาย

เหตุผลที่ใช้getClassคือเพื่อให้แน่ใจว่าคุณสมบัติสมมาตรของequalsสัญญา จาก JavaDocs เท่ากับ

มันสมมาตร: สำหรับค่าอ้างอิงที่ไม่ใช่ค่าว่างใด ๆ x และ y, x.equals (y) ควรกลับค่าจริงถ้าหาก y.equals (x) คืนค่าจริง

โดยใช้อินสแตนซ์ของมันเป็นไปได้ที่จะไม่สมมาตร ลองพิจารณาตัวอย่าง: สุนัขขยายสัตว์ สัตว์equalsใช้instanceofเช็คของสัตว์ สุนัขequalsทำการinstanceofตรวจสอบสุนัข ให้สัตว์และสุนัขd (กับสาขาอื่น ๆ เดียวกัน):

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

สิ่งนี้ละเมิดคุณสมบัติสมมาตร

ในการปฏิบัติตามสัญญาที่เท่าเทียมกันอย่างเคร่งครัดนั้นจะต้องมั่นใจในความสมมาตรดังนั้นชั้นเรียนจึงต้องเหมือนกัน

นี่เป็นสิ่งที่ถกเถียงทางศาสนา ทั้งสองวิธีมีปัญหา

• ใช้instanceofและคุณจะไม่สามารถเพิ่มสมาชิกสำคัญลงในคลาสย่อยได้
• ใช้getClassและคุณละเมิดหลักการทดแทน Liskov

Blochมีคำแนะนำอื่นที่เกี่ยวข้องในEffective Java Second Edition :

• รายการที่ 17: การออกแบบและเอกสารสำหรับการสืบทอดหรือการห้าม

แก้ไขให้ถูกต้องหากฉันผิด แต่ getClass () จะมีประโยชน์เมื่อคุณต้องการตรวจสอบให้แน่ใจว่าอินสแตนซ์ของคุณไม่ใช่คลาสย่อยของคลาสที่คุณกำลังเปรียบเทียบ หากคุณใช้ instanceof ในสถานการณ์นั้นคุณจะไม่สามารถรู้ได้เพราะ:

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

getClass() ==ถ้าคุณต้องการเพื่อให้แน่ใจว่าเพียงว่าชั้นจะตรงกับการใช้งานแล้ว หากคุณต้องการจับคู่คลาสย่อยinstanceofจำเป็นต้องมี

นอกจากนี้อินสแตนซ์ของจะไม่จับคู่กับโมฆะ แต่ปลอดภัยที่จะเปรียบเทียบกับโมฆะ ดังนั้นคุณไม่จำเป็นต้องตรวจสอบ null

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

มันขึ้นอยู่กับว่าคุณพิจารณาว่าคลาสย่อยของคลาสที่กำหนดนั้นเท่ากับพาเรนต์หรือไม่

class LastName
{
(...)
}


class FamilyName
extends LastName
{
(..)
}

ที่นี่ฉันจะใช้ 'instanceof' เพราะฉันต้องการใช้นามสกุลเพื่อเปรียบเทียบกับ FamilyName

class Organism
{
}

class Gorilla extends Organism
{
}

ที่นี่ฉันจะใช้ 'getClass' เพราะชั้นเรียนบอกว่าทั้งสองกรณีนั้นไม่เท่ากัน

instanceof ใช้งานได้กับอินสแตนซ์ของคลาสเดียวกันหรือคลาสย่อย

คุณสามารถใช้มันเพื่อทดสอบว่าวัตถุเป็นอินสแตนซ์ของคลาสอินสแตนซ์ของคลาสย่อยหรืออินสแตนซ์ของคลาสที่ใช้อินเทอร์เฟซเฉพาะ

ArryaList และ RoleList เป็นทั้งสองอินสแตนซ์ของรายการ

ในขณะที่

getClass () == o.getClass ()จะเป็นจริงเฉพาะในกรณีที่วัตถุทั้งสอง (นี้และ o) เป็นของชั้นเดียวกัน

ดังนั้นขึ้นอยู่กับสิ่งที่คุณต้องการเปรียบเทียบคุณสามารถใช้อย่างใดอย่างหนึ่ง

หากตรรกะของคุณคือ: "วัตถุหนึ่งเท่ากับอีกอย่างหนึ่งก็ต่อเมื่อพวกเขาทั้งคู่เหมือนกัน" คุณควรไปที่ "เท่ากับ" ซึ่งฉันคิดว่าเป็นกรณีส่วนใหญ่

ทั้งสองวิธีมีปัญหา

หากคลาสย่อยเปลี่ยนข้อมูลประจำตัวคุณต้องเปรียบเทียบคลาสจริงของคลาสนั้น มิฉะนั้นคุณละเมิดคุณสมบัติสมมาตร ยกตัวอย่างเช่นประเภทต่าง ๆPersonไม่ควรได้รับการพิจารณาเทียบเท่าแม้ว่าพวกเขาจะมีชื่อเดียวกัน

อย่างไรก็ตาม subclasses instanceofบางคนไม่เปลี่ยนอัตลักษณ์และความจำเป็นเหล่านี้ไปใช้ ตัวอย่างเช่นถ้าเรามีพวงของการเปลี่ยนรูปShapeวัตถุนั้นRectangleมีความยาวและความกว้างของ 1 Squareควรจะเท่ากับหน่วย

ในทางปฏิบัติฉันคิดว่ากรณีในอดีตน่าจะเป็นจริงมากกว่า โดยปกติแล้วการแบ่งคลาสย่อยเป็นส่วนพื้นฐานของตัวตนของคุณและการเป็นเหมือนพ่อแม่ของคุณยกเว้นว่าคุณสามารถทำสิ่งเล็ก ๆ น้อย ๆ ไม่ทำให้คุณเท่าเทียมกัน

อินสแตนซ์จริงของการตรวจสอบที่วัตถุอยู่ในลำดับชั้นบางส่วนหรือไม่ ตัวอย่าง: วัตถุรถยนต์เป็นของคลาส Vehical ดังนั้น "รถใหม่ () ตัวอย่างของ Vehical" จึงกลับมาจริง และ "new Car (). getClass (). equals (Vehical.class)" คืนค่าเท็จแม้ว่าวัตถุ Car นั้นเป็นของคลาส Vehical แต่มันถูกจัดหมวดหมู่เป็นประเภทแยกต่างหาก