ประเภทของมรดกใน Java พร้อมตัวอย่าง

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

ความสำคัญของมรดก

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

ลำดับชั้นการสืบทอดแสดงถึงความสัมพันธ์ระหว่างพ่อแม่และลูกระหว่างระดับการสืบทอดที่แตกต่างกัน ระดับสูงสุดของการสืบทอดเรียกว่า “Super Class” หรือ “Parent Class”

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

ไวยากรณ์ของ Java Inheritance

คลาส Subclass-name ขยาย Superclass-name

{

//เมธอดและฟิลด์

}

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

ตัวอย่าง: ในตัวอย่างด้านล่างของการสืบทอด คลาส Bicycle เป็นคลาสพื้นฐาน คลาส MountainBike เป็นคลาสที่ได้รับซึ่งขยายคลาส Bicycle และคลาส Test เป็นคลาสไดรเวอร์เพื่อเรียกใช้โปรแกรม

ป้อนข้อมูล:

// โปรแกรม Java เพื่อแสดง

// แนวคิดเรื่องมรดก

// คลาสพื้นฐาน

คลาสจักรยาน {

// คลาสจักรยานมีสองสนาม

เกียร์สาธารณะ

ความเร็ว int สาธารณะ;

// คลาสจักรยานมีคอนสตรัคเตอร์หนึ่งตัว

รถจักรยานสาธารณะ (int gear, int speed)

{

this.gear = เกียร์;

this.speed = ความเร็ว;

}

// คลาสจักรยานมีสามวิธี

โมฆะสาธารณะ applyBrake (ลดลง int)

{

ความเร็ว -= ลดลง;

}

โมฆะสาธารณะ speedUp (เพิ่มขึ้น int)

{

ความเร็ว += เพิ่มขึ้น;

}

// toString() วิธีการพิมพ์ข้อมูลของ Bicycle

สตริงสาธารณะ toString()

{

กลับ (“ไม่มีเกียร์ ” + เกียร์ + “\n”

+ “ความเร็วของจักรยานคือ ” + ความเร็ว);

}

}

// คลาสที่ได้รับ

คลาส MountainBike ขยายจักรยาน {

// คลาสย่อย MountainBike เพิ่มอีกหนึ่งฟิลด์

ที่นั่ง int สาธารณะความสูง;

// คลาสย่อย MountainBike มีตัวสร้างหนึ่งตัว

MountainBike สาธารณะ (เกียร์ int, ความเร็ว int,

int startHeight)

{

// เรียกใช้ตัวสร้างคลาสฐาน (จักรยาน)

ซุปเปอร์(เกียร์, ความเร็ว);

seatHeight = startHeight;

}

// คลาสย่อย MountainBike เพิ่มเมธอดอีกวิธีหนึ่ง

โมฆะสาธารณะ setHeight (int newValue)

{

seatHeight = ใหม่ค่า;

}

// แทนที่ toString() method

// ของจักรยานเพื่อพิมพ์ข้อมูลเพิ่มเติม

@Override สตริงสาธารณะ toString()

{

return (super.toString() + “\nความสูงของที่นั่งคือ “

+ ความสูงที่นั่ง);

}

}

//ชั้นคนขับ

การทดสอบระดับสาธารณะ {

โมฆะคงที่สาธารณะหลัก (สตริง args[])

{

MountainBike mb = MountainBike ใหม่ (3, 100, 25);

System.out.println(mb.toString());

}

}

เอาท์พุต :

จำนวนเกียร์ 3

ความเร็วของจักรยานคือ 100

ความสูงที่นั่ง 25

ข้อกำหนดที่ใช้ในมรดก

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

หลักสูตรและบทความยอดนิยมเกี่ยวกับวิศวกรรมซอฟต์แวร์

ประเภทของมรดก Java

1. มรดกเดี่ยว

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

อ้างถึงตัวอย่างด้านล่าง:

ป้อนข้อมูล:

// โปรแกรม Java เพื่อแสดง

// แนวคิดของการสืบทอดเดี่ยว

นำเข้า java.io.*;

นำเข้า java.lang.*;

นำเข้า java.util.*;

ชั้นหนึ่ง {

โมฆะสาธารณะ print_A()

{

System.out.println("A");

}

}

คลาสที่สองขยายหนึ่ง {

โมฆะสาธารณะ print_for() { System.out.println("for"); }

}

//ชั้นคนขับ

คลาสสาธารณะหลัก {

โมฆะคงที่สาธารณะ main(String[] args)

{

สอง g = ใหม่ สอง ();

g.print_A();

g.print_for();

g.print_Apple();

}

}

เอาท์พุต :

อา

สำหรับ

แอปเปิล

2. มรดกหลายระดับ

มรดกหลายระดับคือมรดกที่มีลูกโซ่ n ใน Java คลาสที่ได้รับไม่สามารถเข้าถึงสมาชิกของปู่ย่าตายายได้โดยตรง เมื่อคุณมีลำดับชั้นการสืบทอดเช่นนี้ ซึ่งแต่ละระดับใหม่จะสืบทอดจากบุคคลหรือสิ่งของอื่นก่อนหน้านั้น (หรือในทางกลับกัน) วัตถุใดก็ตามในกลุ่มใดกลุ่มหนึ่งจะกลายเป็นเรื่องยาก เนื่องจากพวกเขาสามารถใช้สิ่งที่มีได้เฉพาะของตนเองเท่านั้น ระดับ; จึงทำให้การดีบักน่าเบื่อเกินความจำเป็น!

ป้อนข้อมูล:

// โปรแกรม Java เพื่อแสดง

