นักเรียนหลายคนโง่และไม่สามารถบอกความแตกต่างระหว่างการโอเวอร์โหลดและแทนที่ ขอแนะนำไม่ให้จดจำความรู้เชิงแนวคิดโดยการท่องจำ แต่เพื่อทำความเข้าใจและจดจำ
ก่อนอื่นให้ฉันให้คำจำกัดความของฉัน:
ก่อนอื่นมาพูดถึง: การโอเวอร์โหลด
(1) วิธีการโอเวอร์โหลดเป็นวิธีการให้คลาสประมวลผลข้อมูลประเภทต่าง ๆ ด้วยวิธีที่รวมกัน ฟังก์ชั่นหลายฟังก์ชั่นที่มีชื่อเดียวกันมีอยู่ในเวลาเดียวกันโดยมีพารามิเตอร์/ประเภทที่แตกต่างกัน การโอเวอร์โหลดเป็นการรวมตัวกันของ polymorphism ในชั้นเรียน
(2) การโอเวอร์โหลดเมธอด Java หมายความว่าสามารถสร้างหลายวิธีในชั้นเรียนพวกเขามีชื่อเดียวกัน แต่มีพารามิเตอร์ที่แตกต่างกันและคำจำกัดความที่แตกต่างกัน เมื่อใช้วิธีการโทรเราตัดสินใจว่าจะใช้วิธีใดตามจำนวนพารามิเตอร์และประเภทพารามิเตอร์ที่แตกต่างกันส่งผ่านไปยังพวกเขา นี่คือความหลากหลาย
(3) เมื่อมีการโอเวอร์โหลดชื่อวิธีจะต้องเหมือนกัน แต่ประเภทพารามิเตอร์และหมายเลขจะแตกต่างกันและประเภทค่าส่งคืนอาจเหมือนกันหรือแตกต่างกัน ประเภทการส่งคืนไม่สามารถใช้เป็นเกณฑ์ความแตกต่างสำหรับฟังก์ชั่นการโอเวอร์โหลด
ก่อนอื่นให้ดูตัวอย่างของการโอเวอร์โหลด:
คลาสสาธารณะ OverloadParent {Public String getPerson (ชื่อสตริง) {return "persona" + ชื่อ; } สตริงสาธารณะ getPerson (อายุ int) {return "personb"; } สตริงสาธารณะ getPerson (ชื่อสตริงอายุ int) {return "personc"; } โมฆะสาธารณะ getPerson (ชื่อสตริง) {system.out.println ("ฉันเป็นวิธีที่โอเวอร์โหลดหรือไม่"); }} คลาสสาธารณะ OverloadChildExtends overloadParent {โมฆะสาธารณะ getPerson (เงินสองเท่า) {System.out.println ("ฉันเป็นวิธีที่โอเวอร์โหลด"); -ให้ความสนใจกับการสังเกต:
(1) มี 4 วิธีที่มีชื่อเดียวกันใน overloadparent
(2) ประเภทพารามิเตอร์และจำนวนของสามวิธีแรกไม่สอดคล้องกันและค่าคืนค่าเหมือนกันซึ่งถือว่าโอเวอร์โหลด
(3) วิธีการที่ 4 และวิธีการที่ 1 เฉพาะค่าที่ส่งคืนจะแตกต่างกันและไม่ถือว่าเป็นการโอเวอร์โหลดและคอมไพเลอร์ไม่ผ่าน
PS: ค่าส่งคืนเป็นผลมาจากการดำเนินการวิธีการ เมื่อเราเรียกวิธีการเราจะไม่ระบุ "ฉันต้องการเรียกวิธีการที่มีค่าส่งคืนของประเภท xxx" มันจะไม่กลายเป็นคุณลักษณะของวิธีการโอเวอร์โหลด
(4) overloadparent สืบทอดการสาธิตและมีวิธีการทั้งหมดที่เป็นเจ้าของในการสาธิต มันรู้สึกว่าวิธีที่มีอยู่ไม่สามารถตอบสนองความต้องการได้ดังนั้นมันจึงมากเกินไป
ธงมากเกินไป: ชื่อวิธีการเหมือนกันพารามิเตอร์แตกต่างกัน (หมายเลขหรือประเภท) และไม่มีส่วนเกี่ยวข้องกับค่าส่งคืน
แล้วมาพูดถึงการเอาชนะ (เอาชนะ) กันเถอะ)
(1) ความหลากหลายระหว่างคลาสแม่และชั้นเด็กกำหนดฟังก์ชั่นของคลาสแม่ หากวิธีการที่กำหนดไว้ในคลาสย่อยมีชื่อและพารามิเตอร์เดียวกับคลาสแม่เราบอกว่าวิธีการที่เหนือกว่า ใน Java subclasses สามารถสืบทอดวิธีการจากคลาสแม่โดยไม่ต้องเขียนวิธีเดียวกันใหม่
แต่บางครั้ง subclass ไม่ต้องการสืบทอดวิธีการของคลาสแม่ แต่ต้องการทำการแก้ไขบางอย่างซึ่งต้องมีการเขียนใหม่ของวิธีการใหม่
วิธีการเขียนใหม่เรียกว่าการเขียนทับวิธี
(2) หากวิธีการในคลาสย่อยมีชื่อวิธีการเดียวกันให้กลับประเภทประเภทและตารางพารามิเตอร์เป็นวิธีในคลาสพาเรนต์วิธีใหม่จะแทนที่วิธีดั้งเดิม
หากคุณต้องการวิธีดั้งเดิมในคลาสพาเรนต์คุณสามารถใช้คำหลัก Super ซึ่งหมายถึงคลาสพาเรนต์ของคลาสปัจจุบัน
(3) สิทธิ์ในการปรับเปลี่ยนการเข้าถึงของฟังก์ชั่น subclass ไม่น้อยกว่าของคลาสแม่
มาดูตัวอย่างการเขียนทับกัน:
คลาสสาธารณะ overrideparent {public void fly () {system.out.println ("ican fly!"); }} คลาสสาธารณะ overridechild ขยาย overrideparent {@Override โมฆะสาธารณะบิน () {system.out.println ("ican't fly, แต่ฉันสามารถวิ่งได้!"); } สาธารณะคงที่ VID หลัก (String [] args) {overwriteparent child = new wudritechild (); เด็กแมลงวัน (); -อะไรจะเป็นผลผลิตเมื่อดำเนินการหลักวิธีหลักของ Overridechild?
คำตอบคือฉันไม่สามารถแมลงลูดได้ แต่ฉันสามารถวิ่งได้!
เราเห็น:
(1) ผู้ครอบงำและ overrideparent มีวิธีการบิน
(2) ค่าส่งคืนและตัวดัดแปลงของแมลงวันเหมือนกันเฉพาะร่างกายของวิธีการแตกต่างกัน
(3) มีคำอธิบายประกอบของ @Overwrite ก่อนวิธีการบินของคลาสย่อย JDK1.5 ปรากฏขึ้นและใช้สำหรับการสืบทอดคลาสเท่านั้น 1.6 สามารถใช้สำหรับการใช้งานส่วนต่อประสาน คำอธิบายประกอบนี้ช่วยตรวจสอบคอมไพเลอร์และไม่สามารถเพิ่มได้
Flags Overridden : เด็กสืบทอดคลาสหลักและมีการใช้งานที่แตกต่างกันสำหรับวิธีการเดียวกัน
สถานการณ์แอปพลิเคชัน
โอเวอร์โหลด: เมื่อฟังก์ชั่นวิธีการคล้ายกัน แต่ต้องส่งพารามิเตอร์ที่แตกต่างกัน
Override: เมื่อ subclass มีพฤติกรรมที่เป็นเอกลักษณ์ของตัวเองมันสืบทอดมาจากชั้นเรียนหลักและไม่สามารถตอบสนองความต้องการของตัวเองได้
PS: การโอเวอร์โหลดและการเขียนทับเป็นทั้งการแสดงออกของความหลากหลาย อดีตคือคอมไพเลอร์ polymorphism ในขณะที่หลังเป็นรันไทม์ polymorphism
กฎสำหรับวิธีการเขียนใหม่:
1. รายการพารามิเตอร์จะต้องเหมือนกับวิธีการเขียนใหม่มิฉะนั้นจะไม่สามารถเรียกได้ว่าเขียนซ้ำ แต่โอเวอร์โหลด
2. ประเภทที่ส่งคืนจะต้องเหมือนกับประเภทการส่งคืนของวิธีที่เขียนทับไม่เช่นนั้นไม่สามารถเรียกได้ว่าเขียนซ้ำ แต่โอเวอร์โหลด
3. ขีด จำกัด การเข้าถึงการเข้าถึงจะต้องมากกว่าตัวดัดแปลงการเข้าถึงของวิธีการเขียนใหม่ (สาธารณะ> ป้องกัน> ค่าเริ่มต้น> ส่วนตัว)
4. วิธีการเขียนใหม่จะต้องไม่โยนข้อยกเว้นการตรวจสอบใหม่หรือข้อยกเว้นที่ตรวจสอบอย่างกว้างขวางกว่าการประกาศวิธีการเขียนใหม่ ตัวอย่างเช่น:
วิธีการของคลาสแม่ประกาศข้อยกเว้นการตรวจสอบ IOException เมื่อเขียนวิธีนี้ใหม่คุณไม่สามารถโยนข้อยกเว้นได้คุณสามารถโยนข้อยกเว้นย่อยของ IOException ได้เท่านั้นและคุณสามารถโยนข้อยกเว้นที่ไม่ได้ตรวจสอบได้
และกฎสำหรับการโอเวอร์โหลด:
1. ต้องมีรายการพารามิเตอร์ที่แตกต่างกัน
2. อาจมีประเภทการส่งคืนที่ไม่ดุคุณตราบใดที่รายการพารามิเตอร์แตกต่างกัน
3. อาจมีตัวดัดแปลงการเข้าถึงที่แตกต่างกัน
4. ข้อยกเว้นที่แตกต่างกันสามารถโยนได้;
ความแตกต่างระหว่างการเขียนซ้ำและการโอเวอร์โหลดคือ:
การเขียนแบบ polymorphism ใหม่การเรียกใช้วิธีการมากเกินไปสามารถลดจำนวนอินพุตของรหัสได้อย่างมาก ตราบใดที่ชื่อวิธีการเดียวกันส่งผ่านพารามิเตอร์ที่แตกต่างกันมันสามารถมีฟังก์ชั่นที่แตกต่างกันหรือค่าส่งคืน
หากคุณใช้การเขียนใหม่และการโอเวอร์โหลดได้ดีคุณสามารถออกแบบชั้นเรียนด้วยโครงสร้างที่ชัดเจนและกระชับ อาจกล่าวได้ว่าบทบาทของการเขียนใหม่และการโอเวอร์โหลดในกระบวนการเขียนโค้ดนั้นไม่ธรรมดา
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น