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

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

มีจุดมุ่งหมายเพื่อให้คล้ายกับหน่วยงานในโลกแห่งความเป็นจริงและทำให้โปรแกรมเมอร์สร้างโค้ดที่รวมกระบวนทัศน์ที่พวกเขากำลังเขียนโค้ดได้ง่ายขึ้น มีแนวคิดการเขียนโปรแกรมเชิงวัตถุสี่แนวคิด ได้แก่ Inheritance, Abstraction, Polymorphism และ encapsulation ในตอนนี้ แนวคิดแต่ละข้อดังที่กล่าวไว้ก่อนหน้านี้ ถือได้ว่าเป็นเสาหลักที่ภาษาสมัยใหม่ใดๆ มีอยู่ในปัจจุบัน

กลับมาที่หัวข้อ polymorphism กับ inheritance และ right of the bat ของเรา เราจะเห็นความแตกต่างที่เห็นได้ชัดระหว่างแนวคิดทั้งสอง การสืบทอดเป็นแนวคิดที่อนุญาตให้ใช้รหัสซ้ำอีกครั้งในโปรแกรมเดิมหรือโปรแกรมอื่น เรายังเปลี่ยนวิธีการทำงานของโค้ดได้ด้วยการรักษาสิ่งที่เราชอบและละทิ้งสิ่งที่ไม่เป็นประโยชน์สำหรับงานที่เราพยายามทำให้สำเร็จ การสืบทอดช่วยประหยัดเวลาได้มากในการพัฒนาเกือบทุกอย่างที่เราเห็นบนจอแสดงผลดิจิทัลของเราในปัจจุบัน

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

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

มรดก

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

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

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

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

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

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

อ่าน: โอกาสในการทำงานในภาษาการเขียนโปรแกรม R

C ++ ยังให้คุณมีตัวเลือกมากมายเมื่อคุณทำการสืบทอด คุณจะพบรายการด้านล่าง:

ก. การ สืบทอดตามลำดับชั้น: การสืบทอด ประเภทนี้เป็นไปตามกฎที่ควรมีเพียงหนึ่ง superclass และจาก superclass นั้นจะต้องมี subclass ที่ได้รับจำนวนมาก คุณจะพบตัวอย่างด้านล่าง:

1. //คลาสพื้นฐาน
2. คลาส A
3. {
4. โมฆะสาธารณะ funA()
5. {
6. //
7. }
8. }
10. //คลาสที่ได้รับ
11. คลาส B: A
12. {
13. โมฆะสาธารณะ funB()
14. {
15. //
16. }
17. }
19. //คลาสที่ได้รับ
20. คลาส C: A
21. {
22. โมฆะสาธารณะ funC()
23. {
24. //
25. }
26. }
28. //คลาสที่ได้รับ
29. คลาส D: C
30. {
31. โมฆะสาธารณะ funD()
32. {
33. //
34. }
35. }
37. //คลาสที่ได้รับ
38. คลาส E: C
39. {
40. โมฆะสาธารณะ funE()
41. {
42. //
43. }
44. }
46. //คลาสที่ได้รับ
47. คลาส F: B
48. {
49. โมฆะสาธารณะ funF()
50. {
51. //
52. }
53. }
55. //คลาสที่ได้รับ
56. คลาส G: B
57. {
58. โมฆะสาธารณะ funG()
59. {
60. //
61. }
62. }

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

1. //คลาสพื้นฐาน
2. คลาส A
3. {
4. โมฆะสาธารณะ funA()
5. {
6. //
7. }
8. }
10. //คลาสพื้นฐาน
11. คลาส B
12. {
13. โมฆะสาธารณะ funB()
14. {
15. //
16. }
17. }
19. //คลาสที่ได้รับ
20. คลาส C: A, B
21. {
22. โมฆะสาธารณะ funC()
23. {
24. //
25. }
26. }

ค. มรดกเดี่ยว: นี่อาจเป็นรูปแบบการสืบทอดที่ง่ายที่สุด มีเพียงหนึ่งคลาสฐานและหนึ่งคลาสที่ได้รับ คุณจะพบตัวอย่างด้านล่าง:

1. //คลาสพื้นฐาน
2. คลาส A
3. {
4. โมฆะสาธารณะ funA()
5. {
6. //ทำ:
7. }
8. }
10. //คลาสที่ได้รับ
11. คลาส B: A
12. {
13. โมฆะสาธารณะ funB()
14. {
15. //ทำ:
16. }
17. }

ความหลากหลาย

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

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

