ความแตกต่างระหว่างการสืบทอดและความหลากหลาย

• 2019

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

แผนภูมิเปรียบเทียบ

พื้นฐานสำหรับการเปรียบเทียบ	มรดก	ความแตกต่าง
ขั้นพื้นฐาน	การสืบทอดกำลังสร้างคลาสใหม่โดยใช้คุณสมบัติของคลาสที่มีอยู่แล้ว	ความแตกต่างนั้นเป็นอินเตอร์เฟสทั่วไปสำหรับหลายรูปแบบ
การดำเนินงาน	การสืบทอดนั้นถูกนำไปใช้กับคลาส	ความหลากหลายมีการใช้งานโดยทั่วไปในการทำงาน / วิธีการ
ใช้	เพื่อสนับสนุนแนวคิดของการใช้ซ้ำใน OOP และลดความยาวของรหัส	อนุญาตให้วัตถุตัดสินใจว่าจะเรียกใช้ฟังก์ชันรูปแบบใดเมื่อในเวลารวบรวม (มากไป) และเวลาทำงาน (แทนที่)
รูปแบบ	การสืบทอดอาจเป็นมรดกเดี่ยวหลายมรดกมรดกหลายระดับมรดกลำดับชั้นและมรดกไฮบริด	ความแตกต่างอาจเป็นช่วงเวลาที่รวบรวมความแตกต่าง (มากไป) หรือความแตกต่างในเวลาทำงาน (เอาชนะ)
ตัวอย่าง	คลาส 'ตาราง' สามารถสืบทอดคุณสมบัติของคลาส 'เฟอร์นิเจอร์' เนื่องจาก 'ตาราง' เป็น 'เฟอร์นิเจอร์'	คลาส 'study_table' สามารถมีฟังก์ชั่น 'set_color ()' และคลาส 'Dining_table' สามารถมีฟังก์ชั่น 'set_color ()' ดังนั้นรูปแบบของฟังก์ชั่น set_color () ที่จะเรียกสามารถตัดสินใจได้ทั้งในเวลารวบรวมและ เวลาทำงาน

คำจำกัดความของมรดก:

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

