คุณใช้คำอธิบายประกอบ @Override ของ Java เมื่อใดและเพราะเหตุใด

แนวปฏิบัติที่ดีที่สุดสำหรับการใช้@Overrideคำอธิบายประกอบของ Java คืออะไรและเพราะเหตุใด

ดูเหมือนว่าจะเป็น overkill ในการทำเครื่องหมายทุกวิธีการแทนที่ด้วย@Overrideคำอธิบายประกอบ มีสถานการณ์การเขียนโปรแกรมบางอย่างที่เรียกใช้@Overrideและอื่น ๆ ที่ไม่ควรใช้@Overrideหรือไม่

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

นอกจากนี้ใน Java 1.6 คุณสามารถใช้เพื่อทำเครื่องหมายเมื่อวิธีการใช้อินเทอร์เฟซเพื่อประโยชน์เดียวกัน ฉันคิดว่ามันจะเป็นการดีกว่าถ้าจะมีคำอธิบายประกอบแยกกัน (เช่น@Implements) แต่ก็ดีกว่าไม่มีเลย

ฉันคิดว่ามันมีประโยชน์มากที่สุดในการเตือนเวลารวบรวมว่าความตั้งใจของวิธีนี้คือการแทนที่วิธีการหลัก ตัวอย่างเช่น:

protected boolean displaySensitiveInformation() {
  return false;
}

คุณมักจะเห็นบางสิ่งบางอย่างเช่นวิธีการข้างต้นที่แทนที่วิธีการในชั้นฐาน นี่คือรายละเอียดการใช้งานที่สำคัญของคลาสนี้ - เราไม่ต้องการให้แสดงข้อมูลที่ละเอียดอ่อน

สมมติว่าวิธีนี้มีการเปลี่ยนแปลงในระดับผู้ปกครองเพื่อ

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

การเปลี่ยนแปลงนี้จะไม่ทำให้เกิดข้อผิดพลาดในเวลาคอมไพล์หรือคำเตือน - แต่เป็นการเปลี่ยนแปลงลักษณะการทำงานที่ตั้งใจไว้ของคลาสย่อย

ในการตอบคำถามของคุณ: คุณควรใช้คำอธิบายประกอบ @Override หากไม่มีวิธีการที่มีลายเซ็นเดียวกันในซูเปอร์คลาสนั้นบ่งบอกถึงข้อบกพร่อง

มีคำตอบที่ดีมากมายที่นี่ให้ฉันเสนอวิธีอื่นในการดู ...

ไม่มีการเติมมากเกินไปเมื่อคุณกำลังเข้ารหัส ไม่เสียค่าใช้จ่ายใด ๆ สำหรับการพิมพ์ @override แต่การประหยัดอาจมีค่ามากหากคุณสะกดชื่อวิธีการหรือมีลายเซ็นผิดเล็กน้อย

คิดแบบนี้: ในเวลาที่คุณสำรวจที่นี่และพิมพ์โพสต์นี้คุณใช้เวลามากกว่าที่คุณจะพิมพ์ @override ไปตลอดชีวิต แต่ข้อผิดพลาดอย่างหนึ่งที่ป้องกันสามารถช่วยให้คุณประหยัดเวลาได้

Java ทำทุกอย่างเท่าที่ทำได้เพื่อให้แน่ใจว่าคุณไม่ได้ทำผิดพลาดใด ๆ ในการแก้ไข / รวบรวมเวลานี่เป็นวิธีที่ฟรีในการแก้ไขข้อผิดพลาดทั้งหมดที่ไม่สามารถป้องกันได้ด้วยวิธีอื่นนอกเหนือจากการทดสอบที่ครอบคลุม

คุณช่วยสร้างกลไกที่ดีขึ้นใน Java เพื่อให้แน่ใจว่าเมื่อผู้ใช้ตั้งใจจะแทนที่วิธีการจริงหรือไม่

ผลกระทบที่ประณีตอีกอย่างคือถ้าคุณไม่ได้ใส่คำอธิบายประกอบมันจะเตือนคุณเมื่อถึงเวลารวบรวมว่าคุณลบล้างวิธีการของผู้ปกครองโดยบังเอิญ - สิ่งที่อาจสำคัญหากคุณไม่ได้ตั้งใจทำ

ฉันใช้แท็กเสมอ มันเป็นธงเวลาเรียบง่ายในการรวบรวมข้อผิดพลาดเล็ก ๆ น้อย ๆ ที่ฉันอาจทำ

