การรับมรดกใน Java (พร้อมตัวอย่าง)

มรดกคืออะไร?

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

การถ่ายทอดทางพันธุกรรมคืออะไร Java?

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

Java ไวยากรณ์การสืบทอด:

class subClass extends superClass
{
   //methods and fields
}

ประเภทของการสืบทอดใน Java

ต่อไปนี้เป็นมรดกประเภทต่างๆ Java:

1. มรดกเดียว
2. มรดกหลายรายการ
3. มรดกหลายระดับ
4. มรดกตามลำดับชั้น
5. มรดกแบบผสมผสาน

1. การสืบทอดแบบเดี่ยว:

ใน Single Inheritance คลาสหนึ่งจะขยายอีกคลาสหนึ่ง (คลาสเดียวเท่านั้น)

ในแผนภาพด้านบน คลาส B จะขยายเฉพาะคลาส A คลาส A เป็นคลาสซุปเปอร์ และคลาส B เป็นคลาสย่อย

2. การสืบทอดหลายแบบ:

มรดกหลายรายการเป็นหนึ่งในมรดกใน Java ประเภทที่หนึ่งคลาสขยายมากกว่าหนึ่งคลาส Java ไม่รองรับการสืบทอดหลายรายการ

ตามแผนภาพด้านบน คลาส C จะขยายคลาส A และคลาส B ทั้งสองอย่าง

3. การสืบทอดหลายระดับ:

ในการสืบทอดหลายระดับ คลาสหนึ่งสามารถสืบทอดจากคลาสที่ได้รับ ดังนั้นคลาสที่ได้รับจึงกลายเป็นคลาสพื้นฐานสำหรับคลาสใหม่

ตามที่แสดงในแผนภาพ Class C คือคลาสย่อยของ B และ B เป็นคลาสย่อยของ Class A

4. การสืบทอดลำดับชั้น:

ในการสืบทอดแบบลำดับชั้น คลาสหนึ่งจะได้รับการสืบทอดโดยคลาสย่อยหลายคลาส

ตามตัวอย่างข้างต้น คลาส B, C และ D สืบทอดคลาส A เดียวกัน

5. การสืบทอดแบบไฮบริด:

การสืบทอดแบบไฮบริดเป็นหนึ่งในประเภทการสืบทอดใน Java ซึ่งเป็นการผสมผสานระหว่างมรดกเดี่ยวและหลายมรดก

ตามตัวอย่างข้างต้น สมาชิกสาธารณะและสมาชิกที่ได้รับการคุ้มครองของคลาส A ทั้งหมดจะได้รับการสืบทอดไปยังคลาส D อันดับแรกผ่านคลาส B และอันดับที่สองผ่านคลาส C

หมายเหตุ Java ไม่รองรับการสืบทอดแบบไฮบริด/หลายรายการ

การรับมรดกใน Java ตัวอย่าง

นี่คือตัวอย่างมรดกใน Java:

class Doctor {
 void Doctor_Details() {
  System.out.println("Doctor Details...");
 }
}

class Surgeon extends Doctor {
 void Surgeon_Details() {
  System.out.println("Surgen Detail...");
 }
}

public class Hospital {
 public static void main(String args[]) {
  Surgeon s = new Surgeon();
  s.Doctor_Details();
  s.Surgeon_Details();
 }
}

ซุปเปอร์คีย์เวิร์ด

คำสำคัญ super คล้ายกับคำสำคัญ “this” คำสำคัญ super สามารถใช้เพื่อเข้าถึงข้อมูลสมาชิกหรือวิธีการใดๆ ของคลาสหลัก คำสำคัญ Super สามารถใช้ได้ที่ ตัวแปรวิธีการและระดับตัวสร้าง

ไวยากรณ์:

super.<method-name>();

ตรวจสอบด้วย: - คำหลักนี้ใน Java: คืออะไร & วิธีใช้กับตัวอย่าง

เรียนรู้การสืบทอดใน OOP พร้อมตัวอย่าง

พิจารณาใบสมัครธนาคารเดียวกันจาก ตัวอย่างก่อนหน้า

เราควรจะเปิดบัญชีสองประเภทที่แตกต่างกัน ประเภทหนึ่งสำหรับการออมและอีกประเภทหนึ่งสำหรับการตรวจสอบ (หรือที่เรียกว่ากระแสรายวัน)

ลองเปรียบเทียบและศึกษาว่าเราสามารถเข้าถึงการเขียนโค้ดจาก a มุมมองการเขียนโปรแกรมเชิงโครงสร้างและเชิงวัตถุ

วิธีการเชิงโครงสร้าง: ในการเขียนโปรแกรมเชิงโครงสร้าง เราจะสร้างฟังก์ชันสองฟังก์ชัน –

1. หนึ่งที่จะถอนตัว
2. และอีกอันสำหรับการฝากเงิน

เนื่องจากการทำงานของฟังก์ชันเหล่านี้ยังคงเหมือนเดิมในบัญชีต่างๆ

แนวทางของ OOP: ในขณะที่ใช้ OOP วิธีการเขียนโปรแกรม เราจะสร้างสองคลาส

• แต่ละอันมีฟังก์ชั่นการฝากและถอนเงิน
• นี่จะเป็นการทำงานพิเศษที่ซ้ำซ้อน

เปลี่ยนคำขอในซอฟต์แวร์

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

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

แนวทางของ OOP: เมื่อใช้วิธีการของ OOP คุณเพียงแค่ต้องเขียนคลาสใหม่ที่มีการใช้งานฟังก์ชันการถอนที่เป็นเอกลักษณ์ เราไม่เคยสัมผัสโค้ดที่ทดสอบแล้ว

คำขอเปลี่ยนแปลงอื่น

จะเกิดอะไรขึ้นหากข้อกำหนดมีการเปลี่ยนแปลงเพิ่มเติม ชอบที่จะเพิ่มบัญชีบัตรเครดิตที่มีข้อกำหนดการฝากเงินเฉพาะของตัวเอง.

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

แนวทางของ OOP: แต่ถ้าใช้แนวทางเชิงวัตถุ คุณก็แค่สร้างคลาสใหม่ที่มีการใช้งานวิธีการฝากเงินเฉพาะของตัวเอง (ไฮไลต์สีแดงในภาพด้านล่าง) ดังนั้นถึงแม้ว่าการเขียนโปรแกรมเชิงโครงสร้างจะดูเหมือนเป็นวิธีที่ง่ายในตอนแรก แต่การเขียนโปรแกรมเชิงวัตถุจะชนะในระยะยาว

ข้อดีของการสืบทอดใน OOP

แต่อาจมีคนแย้งว่าในทุกคลาส คุณมีโค้ดที่ซ้ำกัน

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

คำถามที่พบบ่อย