1. คลาสเกิน{
2. int a, b;
3. สาธารณะ:
4. int โอเวอร์โหลด (int x) { // โอเวอร์โหลดแรก () ตัวสร้าง
5. ก=x;
6. ส่งคืน a;
7. }
8. int โอเวอร์โหลด (int x, int y) { //วินาทีโอเวอร์โหลด () ตัวสร้าง
9. ก=x;
10. b=y;
11. ส่งคืน a*b;
12. }
13. };
14. int หลัก (){
15. โอเวอร์โหลด O1;
16. โอ1 เกินพิกัด (20); // โอเวอร์โหลดแรก () คอนสตรัคเตอร์เรียก
17. โอ1 เกินพิกัด (20,40); // โอเวอร์โหลดที่สอง () การเรียกคอนสตรัคเตอร์

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

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

1. ฐานชั้น{
2. สาธารณะ:
3. ฟังก์ชัน โมฆะเสมือน ( ) {// ฟังก์ชันเสมือนของคลาสฐาน
4. cout<<"นี่คือ funct() ของคลาสพื้นฐาน";
5. }
6. };
7. คลาสที่ได้รับ1 : ฐานสาธารณะ{
8. สาธารณะ:
9. void funct () {// ฟังก์ชั่นเสมือนของคลาสฐานกำหนดใหม่ในคลาสที่ได้รับ1
10. cout<<"นี่คือ function() ของคลาสที่รับมา";
11. }
12. };
13. int หลัก ()
14. {
15. ฐาน *p, b;
16. ที่ได้รับ1 d1;
17. *p=&b;
18. p-> ฟังก์ชั่ น (); // เรียกใช้ฟังก์ชันคลาสพื้นฐาน ()
19. *p=&d1;
20. กลับ 0;
21. }

ดูว่าคีย์เวิร์ด virtual ถูกใช้อย่างไรในคลาสฐาน และในคลาสที่ได้รับ นิยามฟังก์ชันเดียวกันก็คือไม่มีคีย์เวิร์ด virtual

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

1. การสืบทอดคือการสร้างคลาส จากนั้นให้คลาสอื่นๆ ในโปรแกรมของคุณรับฟีเจอร์จากคลาสพื้นฐานที่มีอยู่แล้ว อย่างไรก็ตาม พหุสัณฐานเป็นส่วนต่อประสาน และเนื่องจากเป็นอินเทอร์เฟซ จึงสามารถใช้รูปร่างและรูปแบบที่แตกต่างกันได้
2. การสืบทอดเป็นคุณสมบัติที่เกี่ยวข้องกับคลาสเพียงอย่างเดียว ในขณะที่พหุสัณฐานขยายตัวเองเป็นวิธีการและ/หรือฟังก์ชันใดๆ
3. การสืบทอดอนุญาตให้คลาสที่ได้รับใช้ฟังก์ชันและตัวแปรทั้งหมดที่ประกาศในคลาสฐานโดยไม่ต้องกำหนดอย่างชัดเจนอีก นั่นคือเหตุผลที่เรากล่าวว่าการสืบทอดเพิ่มความสามารถในการนำรหัสกลับมาใช้ใหม่ได้และลดความยาวของรหัส ซึ่งเราจะต้องเขียนหากไม่มีการสืบทอด ในขณะที่พหุสัณฐานทำให้ชื่อฟังก์ชันเดียวกันมีรหัสที่แตกต่างกันสองรหัส ดังนั้น ในแง่หนึ่ง แทนที่จะลดความยาวของโค้ดที่เราจะต้องเขียน ความหลากหลายกลับขยายออกไปอีก
4. มีหลายรูปแบบที่สามารถรับมรดกได้ คุณสามารถสร้างสรรค์ได้อย่างแท้จริงด้วยการสืบทอด อย่างไรก็ตาม ความหลากหลายสามารถทำได้ด้วยสองวิธีเท่านั้น คือ การโอเวอร์โหลดและการเอาชนะ คุณยังสามารถคลั่งไคล้ได้มากในขณะที่ใช้ polymorphism แต่คุณถูกจำกัดให้ใช้งานได้เพียงสองวิธีในการเขียนโค้ดของคุณ

ต้องอ่าน: ต้องอ่าน 47 OOPS คำถามและคำตอบสัมภาษณ์สำหรับ Freshers & ผู้มีประสบการณ์

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

ในตารางด้านล่าง คุณจะพบความแตกต่างที่ชัดเจนระหว่างความแตกต่างและการสืบทอด:

เช็คเอาท์: Type Casting ใน Java คืออะไร | ทำความเข้าใจการหล่อแบบเป็นมือใหม่

บทสรุป

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

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

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

หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับการพัฒนาซอฟต์แวร์แบบฟูลสแตก โปรดดูประกาศนียบัตร PG ของ upGrad & IIIT-B ด้านการพัฒนาซอฟต์แวร์แบบครบวงจร ซึ่งออกแบบมาสำหรับมืออาชีพที่ทำงานและมีการฝึกอบรมที่เข้มงวดมากกว่า 500 ชั่วโมง โครงการมากกว่า 9 โครงการ และ การมอบหมายงาน สถานะศิษย์เก่า IIIT-B โครงการหลักที่นำไปปฏิบัติจริง และความช่วยเหลือด้านงานกับบริษัทชั้นนำ

วางแผนอาชีพการพัฒนาซอฟต์แวร์ของคุณตอนนี้

สมัครใบรับรอง PG ที่เชื่อมโยงกับงานของ upGrad ในสาขาวิศวกรรมซอฟต์แวร์