มันจะจับสิ่งต่าง ๆ เช่นtostring()แทนที่จะtoString()

สิ่งเล็ก ๆ น้อย ๆ ช่วยในโครงการขนาดใหญ่

การใช้@Overrideคำอธิบายประกอบทำหน้าที่ป้องกันเวลาคอมไพล์จากความผิดพลาดในการโปรแกรมทั่วไป มันจะโยนข้อผิดพลาดในการคอมไพล์ถ้าคุณมีคำอธิบายประกอบในวิธีการที่คุณไม่ได้เอาชนะวิธี superclass

กรณีที่พบบ่อยที่สุดซึ่งมีประโยชน์คือเมื่อคุณเปลี่ยนวิธีในคลาสพื้นฐานเพื่อให้มีรายการพารามิเตอร์ที่แตกต่างกัน เมธอดในคลาสย่อยที่ใช้เพื่อแทนที่เมธอดคลาสคลาสจะไม่ทำเช่นนั้นอีกต่อไปเนื่องจากลายเซ็นเมธอดที่เปลี่ยนไป บางครั้งสิ่งนี้สามารถทำให้เกิดพฤติกรรมที่แปลกและไม่คาดคิดโดยเฉพาะเมื่อต้องรับมือกับโครงสร้างการสืบทอดที่ซับซ้อน @Overrideคำอธิบายประกอบป้องกันการนี้

หากต้องการใช้ประโยชน์จากการตรวจสอบคอมไพเลอร์คุณควรใช้คำอธิบายประกอบแบบแทนที่ แต่อย่าลืมว่า Java Compiler 1.5 จะไม่อนุญาตให้ใช้คำอธิบายประกอบนี้เมื่อเอาชนะวิธีการเชื่อมต่อ คุณสามารถใช้มันเพื่อแทนที่วิธีการเรียน (นามธรรมหรือไม่)

IDE บางตัวในขณะที่ Eclipse แม้กำหนดค่าด้วยรันไทม์ Java 1.6 หรือสูงกว่านั้นก็ยังคงสอดคล้องกับ Java 1.5 และไม่อนุญาตให้ใช้ @override ตามที่อธิบายไว้ข้างต้น เพื่อหลีกเลี่ยงพฤติกรรมดังกล่าวคุณต้องไปที่: คุณสมบัติโครงการ -> Java คอมไพเลอร์ -> กาเครื่องหมาย“ เปิดใช้งานการตั้งค่าเฉพาะโครงการ” -> เลือก“ ระดับความสอดคล้องกับคอมไพเลอร์” = 6.0 หรือสูงกว่า

ฉันชอบที่จะใช้คำอธิบายประกอบนี้ทุกครั้งที่ฉันเอาชนะวิธีการอย่างอิสระถ้าฐานเป็นอินเทอร์เฟซหรือคลาส

สิ่งนี้จะช่วยให้คุณหลีกเลี่ยงข้อผิดพลาดทั่วไปเช่นเมื่อคุณคิดว่าคุณกำลังจัดการกับตัวจัดการเหตุการณ์แล้วคุณจะไม่เห็นอะไรเกิดขึ้น ลองนึกภาพคุณต้องการเพิ่มฟังเหตุการณ์ไปยังองค์ประกอบ UI บางส่วน:

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

คอมไพล์รหัสและวิ่งข้างต้น แต่ถ้าคุณเลื่อนเมาส์ภายใน someUIComponent ว่า“ทำอะไร” รหัสจะทราบทำงานเพราะจริง ๆ mouseEntered(MouseEvent ev)แล้วคุณไม่ได้เอาชนะวิธีฐาน mouseEntered()คุณเพียงแค่สร้างวิธีพารามิเตอร์น้อยใหม่ แทนที่จะใช้รหัสนั้นหากคุณใช้@Overrideคำอธิบายประกอบคุณได้เห็นข้อผิดพลาดในการคอมไพล์และคุณไม่ต้องเสียเวลาคิดว่าเหตุใดตัวจัดการเหตุการณ์ของคุณจึงไม่ทำงาน

@Override เกี่ยวกับการใช้อินเตอร์เฟสไม่สอดคล้องกันเนื่องจากไม่มีสิ่งใดใน "การแทนที่อินเตอร์เฟส" ใน java