// แนวคิดของการสืบทอดหลายระดับ

นำเข้า java.io.*;

นำเข้า java.lang.*;

นำเข้า java.util.*;

ชั้นหนึ่ง {

โมฆะสาธารณะ print_Inheritance()

{

System.out.println("มรดก");

}

}

คลาสที่สองขยายหนึ่ง {

โมฆะสาธารณะ print_in () { System.out.println ("ใน"); }

}

ชั้นสามขยายสอง {

โมฆะสาธารณะ print_Inheritance()

{

System.out.println("จาวา");

}

}

// คลาสที่ได้รับ

คลาสสาธารณะหลัก {

โมฆะคงที่สาธารณะ main(String[] args)

{

สาม g = ใหม่ สาม ();

g.print_Inheritance();

g.print_in();

g.print_Java();

}

}

เอาท์พุต :

มรดก

ใน

Java

3. การสืบทอดตามลำดับชั้น

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

ป้อนข้อมูล:

สัตว์ประจำชั้น{

ถือเป็นโมฆะกิน(){System.out.println("กิน...");}

}

คลาส สุนัข ขยาย สัตว์{

เปลือกเป็นโมฆะ(){System.out.println("เห่า…”);}

}

คลาส Cat ขยายสัตว์{

โมฆะ meow(){System.out.println("meowing...");}

}

คลาส TestInheritance3{

โมฆะคงที่สาธารณะหลัก (สตริง args[]){

แมว c = แมวใหม่ ();

c.meow();

ค.กิน();

//c.bark();//CTError

}}

เอาท์พุต :

เหมียว…

การกิน…

4. การสืบทอดหลายรายการ (ผ่านอินเทอร์เฟซ)

Java ไม่สนับสนุนการสืบทอดหลายรายการกับคลาส แต่สามารถบรรลุได้ผ่านอินเทอร์เฟซ ในภาพด้านล่างคลาส C มาจากทั้ง A และ B ซึ่งหมายความว่าพวกเขาแบ่งปันคุณสมบัติบางอย่างในขณะที่มีการใช้งานที่แตกต่างกันสำหรับผู้อื่นขึ้นอยู่กับความต้องการเฉพาะของพวกเขาในการเรียกใช้โค้ดหรือการปฏิบัติตามวิธีการที่ผู้ใช้ต้องการ (i)

ป้อนข้อมูล:

// โปรแกรม Java เพื่อแสดง

// แนวคิดของการสืบทอดหลายรายการ

นำเข้า java.io.*;

นำเข้า java.lang.*;

นำเข้า java.util.*;

อินเทอร์เฟซหนึ่ง {

โมฆะสาธารณะ print_eye();

}

อินเทอร์เฟซที่สอง {

โมฆะสาธารณะ print_for();

}

อินเทอร์เฟซสามขยายหนึ่งสอง {

โมฆะสาธารณะ print_eye();

}

เด็กคลาสดำเนินการสาม {

@แทนที่โมฆะสาธารณะ print_eye()

{

System.out.println("ตา");

}

โมฆะสาธารณะ print_for() { System.out.println("for"); }

}

// คลาสที่ได้รับ

คลาสสาธารณะหลัก {

โมฆะคงที่สาธารณะ main(String[] args)

{

ลูก c = ลูกใหม่ ();

c.print_eye();

c.print_for();

c.print_eye();

}

}

เอาท์พุต :

ดวงตา

สำหรับ

ดวงตา

5. มรดกไฮบริด (ผ่านอินเทอร์เฟซ)

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

ป้อนข้อมูล

(อ้างอิง)

คลาส A และ B ขยายคลาส C → การสืบทอดตามลำดับชั้น

คลาส D ขยายคลาส A → การสืบทอดเดี่ยว

คลาส C

{

โมฆะสาธารณะ disp()

{

System.out.println(“C”);

}

}

คลาส A ขยาย C

{

โมฆะสาธารณะ disp()

{

System.out.println("A");

}

}

คลาส B ขยาย C

{

โมฆะสาธารณะ disp()

{

System.out.println("B");

}

}

คลาส D ขยาย A

{

โมฆะสาธารณะ disp()

{

System.out.println("D");

}

โมฆะคงที่สาธารณะหลัก (สตริง args[]){

D obj = ใหม่ D();

obj.disp();

}

}

เอาท์พุท:

ดี

หากคุณต้องการเรียนรู้เชิงลึกเกี่ยวกับการสืบทอดใน Java และแนวคิด OOP อื่นๆ เราขอแนะนำ Executive PG Program ของ upGrad ใน การพัฒนาซอฟต์แวร์จาก IIIT-Bangalore หลักสูตร 13 เดือนได้รับการออกแบบโดยผู้เชี่ยวชาญและคณาจารย์ในอุตสาหกรรมระดับโลกเพื่อสร้างความสามารถในเครื่องมือและซอฟต์แวร์มากกว่า 30 รายการ ประกอบด้วยเนื้อหามากกว่า 400 ชั่วโมง กรณีศึกษาและโครงการที่เกี่ยวข้องกับอุตสาหกรรมมากกว่า 30 รายการ และเซสชันสดมากกว่า 10 รายการเพื่อช่วยให้คุณบรรลุผลตามที่ต้องการ หลักสูตรนี้นำเสนอความเชี่ยวชาญพิเศษสามอย่าง ได้แก่ การพัฒนาฟูลสแตก การพัฒนาแบ็คเอนด์บนคลาวด์ และความปลอดภัยทางไซเบอร์

สำรองที่นั่งในโปรแกรมวันนี้!