สำรวจการสืบทอดในภาษาการเขียนโปรแกรม Java

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

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

---

---

เปิดหรือปิดการเร่งฮาร์ดแวร์ด้วยฮาร์ดแวร์

มรดกทำงานอย่างไร

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

ตัวอย่างในโลกแห่งความเป็นจริงว่าการถ่ายทอดมรดกจะพิจารณาผลอย่างไร นี่คือป้ายกำกับแบบกว้างที่ทำหน้าที่ห่อหุ้มรายการต่างๆ

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

นั่นคือวิธีการทำงานของมรดก

การใช้การสืบทอดใน Java

การสืบทอดสามารถใช้ในภาษาการเขียนโปรแกรมใดๆ ก็ตามที่ใช้กระบวนทัศน์การเขียนโปรแกรมเชิงวัตถุ อย่างไรก็ตาม วิธีที่แน่นอนในการใช้การสืบทอดนั้นขึ้นอยู่กับภาษาโปรแกรมเฉพาะ

---

---

ตัวอย่างเช่น, C ++ เป็นภาษาการเขียนโปรแกรมเชิงวัตถุด้วย . C ++ รองรับสิ่งที่เรียกว่าการสืบทอดหลายรายการในขณะที่ Java รองรับการสืบทอดเดียวเท่านั้น

สิ่งนี้หมายความว่าใน Java คลาสพาเรนต์สามารถมีคลาสย่อยได้หลายคลาส แต่คลาสย่อยแต่ละคลาสสามารถมีคลาสพาเรนต์เดียวเท่านั้น (การสืบทอดเดี่ยว) อย่างไรก็ตาม มีวิธีการที่จะได้รับมรดกหลายทางโดยอ้อมใน Java โดยการสร้างความสัมพันธ์แบบปู่ย่าตายาย พ่อแม่ และลูก

---

---

การสร้างคลาสพาเรนต์ใน Java

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

ตัวอย่างคลาสผู้ปกครองผลไม้


public class Fruit {
//Variable Declaration
protected String seed;
protected String skinColor;
protected String taste;
//Default Constructor
public Fruit(){
seed = '';
skinColor ='';
taste ='';
}
//Primary Constructor
public Fruit(String seed, String skinColor, String taste){
this.seed = seed;
this.skinColor = skinColor;
this.taste = taste;
}
//getters and setters
public String getSeed() {
return seed;
}
public void setSeed(String seed) {
this.seed = seed;
}
public String getSkinColor() {
return skinColor;
}
public void setSkinColor(String skinColor) {
this.skinColor = skinColor;
}
public String getTaste() {
return taste;
}
public void setTaste(String taste) {
this.taste = taste;
}
//eat method
public void eat(){
//general code on how to eat a fruit
}
//juice method
public void juice() {
//general code on how to juice a fruit
}
}

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

ต่อไปในโค้ด คุณจะได้รู้จักกับคอนสตรัคเตอร์, getters และ setters ซึ่งเป็นบล็อคการสร้างทั่วไปสำหรับคลาส Java ใดๆ สุดท้ายนี้ คุณจะได้รู้จักกับสองวิธี (น้ำผลไม้และการกิน) ที่สร้างขึ้นในคลาสหลักของโปรแกรมของเรา เนื่องจากเป็นวิธีการสากลสำหรับผลไม้ทุกชนิด ผลไม้ทุกชนิดสามารถรับประทานและคั้นน้ำผลไม้ได้

การสร้างคลาสลูกใน Java

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

ต่อจากตัวอย่างของเรา คุณน่าจะเข้าใจได้ว่าทำไมส้มถึงเป็นคลาสเด็กที่เหมาะสมกับคลาสผลไม้ด้านบน

ตัวอย่างคลาสเด็กสีส้ม


public class Orange extends Fruit{
//variable declaration
private int supremes;
//default constructor
public Orange() {
supremes = 0;
}
//primary constructor
public Orange(String seed, String skinColor, String taste, int supremes){
super(seed, skinColor, taste);
this.supremes = supremes;
}
//getters and setters
public int getsupremes() {
return supremes;
}
public void setsupremes(int supremes) {
this.supremes = supremes;
}
//eat method
public void eat(){
//how to eat an orange
}
//juice method
public void juice() {
//how to juice and orange
}
//peel method
public void peel(){
//how to peel an orange
}
}