@Override เกี่ยวกับการใช้อินเตอร์เฟสนั้นไม่มีประโยชน์เนื่องจากในทางปฏิบัติมันจับข้อบกพร่องที่การรวบรวมจะไม่จับ มีเพียงสถานการณ์จำลองที่ไกลออกไปซึ่งการแทนที่ทับซ้อนบน implementers จริง ๆ แล้วทำอะไรบางอย่าง: ถ้าคุณใช้อินเทอร์เฟซและวิธีการอินเทอร์เฟซที่ลบคุณจะได้รับการแจ้งเตือนในเวลารวบรวมที่คุณควรเอาการใช้งาน โปรดสังเกตว่าหากอินเทอร์เฟซเวอร์ชันใหม่มีวิธีใหม่หรือเปลี่ยนคุณจะได้รับข้อผิดพลาดในการรวบรวมอย่างชัดเจนเนื่องจากคุณไม่ได้ใช้สิ่งใหม่

@Override บนเครื่องมือใช้งานอินเทอร์เฟซไม่ควรได้รับอนุญาตใน 1.6 และด้วย eclipse เศร้าที่เลือกแทรกคำอธิบายประกอบอัตโนมัติเป็นพฤติกรรมเริ่มต้นเราได้รับไฟล์ต้นฉบับจำนวนมากที่รก เมื่ออ่านรหัส 1.6 คุณจะไม่สามารถเห็นได้จากคำอธิบายประกอบ @Override หากจริงๆแล้ววิธีการแทนที่วิธีการใน superclass หรือเพียงแค่ใช้อินเตอร์เฟซ

การใช้ @Override เมื่อแทนที่เมธอดใน superclass ได้จริง

เป็นการดีที่สุดที่จะใช้สำหรับทุกวิธีที่ตั้งใจจะเป็น override และ Java 6+ ทุกวิธีที่ตั้งใจจะใช้เป็นอินเตอร์เฟส

ก่อนอื่นจะจับการสะกดคำผิดเช่น " hashcode()" แทนที่จะเป็น " hashCode()" ในเวลารวบรวม อาจทำให้งงงันว่าทำไมผลลัพธ์ของวิธีการของคุณไม่ตรงกับรหัสของคุณเมื่อสาเหตุที่แท้จริงคือว่ารหัสของคุณไม่เคยถูกเรียก

นอกจากนี้หากซูเปอร์คลาสเปลี่ยนลายเซ็นวิธีการแทนที่ของลายเซ็นเก่าสามารถ "orphaned" ทิ้งไว้ข้างหลังเป็นรหัสที่สับสน @Overrideคำอธิบายประกอบจะช่วยให้คุณระบุเด็กกำพร้าเหล่านี้เพื่อให้พวกเขาสามารถได้รับการแก้ไขเพื่อให้ตรงกับลายเซ็นใหม่

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

การใช้ @Override เมื่อใช้วิธีการอินเทอร์เฟซ (คุณลักษณะ 1.6+) ดูเหมือนจะเกินความจำเป็นเล็กน้อยสำหรับฉัน หากคุณมีวิธีการมากมายที่จะแทนที่และบางวิธีก็อาจจะไม่ดีเท่าที่ควร (การแก้ไขของคุณจะแสดงให้เห็นว่าตัวไหนเป็นสิ่งที่ถ้าคุณไม่รู้)

@Override บนอินเตอร์เฟสมีประโยชน์จริง ๆ เพราะคุณจะได้รับคำเตือนหากคุณเปลี่ยนอินเตอร์เฟส

สิ่งอื่นก็คือมันทำให้ชัดเจนมากขึ้นเมื่ออ่านรหัสว่ามีการเปลี่ยนแปลงพฤติกรรมของชั้นผู้ปกครอง กว่าสามารถช่วยในการแก้ไขข้อบกพร่อง

นอกจากนี้ในหนังสือของ Joshua Block Java ที่มีประสิทธิภาพ (ฉบับที่ 2) รายการที่ 36 ให้รายละเอียดเพิ่มเติมเกี่ยวกับประโยชน์ของการเพิ่มความคิดเห็น

มันไม่มีเหตุผลที่จะใช้ @Override เมื่อใช้วิธีการอินเตอร์เฟส ไม่มีประโยชน์ที่จะใช้ในกรณีนี้คอมไพเลอร์จะจับข้อผิดพลาดของคุณได้แล้วดังนั้นมันจึงไม่จำเป็น