รูปแบบทั่วไปของการสืบทอดคลาสมีดังต่อไปนี้:

 class-class-name ที่ได้รับมา: access-specifier base-class-name {// เนื้อหาของคลาส}; 

ที่นี่ตัวระบุการเข้าถึงจัดเตรียมโหมดการเข้าถึง (ส่วนตัวสาธารณะป้องกัน) ให้กับสมาชิกในคลาสฐานไปยังคลาสที่ได้รับ หากไม่มีตัวระบุการเข้าถึงตามค่าเริ่มต้นจะถือว่าเป็น "ส่วนตัว" ใน C ++ ถ้าคลาสที่ได้รับคือ "struct" ตัวระบุการเข้าถึงคือ "สาธารณะ" โดยค่าเริ่มต้น

ใน C ++ การสืบทอดสามารถทำได้ในห้ารูปแบบ พวกเขาสามารถจำแนกได้เป็น: -

• มรดกเดี่ยว (คลาสเดียวเท่านั้น)
• การสืบทอดหลายรายการ (Superclasses หลายรายการ)
• การสืบทอดลำดับชั้น (คลาส Super หนึ่งคลาส, คลาสย่อยจำนวนมาก)
• การสืบทอดหลายอย่าง (มาจากคลาสที่ได้รับ)

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

 คลาสที่ได้รับคลาสชื่อขยายฐานชั้นชื่อ {// ร่างกายของชั้น}; 

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

'super' มีสองรูปแบบทั่วไป อย่างแรกคือมันใช้เพื่อเรียกนวกรรมิกของ super class ประการที่สองคือการเข้าถึงสมาชิกของซูเปอร์คลาสที่ถูกซ่อนไว้โดยสมาชิกของคลาสย่อย

 // รูปแบบแรกของการเรียกนวกรรมิก คลาส supper_class {supper_class (argument_list) {.. } // ตัวสร้างของคลาส super}; sub_class คลาสขยาย supper_class {sub_class (argument_list) {.. } // คอนสตรัคของ sub_class super (argument_list); // sub_class เรียกตัวสร้างของ super class}}; 

 // วินาทีสำหรับคลาส 'super' supper_class {int i; } คลาส sub_class ขยาย supper_class {int i; sub_class (int a, int b) {super.i = a; // 'i' ของ super class i = b; // 'i' ของคลาสย่อย}}; 

ความหมายของความแตกต่าง

คำว่าพหุนามหมายถึง 'หนึ่งฟังก์ชันหลายรูปแบบ' ความแตกต่างคือทำได้ทั้งในเวลารวบรวมและเวลาทำงาน polymorphism เวลาคอมไพล์สามารถทำได้ผ่าน "overloading" ในขณะที่ polymorphism เวลารันสามารถทำได้ผ่าน "overriding"

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

 คลาสเกินพิกัด {int a, b; สาธารณะ: int เกิน (int x) {// แรกเกิน () คอนสตรัค a = x; กลับมา; } int โอเวอร์โหลด (int x, int y) {// วินาทีโอเวอร์โหลด () คอนสตรัคเตอร์ a = x; ข y =; คืน a * b; }}; int main () {โอเวอร์โหลด O1; O1.overload (20); // แรกโอเวอร์โหลด () คอนสตรัคโทร O1.overload (20, 40); // การเรียกใช้ constructor เกินสอง () 

ทีนี้เรามาพูดถึงรูปแบบที่สองของความแตกต่างคือการเอาชนะ แนวคิดของการเอาชนะสามารถนำไปใช้กับฟังก์ชันของคลาสที่ใช้แนวคิดของการสืบทอดเท่านั้น ใน C ++ ฟังก์ชั่นที่จะถูกแทนที่จะถูกนำหน้าด้วยคำหลัก“ เสมือน” ในคลาสฐานและนิยามใหม่ในคลาสที่ได้รับด้วยต้นแบบเดียวกันยกเว้นคีย์เวิร์ด“ เสมือน”

 ชั้นฐาน {สาธารณะ: ฟังก์ชั่นโมฆะเสมือน () {// ฟังก์ชั่นเสมือนจริงของชั้นศาล << "นี่คือฟังก์ชั่นชั้นฐานของ" () "; }}; ระดับที่ได้รับ 1: ฐานสาธารณะ {สาธารณะ: เป็นโมฆะฟังก์ชั่น () {// ฟังก์ชั่นเสมือนจริงของชั้นฐานกำหนดไว้ในชั้นเรียนที่ได้รับ 1 
ความแตกต่างที่สำคัญระหว่างมรดกกับความแตกต่าง 
การสืบทอดกำลังสร้างคลาสที่สืบทอดคุณสมบัติของคลาสที่มีอยู่แล้ว ในทางตรงกันข้าม polymorphism เป็นอินเตอร์เฟสที่สามารถกำหนดได้ในหลายรูปแบบ
การสืบทอดจะดำเนินการในชั้นเรียนในขณะที่ความแตกต่างจะดำเนินการในวิธีการ / ฟังก์ชั่น
เนื่องจากการสืบทอดทำให้คลาสที่ได้รับมาใช้องค์ประกอบและวิธีการที่กำหนดไว้ในคลาสพื้นฐานคลาสที่ได้รับจึงไม่จำเป็นต้องกำหนดองค์ประกอบหรือวิธีการเหล่านั้นอีกครั้งดังนั้นเราจึงสามารถพูดได้ว่ามันจะเพิ่มความสามารถในการใช้รหัสได้อีกครั้ง . ในทางตรงกันข้ามความแตกต่างทำให้มันเป็นไปได้สำหรับวัตถุที่จะตัดสินใจว่ารูปแบบของวิธีการที่มันต้องการที่จะเรียกทั้งเวลารวบรวมและเวลาทำงาน
การสืบทอดสามารถแบ่งได้เป็นการสืบทอดเดี่ยวการสืบทอดหลายการสืบทอดหลายระดับการสืบทอดลำดับชั้นและการสืบทอดไฮบริด ในทางตรงกันข้าม polymorphism จัดเป็น overloading และ overriding
สรุป: 
การสืบทอดและความหลากหลายเป็นแนวคิดที่มีความสัมพันธ์กันในขณะที่ความแตกต่างแบบไดนามิกนำไปใช้กับชั้นเรียนซึ่งยังใช้แนวคิดของการถ่ายทอดทางพันธุกรรม