มีความแตกต่างระหว่างการประกาศคลาส Java ปกติและสิ่งที่เรามีในโค้ดด้านบน คีย์เวิร์ดขยายคือสิ่งที่ใช้ใน Java เพื่อให้การสืบทอดเป็นไปได้

ในตัวอย่างของเราเหนือคลาสลูก (สีส้ม) ขยายคลาสพาเรนต์ (ผลไม้) ดังนั้นสถานะและพฤติกรรมของคลาสผลไม้จึงสามารถเข้าถึงและแก้ไขโดยคลาสสีส้ม

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

การเพิ่มวิธีการปอกเปลือกลงในวิธีการกินและน้ำผลไม้ที่มีอยู่แล้วนั้นก็สมเหตุสมผลเช่นกัน เพราะถึงแม้จะไม่สามารถปอกผลไม้ได้ทั้งหมด แต่ส้มก็มักจะปอกอยู่เสมอ

คุณควรจำไว้ว่าหากเราไม่ได้ตั้งใจจะเปลี่ยนแปลงวิธีการกินและน้ำผลไม้ที่มีอยู่ เราก็ไม่จำเป็นต้องรวมวิธีการกินและน้ำผลไม้ไว้ในชั้นเรียนสีส้มของเรา เมธอดในคลาสสีส้มจะแทนที่เมธอดที่คล้ายกันในคลาสผลไม้ ดังนั้นถ้าผลไม้ทั้งหมดถูกกินและคั้นด้วยวิธีเดียวกัน เราก็ไม่จำเป็นต้องสร้างวิธีการเหล่านี้ในคลาสสีส้ม

ตัวสร้างบทบาทมีบทบาทในการสืบทอด

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

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

เบื้องหลัง เมื่อสร้างอ็อบเจ็กต์คลาสลูก คอนสตรัคเตอร์ของคลาสพาเรนต์จะถูกเรียกก่อน ตามด้วยคอนสตรัคเตอร์ของคลาสย่อย ในคลาสย่อยสีส้มของเราด้านบน หากวัตถุสีส้มถูกสร้างขึ้นโดยไม่มีพารามิเตอร์ใด ๆ ตัวสร้างคลาสผลไม้เริ่มต้นของเราจะถูกเรียก ตามด้วยผู้รับเหมาคลาสสีส้มเริ่มต้นของเรา

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

ตอนนี้คุณสามารถใช้การสืบทอดใน Java

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

เครดิตภาพ: Andreas Wohlfahrt / Pexels

แบ่งปัน แบ่งปัน ทวีต อีเมล วิธีจัดระเบียบรหัสเชิงวัตถุของคุณด้วยมรดก

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

อ่านต่อไป หัวข้อที่เกี่ยวข้อง

• การเขียนโปรแกรม
• Java
• การเขียนโปรแกรมเชิงวัตถุ

เกี่ยวกับผู้เขียน คาเดชา คีน(21 บทความที่ตีพิมพ์)

Kadeisha Kean เป็นนักพัฒนาซอฟต์แวร์ฟูลสแตกและนักเขียนด้านเทคนิค/เทคโนโลยี เธอมีความสามารถที่ชัดเจนในการทำให้แนวคิดทางเทคโนโลยีที่ซับซ้อนที่สุดบางส่วนง่ายขึ้น การผลิตวัสดุที่สามารถเข้าใจได้ง่ายโดยสามเณรเทคโนโลยี เธอหลงใหลในการเขียน พัฒนาซอฟต์แวร์ที่น่าสนใจ และเดินทางไปทั่วโลก (ผ่านสารคดี)

เพิ่มเติมจาก Kadeisha Kean

สมัครรับจดหมายข่าวของเรา

เข้าร่วมจดหมายข่าวของเราสำหรับเคล็ดลับทางเทคนิค บทวิจารณ์ eBook ฟรี และดีลพิเศษ!

คลิกที่นี่เพื่อสมัครสมาชิก