แนวคิดพื้นฐานของการสืบทอดและการสังเคราะห์
การสืบทอด: คลาสใหม่สามารถสร้างขึ้นได้ตามคลาสที่มีอยู่ การสืบทอดคลาสที่มีอยู่สามารถนำวิธีการและโดเมนของคลาสเหล่านี้กลับมาใช้ซ้ำได้ บนพื้นฐานนี้สามารถเพิ่มวิธีการและโดเมนใหม่เพื่อขยายฟังก์ชั่นของคลาส
การสังเคราะห์: การสร้างวัตถุต้นฉบับในคลาสใหม่เรียกว่าการสังเคราะห์ วิธีนี้คุณสามารถนำรหัสที่มีอยู่กลับมาใช้ใหม่ได้โดยไม่ต้องเปลี่ยนแบบฟอร์ม
1. ไวยากรณ์ที่สืบทอดมา
คำหลักขยายแสดงว่าคลาสใหม่นั้นได้มาจากคลาสที่มีอยู่ คลาสที่มีอยู่เรียกว่าคลาสแม่หรือคลาสพื้นฐานและคลาสใหม่เรียกว่าคลาสย่อยหรือคลาสที่ได้รับ ตัวอย่างเช่น:
นักเรียนชั้นเรียนขยายบุคคล {}นักเรียนชั้นเรียนสืบทอดบุคคล คลาสบุคคลเรียกว่าชั้นเรียนหลักหรือชั้นเรียนฐานและชั้นเรียนนักเรียนเรียกว่าคลาสย่อยหรือคลาสที่ได้รับ
2. การสังเคราะห์การสังเคราะห์
การสังเคราะห์ค่อนข้างง่ายซึ่งคือการสร้างคลาสที่มีอยู่ในชั้นเรียน
นักเรียนชั้นเรียน {Dog Dog;}สไตล์ขึ้น
1. แนวคิดพื้นฐาน
บทบาทของการสืบทอดอยู่ในการใช้รหัสซ้ำ เนื่องจากการสืบทอดหมายความว่าวิธีการทั้งหมดของคลาสแม่สามารถใช้ในคลาสย่อยข้อความที่ส่งไปยังคลาสแม่สามารถส่งไปยังคลาสอนุพันธ์ได้ หากมีวิธีการกินในชั้นเรียนบุคคลจะมีวิธีนี้ในชั้นเรียนนักเรียนซึ่งหมายความว่าวัตถุนักเรียนเป็นประเภทของบุคคล
บุคคลในชั้นเรียน {โมฆะสาธารณะกิน () {system.out.println ("กิน");} โมฆะคงที่แสดง (บุคคล p) {p.eat ();}} นักเรียนชั้นเรียนสาธารณะขยายบุคคล {โมฆะคงที่สาธารณะหลัก【ผลการดำเนินงาน】:
กิน
วิธีการแสดงที่กำหนดไว้ในตัวเองใช้เพื่อรับที่จับบุคคล แต่ที่①จะได้รับการอ้างอิงถึงวัตถุนักเรียน นี่เป็นเพราะวัตถุนักเรียนเป็นวัตถุของบุคคล ในวิธีการแสดงที่จับ (การอ้างอิงถึงวัตถุ) ที่ส่งผ่านสามารถเป็นวัตถุบุคคลและบุคคลที่ได้รับวัตถุคลาส พฤติกรรมของการแปลงนักเรียนที่จับเป็นมือจับตัวกลายเป็นรูปแบบที่สูงขึ้น
2. ทำไมคุณต้องติดตามรูปร่าง?
ทำไมคุณถึงต้องการเพิกเฉยต่อประเภทวัตถุที่เรียกมันเมื่อโทรหา Eat? หากคุณทำวิธีการแสดงเพียงแค่จัดการกับนักเรียนดูเหมือนว่าใช้งานง่ายและเข้าใจง่ายมากขึ้น แต่นั่นจะทำให้ทุกชั้นเรียนใหม่ที่ได้มาจากชั้นเรียนบุคคลใช้วิธีการแสดงของตัวเอง:
ค่าคลาส {count private int = 1; ค่าส่วนตัว (จำนวน int) {this.count = count;} ค่าคงที่สาธารณะสุดท้าย v1 = ค่าใหม่ (1), v2 = ค่าใหม่ (2), v3 = ค่าใหม่ (3);} คนชั้นเรียน {system.out.println ("teacher.eat ()");}} นักเรียนชั้นเรียนขยายบุคคล {โมฆะสาธารณะกิน (ค่า V) {system.out.println ("student.eat ()");}} ชั้นเรียนสาธารณะ upcastingdemo {t.eat (value.v1);} โมฆะคงที่สาธารณะแสดง (บุคคล p) {p.eat (value.v1);} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {นักเรียน s = นักเรียนใหม่ () ครู t = ครูใหม่ (); บุคคล p = บุคคลใหม่ (); แสดง (s);ข้อบกพร่องที่ชัดเจนในวิธีการนี้คือจำเป็นต้องกำหนดวิธีการที่เกี่ยวข้องอย่างใกล้ชิดกับคลาสอนุพันธ์ของคลาสแต่ละคนส่งผลให้รหัสซ้ำจำนวนมาก ในทางกลับกันหากคุณลืมการโอเวอร์โหลดของวิธีการคุณจะไม่รายงานข้อผิดพลาด วิธีการแสดงทั้งสามในตัวอย่างข้างต้นสามารถรวมเข้าด้วยกันเป็นหนึ่งเดียว:
โมฆะคงที่สาธารณะแสดง (บุคคล p) {p.eat (value.v1);} การผูกมัดแบบไดนามิก
เมื่อทำการแสดงผลการส่งออกคือ student.eat () นี่เป็นผลลัพธ์ที่ต้องการ แต่ดูเหมือนจะไม่ถูกประหารชีวิตในรูปแบบที่เราหวังไว้ มาดูวิธีการแสดงอีกครั้ง:
โมฆะคงที่สาธารณะแสดง (บุคคล p) {p.eat (value.v1);}มันได้รับการจัดการบุคคล เมื่อทำการแสดง (s) มันรู้ได้อย่างไรว่าบุคคลนั้นจัดการคะแนนไปยังวัตถุนักเรียนแทนที่จะเป็นวัตถุครู? คอมไพเลอร์ไม่มีทางรู้ซึ่งเกี่ยวข้องกับปัญหาการผูกมัดที่จะอธิบายต่อไป
1. วิธีการเรียกใช้การโทร
การเชื่อมต่อวิธีการและร่างกายวิธีการเดียวกันเข้าด้วยกันเรียกว่าการผูกมัด หากมีผลผูกพันก่อนที่จะทำงานจะเรียกว่า "การผูกมัดก่อน" ในตัวอย่างข้างต้นเมื่อมีคนจัดการเพียงคนเดียวคอมไพเลอร์ไม่ทราบว่าจะเรียกใช้วิธีใด Java ใช้กลไกการเรียกใช้วิธีการที่สามารถกำหนดประเภทของวัตถุในระหว่างการทำงานและเรียกใช้วิธีการที่เกี่ยวข้อง การเชื่อมโยงนี้ขึ้นอยู่กับประเภทของวัตถุเรียกว่าการเชื่อมโยงแบบไดนามิกระหว่างการดำเนินการ เว้นแต่จะมีการประกาศวิธีการสุดท้ายวิธีทั้งหมดใน Java จะถูกผูกไว้แบบไดนามิก
ใช้รูปภาพเพื่อแสดงถึงความสัมพันธ์ในการสืบทอดของรูปร่างสูงขึ้น:
ในรหัสสรุปเป็น:
Shapes=newShape();
ตามความสัมพันธ์ในการสืบทอดมันเป็นเรื่องถูกกฎหมายที่จะกำหนดที่จับวัตถุวงกลมที่สร้างขึ้นให้เป็นรูปร่างเนื่องจากวงกลมเป็นของรูปร่าง
เมื่อหนึ่งในวิธีการคลาสพื้นฐานเรียกว่า:
Shapes=newShape();
ในเวลานี้ Circle.draw () ถูกเรียกซึ่งเกิดจากการเชื่อมโยงแบบไดนามิก
บุคคลในชั้นเรียน {โมฆะกิน () {} โมฆะพูด () {}} เด็กชายชั้นเรียนขยายบุคคล {void eat () {system.out.println ("boy.eat ()");} void พูด () {system.out.println ("boy.speak ()"); {system.out.println ("girl.eat ()");}} บุคคลระดับสาธารณะ {บุคคลคงที่สาธารณะ randperson () {switch ((int) (math.random () * 2)) {ค่าเริ่มต้น: กรณี 0: คืนเด็กใหม่ (); <p.length;สำหรับทุกชั้นเรียนที่ได้มาจากบุคคลบุคคลจะสร้างอินเทอร์เฟซทั่วไปและคลาสที่ได้รับทั้งหมดมีสองพฤติกรรม: กินและพูด คลาสที่ได้รับจะแทนที่คำจำกัดความเหล่านี้และกำหนดพฤติกรรมทั้งสอง ในคลาสหลัก Randperson สุ่มเลือกที่จับของวัตถุบุคคล ** รูปแบบการอุทธรณ์เกิดขึ้นในคำสั่ง Return คำสั่ง ** กลับใช้การจัดการกับเด็กผู้ชายหรือเด็กผู้หญิงและส่งคืนเป็นคนประเภท ในเวลานี้ฉันไม่รู้ว่ามันคือประเภทอะไรฉันรู้แค่ว่ามันเป็นมือจับวัตถุบุคคล ในวิธีการหลักให้โทรหาวิธี Randperson เพื่อเติมเต็มวัตถุของบุคคลในอาร์เรย์ แต่ไม่ทราบสถานการณ์เฉพาะ เมื่อวิธีการ EAT ของแต่ละองค์ประกอบของอาร์เรย์ถูกเรียกฟังก์ชันของการเชื่อมโยงแบบไดนามิกคือการดำเนินการวิธีการที่กำหนดใหม่ของวัตถุ
อย่างไรก็ตามการผูกมัดแบบไดนามิกเป็นสิ่งที่จำเป็นต้องมีและวิธีการผูกมัดจะต้องมีอยู่ในคลาสฐานมิฉะนั้นจะไม่ถูกรวบรวมและผ่าน
บุคคลในชั้นเรียน {โมฆะกิน () {system.out.println ("person.eat ()");}} เด็กชายชั้นเรียนขยายบุคคล {void eat () {system.out.println ("boy.eat ()");} void พูด () {system.out.println ( {person p = new boy (); p.eat (); p.speak (); // วิธีการพูด () ไม่ได้กำหนดไว้สำหรับคนประเภท}}}หากไม่มีการแทนที่วิธีการแทนที่ในคลาสย่อยวิธีการในคลาสหลักจะเรียกว่า:
บุคคลในชั้นเรียน {void eat () {system.out.println ("person.eat ()");}} เด็กชายชั้นเรียนขยายบุคคล {} บุคคลชั้นเรียนสาธารณะ {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {บุคคล p = เด็กใหม่ (); p.eat ();}}}}}}}}}}}【ผลการดำเนินงาน】:
person.eat ()
2. การเชื่อมของวิธีการคงที่
เพิ่มคำหลักคงที่ไปยังวิธีการข้างต้นและเปลี่ยนเป็นวิธีการคงที่:
คนชั้นเรียน {โมฆะคงที่กิน () {system.out.println ("person.eat ()");} โมฆะคงที่พูด () {system.out.println ("person.peak ()");}} เด็กเรียน {system.out.println ("boy.speak ()");}} สาวชั้นเรียนขยายบุคคล {โมฆะคงที่กิน () {system.out.println ("girl.eat ()");} void คงที่พูด () {system.out.println ("girl.speak ()") ((int) (math.random () * 2)) {ค่าเริ่มต้น: กรณี 0: กลับไปที่เด็กใหม่ (); กรณีที่ 1: กลับสาวใหม่ ();}} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {person [] p = คนใหม่ [4]; สำหรับ (int i = 0; i <p.length; i ++) p.length; 【ผลการดำเนินงาน】:
person.eat ()
person.eat ()
person.eat ()
person.eat ()
ผลการสังเกต: สำหรับวิธีการคงที่ไม่ว่าคลาสย่อยใดที่คลาสแม่จะอ้างถึงวิธีการของคลาสแม่ที่เรียกว่า
สูตรช่วยอำนวยความสะดวก
- วิธีการคงที่: วิธีการคงที่ดูคลาสแม่
-วิธีการที่ไม่คงที่: วิธีที่ไม่คงที่ดูคลาสย่อย
สรุป
ข้างต้นเป็นเนื้อหาทั้งหมดของการตีความโดยละเอียดของบทความนี้เกี่ยวกับแนวคิดของมรดก Java และฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน เพื่อนที่สนใจสามารถอ้างถึงหัวข้ออื่น ๆ ที่เกี่ยวข้องในเว็บไซต์นี้ต่อไป หากมีข้อบกพร่องใด ๆ โปรดฝากข้อความไว้เพื่อชี้ให้เห็น ขอบคุณเพื่อนที่ให้การสนับสนุนเว็บไซต์นี้!