เมื่อใดก็ตามที่วิธีการแทนที่วิธีอื่นหรือวิธีการใช้ลายเซ็นในอินเทอร์เฟซ

@Overrideคำอธิบายประกอบคุณมั่นใจว่าคุณทำบางสิ่งบางอย่างในความเป็นจริงแทนที่ หากไม่มีคำอธิบายประกอบคุณจะเสี่ยงต่อการสะกดผิดหรือความแตกต่างในประเภทพารามิเตอร์และหมายเลข

ฉันใช้มันทุกครั้ง มันเป็นข้อมูลเพิ่มเติมที่ฉันสามารถใช้เพื่อค้นหาว่าเกิดอะไรขึ้นเมื่อฉันทบทวนรหัสในหนึ่งปีและฉันลืมสิ่งที่ฉันคิดในครั้งแรก

วิธีปฏิบัติที่ดีที่สุดคือใช้เสมอ (หรือให้ IDE เติมให้คุณ)

@Override ประโยชน์คือการตรวจสอบการเปลี่ยนแปลงในชั้นเรียนผู้ปกครองซึ่งยังไม่ได้รับการรายงานลงในลำดับชั้น หากไม่มีคุณสามารถเปลี่ยนลายเซ็นของเมธอดและลืมที่จะแก้ไขการแทนที่ด้วย @Override คอมไพเลอร์จะตรวจจับให้คุณ

ตาข่ายนิรภัยแบบนั้นดีเสมอ

ฉันใช้มันทุกที่ ในหัวข้อของความพยายามในการทำเครื่องหมายวิธีฉันให้ Eclipse ทำเพื่อฉันดังนั้นจึงไม่มีความพยายามเพิ่มเติม

ฉันนับถือศาสนาเกี่ยวกับการปรับโครงสร้างใหม่อย่างต่อเนื่องดังนั้นฉันจะใช้ทุกอย่างเพื่อให้มันราบรื่นขึ้น

• ใช้เฉพาะในการประกาศวิธีการ
• บ่งชี้ว่าการประกาศเมธอดที่ทำหมายเหตุประกอบไว้จะแทนที่การประกาศใน supertype

หากใช้อย่างต่อเนื่องจะช่วยปกป้องคุณจากข้อผิดพลาดเลวร้ายระดับสูง

ใช้คำอธิบายประกอบ @Override เพื่อหลีกเลี่ยงข้อบกพร่องเหล่านี้: (พบจุดบกพร่องในรหัสต่อไปนี้ :)

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());
    }
}

แหล่งที่มา: Java ที่มีประสิทธิภาพ

ระวังเมื่อคุณใช้ Override เพราะคุณไม่สามารถทำวิศวกรรมย้อนกลับใน starUML หลังจากนั้น ทำ uml ก่อน

ดูเหมือนว่าภูมิปัญญาที่นี่มีการเปลี่ยนแปลง วันนี้ฉันติดตั้งIntelliJ IDEA 9 และสังเกตว่า " การตรวจสอบ @Override ที่หายไป " ในตอนนี้ไม่เพียง แต่ใช้วิธีการแบบนามธรรมเท่านั้น ในฐานรหัสของนายจ้างของฉันและในโครงการของฉันฉันมีนิสัยที่จะใช้ @Override สำหรับวิธีการแบบนามธรรมที่นำมาใช้ในอดีตเท่านั้น อย่างไรก็ตามการทบทวนนิสัยใหม่ข้อดีของการใช้คำอธิบายประกอบในทั้งสองกรณีก็ชัดเจน แม้จะเป็น verbose มากขึ้น แต่ก็จะป้องกันปัญหาคลาสพื้นฐานที่เปราะบาง (ไม่ร้ายแรงเท่ากับ C ++ - ตัวอย่างที่เกี่ยวข้อง) ซึ่งการเปลี่ยนชื่อเมธอดของอินเตอร์เฟส

แน่นอนสถานการณ์นี้ส่วนใหญ่เป็นอติพจน์ คลาสที่ได้รับมาจะไม่คอมไพล์อีกต่อไปตอนนี้ขาดการใช้งานของวิธีการเปลี่ยนชื่ออินเตอร์เฟสและในวันนี้หนึ่งอาจจะใช้การดำเนินการ refactoring วิธีการเปลี่ยนชื่อวิธีการที่จะอยู่ที่ฐานรหัสทั้งหมด en masse

เนื่องจากการตรวจสอบความคิดของ IDEA นั้นไม่สามารถกำหนดค่าให้ละเว้นวิธีการใช้อินเตอร์เฟสได้วันนี้ฉันจะเปลี่ยนทั้งนิสัยและเกณฑ์การตรวจสอบโค้ดของทีม

คำอธิบายประกอบ @Override ใช้สำหรับช่วยตรวจสอบว่านักพัฒนาสิ่งที่จะแทนที่วิธีที่ถูกต้องในคลาสผู้ปกครองหรืออินเตอร์เฟซ เมื่อชื่อของซูเปอร์เปลี่ยนวิธีการคอมไพเลอร์สามารถแจ้งกรณีนั้นซึ่งเป็นเพียงเพื่อให้สอดคล้องกับซูเปอร์และคลาสย่อย

BTW ถ้าเราไม่ได้ประกาศคำอธิบายประกอบ @Override ในคลาสย่อย แต่เราจะแทนที่วิธีการบางอย่างของ super แล้วฟังก์ชั่นสามารถทำงานได้อย่างใดอย่างหนึ่งด้วย @Override แต่วิธีนี้ไม่สามารถแจ้งผู้พัฒนาได้เมื่อมีการเปลี่ยนแปลงวิธีการของซุปเปอร์ เพราะมันไม่ทราบว่าวัตถุประสงค์ของนักพัฒนา - แทนที่วิธีการของซุปเปอร์หรือกำหนดวิธีการใหม่หรือไม่?

ดังนั้นเมื่อเราต้องการแทนที่เมธอดดังกล่าวเพื่อใช้ประโยชน์ของ Polymorphism เราควรเพิ่ม @Override ไว้เหนือเมธอด

ฉันใช้มันให้มากที่สุดเท่าที่จะทำได้เพื่อระบุว่าเมื่อใดที่วิธีการนั้นถูก overriden หากคุณดูที่ภาษาการเขียนโปรแกรม Scala พวกเขายังมีคำหลักแทนที่ ฉันคิดว่ามันมีประโยชน์

มันช่วยให้คุณ (คอมไพเลอร์) จับเมื่อคุณใช้การสะกดผิดกับชื่อวิธีที่คุณกำลังเอาชนะ

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

ฉันคิดว่าเป็นการดีที่สุดที่จะเขียนโค้ด @override ทุกครั้งที่อนุญาต มันช่วยในการเข้ารหัส อย่างไรก็ตามสำหรับข้อสังเกตสำหรับ ecipse Helios ไม่ว่าจะเป็น sdk 5 หรือ 6 คำอธิบายประกอบ @override สำหรับวิธีการใช้งานที่ได้รับอนุญาต สำหรับกาลิเลโอไม่อนุญาตให้ใช้คำอธิบายประกอบแบบ 5 หรือ 6 อย่างใดอย่างหนึ่ง

คำอธิบายประกอบจะให้ข้อมูลเมตาเกี่ยวกับรหัสแก่คอมไพเลอร์และคำอธิบายประกอบ @Override จะใช้ในกรณีของการสืบทอดเมื่อเรากำลังเอาชนะวิธีการใด ๆ ของชั้นฐาน มันแค่บอกคอมไพเลอร์ว่าคุณกำลังเอาชนะวิธีการ มันสามารถ avoide ข้อผิดพลาดทั่วไปบางชนิดที่เราสามารถทำได้เช่นไม่ปฏิบัติตามลายเซ็นที่ถูกต้องของวิธีการหรือการสะกดผิดในชื่อของวิธีการ ฯลฯ ดังนั้นจึงเป็นวิธีปฏิบัติที่ดีในการใช้คำอธิบายประกอบ @Override

สำหรับฉัน @Override รับรองว่าฉันมีลายเซ็นของวิธีการที่ถูกต้อง หากฉันใส่คำอธิบายประกอบและวิธีการสะกดไม่ถูกต้องคอมไพเลอร์ก็บ่นให้ฉันรู้ว่ามีบางอย่างผิดปกติ

ง่าย ๆ - เมื่อคุณต้องการแทนที่เมธอดที่มีอยู่ในซูเปอร์คลาสของคุณให้ใช้@Overrideคำอธิบายประกอบเพื่อทำการแทนที่ที่ถูกต้อง คอมไพเลอร์จะเตือนคุณหากคุณไม่ได้แทนที่อย่างถูกต้อง