ความหลากหลายใน Java: แนวคิด ประเภท ลักษณะและตัวอย่าง
เผยแพร่แล้ว: 2022-04-18Javascript เป็นหนึ่งในภาษาการเขียนโปรแกรมเชิงวัตถุที่ได้รับความนิยมและใช้กันอย่างแพร่หลาย ร่วมกับ C#, PHP, Python, C++ เป็นต้น ซึ่งช่วยให้ผู้ใช้สามารถแสดงและจัดการกับแนวคิดในชีวิตจริงผ่านการเขียนโปรแกรม เนื่องจากทุกอย่างแสดงเป็นวัตถุ คุณสมบัติของ Java ในฐานะภาษาโปรแกรมมีหลายวิธีในการทำให้การพัฒนาซอฟต์แวร์ง่ายขึ้น โดยทำให้โค้ดมีไดนามิกมากขึ้นและทำให้การบำรุงรักษาง่ายขึ้น
ในบทความนี้ เราจะสำรวจ Java เป็นภาษาการเขียนโปรแกรมเชิงวัตถุ และทำความเข้าใจแนวคิดของการสืบทอด นามธรรม ความหลากหลาย และการห่อหุ้มข้อมูล เราจะพิจารณาประเภทของความหลากหลายใน Java ข้อดีและข้อเสียของมันด้วย
ภาพรวมของการเขียนโปรแกรมเชิงวัตถุ
ภาษาการเขียนโปรแกรมเชิงวัตถุ (OOP) หมายถึงภาษาคอมพิวเตอร์ที่ใช้แนวคิดของ 'วัตถุ' แบบเรียลไทม์ในการเข้ารหัส มีจุดมุ่งหมายเพื่อนำสิ่งที่เป็นนามธรรมของโลกไปปฏิบัติ เช่น การสืบทอด ความหลากหลาย การวนซ้ำ การแยกข้อมูล ฯลฯ ผ่านการเขียนโปรแกรม
มีแนวคิดพื้นฐานบางประการของการเขียนโปรแกรมเชิงวัตถุที่โปรแกรมเมอร์จำเป็นต้องทำความคุ้นเคย คำศัพท์ทางแนวคิดเหล่านี้จำเป็นสำหรับการเรียนรู้เกี่ยวกับคุณลักษณะพิเศษและเฉพาะของ OOP เช่น การห่อหุ้ม ความหลากหลาย ฯลฯ
1. คลาส
'คลาส' แสดงถึงชุดของคุณสมบัติและเมธอดที่ใช้กับ 'อ็อบเจ็กต์' ที่ระบุทั้งหมดภายในคลาส ออบเจ็กต์สามารถมีได้หลายประเภท เช่น จำนวนเต็ม อาร์เรย์ หรือสตริง เป็นต้น คลาสเป็นเหมือนต้นแบบที่กำหนดโดยผู้ใช้ ซึ่งสามารถสร้าง 'อ็อบเจ็กต์' ที่แตกต่างกันได้
2. วัตถุ
ออบเจ็กต์เป็นหน่วยพื้นฐานที่สุดของภาษา OOP ซึ่งแสดงถึงข้อมูลจริงในชีวิตจริง ออบเจ็กต์มีคุณสมบัติของคลาสที่ถูกเรียกใช้
3. วิธีการ
วิธีการคือชุดของคำสั่งที่เกี่ยวข้องกับหน้าที่ต่างๆ ที่รวมกันเพื่อทำงานเฉพาะ ส่งคืนผลลัพธ์หลังจากทำตามคำแนะนำที่กำหนดโดยผู้ใช้ นอกจากนี้ยังสามารถทำงานที่ไม่มีผลลัพธ์ได้ วิธีการอนุญาตให้โปรแกรมเมอร์ใช้รหัสซ้ำโดยไม่ต้องพิมพ์ซ้ำ Java ต้องการวิธีการทั้งหมดเพื่อให้อยู่ในคลาส ซึ่งแตกต่างจากภาษาเช่น C++, C หรือ Python
แนวคิด OOP
มีหลักการหลักสี่ประการของการเขียนโปรแกรมเชิงวัตถุ – Java แสดงคุณสมบัติเหล่านี้ทั้งหมด:
1. สิ่งที่เป็นนามธรรม
Data Abstraction เป็นคุณสมบัติของภาษา OOP ที่แสดงรายละเอียดที่จำเป็นในขณะที่เก็บรายละเอียดอื่นๆ ที่ไม่เกี่ยวข้องของวัตถุไม่ให้มองเห็นได้ต่อผู้ใช้ เช่น รหัสการใช้งาน คุณลักษณะนี้จะแสดงเฉพาะรายละเอียดที่จำเป็นและเกี่ยวข้องเท่านั้น ซึ่งช่วยให้นักพัฒนาทำการเปลี่ยนแปลงที่เหมาะสมกับฟังก์ชันการทำงานของชั้นเรียนได้อย่างรวดเร็ว
2. การห่อหุ้ม
การห่อหุ้มข้อมูลหมายถึงการห่อข้อมูลภายในหน่วย คุณสมบัติของภาษา OOP นี้ปกป้องข้อมูลที่ถูกห่อหุ้มจากฟังก์ชันและวิธีการอื่นๆ มันรวมรหัสและวิธีการที่ระบุเพื่อดำเนินการในหน่วยเอกพจน์จึงป้องกันไม่ให้ถูกจัดการหรือเข้าถึงโดยวิธีการภายนอก สิ่งนี้เรียกอีกอย่างว่าการซ่อนข้อมูล
3. มรดก
การสืบทอดเป็นคุณลักษณะที่สำคัญอีกอย่างหนึ่งของภาษา OOP ที่ช่วยให้คลาสสามารถสืบทอดคุณสมบัติจากคลาสอื่นได้ มันทำงานบนแนวคิดของการนำรหัสกลับมาใช้ใหม่ได้ ซึ่งจะช่วยลดความจำเป็นในการพิมพ์คุณสมบัติคลาสซ้ำๆ ซ้ำๆ คลาสที่สืบทอดมาจากคลาสอื่นเรียกว่าคลาสย่อยและคลาสที่สืบทอดนั้นเรียกว่าซูเปอร์คลาส
4. ความหลากหลาย
Polymorphism ช่วยให้วัตถุมีหลายรูปแบบและทำงานคล้ายคลึงกันหรือแสดงพฤติกรรมที่คล้ายคลึงกันในวิธีที่ต่างกัน
ความหลากหลายในภาษาชวา
Polymorphism ช่วยให้ทำงานชิ้นเดียวได้หลายวิธี เป็นคุณสมบัติที่ช่วยระบุและแยกความแตกต่างระหว่างเอนทิตีโค้ดที่คล้ายคลึงกัน ซึ่งจะช่วยเพิ่มประสิทธิภาพของภาษา OOP
ใน Java ความหลากหลายจะแสดงโดยการประกาศวัตถุเป็นเอนทิตีที่แยกจากกัน ในลักษณะนี้ การดำเนินการเดียวกันสามารถทำได้หลายวิธี ความหลากหลายถูกเปิดใช้งานพร้อมกับการสืบทอด ทำให้วัตถุสามารถทำงานที่แตกต่างกันโดยใช้คุณสมบัติที่สืบทอดมาจากคลาสต่างๆ ความแตกต่างในการกำหนดเมธอดหรืออ็อบเจ็กต์แยกความแตกต่างระหว่างสองเอนทิตี
เรียนรู้ หลักสูตรการพัฒนาซอฟต์แวร์ ออนไลน์จากมหาวิทยาลัยชั้นนำของโลก รับโปรแกรม Executive PG โปรแกรมประกาศนียบัตรขั้นสูง หรือโปรแกรมปริญญาโท เพื่อติดตามอาชีพของคุณอย่างรวดเร็ว
ลักษณะของความหลากหลาย
1. บังคับ
การแปลงชนิดข้อมูลโดยนัยเพื่อป้องกันข้อผิดพลาดของประเภทระหว่างเวลาคอมไพล์เป็นการบีบบังคับ ไม่รวมการแปลงประเภทข้อมูลที่ชัดเจน แต่เป็นไปตามลำดับชั้นของการแปลงที่ Java อนุญาตเท่านั้น ตัวอย่างเช่น ถ้าตัวถูกดำเนินการลอยอยู่และตัวดำเนินการเป็นจำนวนเต็ม ผลลัพธ์จะลอยอยู่
2. พารามิเตอร์/ตัวแปรพหุสัณฐาน
อ็อบเจ็กต์หรือตัวแปรที่สามารถเก็บค่าประเภทต่างๆ ระหว่างเวลาดำเนินการเรียกว่าตัวแปรหรือพารามิเตอร์ polymorphic มันกำหนดว่าในขณะที่ประกาศคลาส ชื่อตัวแปรเดียวกันสามารถเก็บประเภทข้อมูลที่แตกต่างกัน และชื่อเมธอดเดียวกันสามารถเก็บพารามิเตอร์และประเภทการส่งคืนที่แตกต่างกัน
3. โอเวอร์โหลดโอเปอเรเตอร์ภายใน
โอเวอร์โหลดตัวดำเนินการใช้สัญลักษณ์ตัวดำเนินการตามที่ผู้ใช้ต้องการ Java รองรับการโอเวอร์โหลดโอเปอเรเตอร์ภายใน นอกจากนี้ยังเป็นตัวอย่างของความหลากหลายคงที่
ประเภทของความหลากหลายในภาษาชวา
ใน Java สามารถใช้ polymorphism ได้โดยใช้:
1. วิธีการโอเวอร์โหลด
เมธอดโอเวอร์โหลดเป็นกระบวนการสร้างอ็อบเจ็กต์หรือเมธอดหลายรายการที่มีชื่อเดียวกันและเป็นของคลาสเดียวกัน มันทำงานภายในชั้นเรียน
2. วิธีการเอาชนะ
การแทนที่เมธอดเป็นวิธีที่คลาสย่อยประกอบขึ้นเป็นเมธอดเดียวกับที่ประกาศไว้ในซูเปอร์คลาส มันทำงานข้ามชั้นเรียน หากคลาสย่อยมีเมธอดเดียวกันที่มีอยู่แล้วในซูเปอร์คลาส ฟังก์ชันในคลาสย่อยจะถูกแทนที่
ชนิดย่อย Polymorphism ใน Java
ความแตกต่างของประเภทย่อยขึ้นอยู่กับ Upcasting และ Late Binding
- การอัปแคสต์เป็นกระบวนการที่อ็อบเจ็กต์หรือเมธอดสามารถส่งเสริมชนิดข้อมูล (แบบลอย จำนวนเต็ม เป็นต้น) จากประเภทย่อยไปเป็นซูเปอร์ไทป์โดยการย้ายขึ้นลำดับชั้นการสืบทอด
- การเชื่อมโยงล่าช้าใช้เพื่อเรียกใช้เมธอดที่ไม่ใช่อินสแตนซ์สุดท้าย
ไม่มีโอเปอเรเตอร์ที่เกี่ยวข้องในเรื่องนี้ เนื่องจากตัวชนิดย่อยเองเป็นสมาชิกของ supertype ตัวอย่างเช่น ถ้าคลาสถูกตั้งชื่อว่าสี ชนิดย่อยของคลาสนั้นอาจเป็นสีแดง น้ำเงิน ส้ม เขียว ฯลฯ ความหลากหลายของประเภทย่อยรวมถึงประเภทย่อยเพื่อแสดงคุณสมบัติของซูเปอร์ไทป์ อย่างไรก็ตาม การเข้าถึงคุณสมบัติส่วนบุคคลของแต่ละประเภทย่อยจะสูญหายไป
Runtime Polymorphism ใน Java
ใน Java ความหลากหลายรันไทม์เรียกอีกอย่างว่า Dynamic Method Dispatch หรือ Dynamic Binding ทำได้ผ่านการแทนที่เมธอด - การเรียกเมธอดที่ถูกแทนที่เพื่อให้มีการแก้ไขแบบไดนามิกที่รันไทม์ สามารถทำได้ผ่านฟังก์ชันและไม่ใช่วัตถุ
นี่คือตัวอย่างความแตกต่างของรันไทม์ใน Java:
รถคลาส{
ถือเป็นโมฆะ run(){System.out.println("driving");}
}
คลาสโฟล์คสวาเกนขยายรถยนต์{
โมฆะ run(){System.out.println("ขับขี่ปลอดภัยด้วยระยะทาง 90 กม.");}
โมฆะคงที่สาธารณะหลัก (สตริง args[]){
รถ c = ใหม่ Volkswagen();//upcasting
b.run();
}
}
เอาท์พุต :
ขับขี่ปลอดภัยด้วยระยะทาง90km
รวบรวมความแตกต่างของเวลาใน Java
ความแตกต่างของเวลาคอมไพล์ทำได้โดยวิธีการโอเวอร์โหลด เป็นกระบวนการที่เรียกใช้เมธอดโอเวอร์โหลดและแก้ไขระหว่างเวลาคอมไพล์ เป็นที่รู้จักกันว่าพหุสัณฐานแบบคงที่ Java มีความยืดหยุ่นเพียงพอที่จะอนุญาตให้ผู้ใช้ใช้เมธอดหรืออ็อบเจ็กต์ที่มีชื่อเหมือนกัน ตราบใดที่การประกาศและคุณสมบัติลายเซ็นยังคงแตกต่างกัน
นี่คือตัวอย่างความแตกต่างของเวลาคอมไพล์ใน Java:
คลาส SimpleCalc
{
int เพิ่ม (int x, int y)
{
ผลตอบแทน x+y;
}
int เพิ่ม (int x, int y, int z)
{
ส่งคืน x+y+z;
}
}
สาธิตคลาสสาธารณะ
{
โมฆะคงที่สาธารณะหลัก (สตริง args[])
{
SimpleCalc obj = SimpleCalc ใหม่ ();
System.out.println(obj.add(20, 30));
System.out.println(obj.add(40, 30, 20));
}
}
เอาท์พุต :
50
90
ความสำคัญของความหลากหลาย
ความหลากหลายทำให้สามารถเขียนวิธีการที่สามารถสร้างเอนทิตีประเภทต่างๆ ที่มีชื่อเดียวกันได้ ความหลากหลายเป็นสิ่งสำคัญใน Java เนื่องจากมีประโยชน์ในการใช้งานที่หลากหลายและขอบเขตที่มีให้สำหรับการทำให้โค้ดเป็นไดนามิก:
- อนุญาตให้ใช้รหัสซ้ำได้ โดยไม่จำเป็นต้องเขียนรหัสเดียวกันหลายครั้ง
- อนุญาตให้ตัวแปรตัวหนึ่งแสดงพฤติกรรมได้หลากหลาย – มีชื่อเดียวกันแต่คุณสมบัติที่แตกต่างกันสามารถเปิดขอบเขตสำหรับการรักษาความสอดคล้องในรหัส
- การลดโค้ดจำนวนมาก - ช่วยในการดีบักในขณะเดียวกันก็ย่นระยะเวลาคอมไพล์ให้สั้นลง ช่วยประหยัดหน่วยความจำ พลังงาน และเวลาของผู้ใช้
ปัญหาที่เป็นไปได้ในการใช้ Polymorphism
ความหลากหลายอาจสร้างความสับสนในการใช้งานและนำไปใช้ มันลดความสามารถในการอ่านรหัส ดังนั้นจึงเป็นภัยคุกคามต่อจุดบกพร่องและข้อผิดพลาดหลายรายการ ยังสร้างปัญหาในการปฏิบัติหน้าที่ตามต้องการ
มีปัญหาคลาสสิกที่ต้องระวัง: ปัญหาคลาสฐานที่เปราะบาง หมายถึงการประกอบและการเข้ารหัสที่ไม่เหมาะสมของคลาสที่สืบทอดมาซึ่งส่งผลให้วิธีการแสดงผลลัพธ์ที่คาดเดาไม่ได้
บทสรุป
ลักษณะที่เปราะบางของมรดกสามารถนำไปสู่รหัสที่ไม่สมบูรณ์และใช้งานไม่ได้ แม้จะปฏิบัติตามเกณฑ์อื่นๆ ทั้งหมดแล้วก็ตาม ปัญหาสถาปัตยกรรมพื้นฐานนี้ถือเป็นปัญหาระดับฐานที่เปราะบาง เรียนรู้เพิ่มเติมเกี่ยวกับวิธีที่ Java จัดแสดงแนวคิด OOP โดยการเข้าร่วมโปรแกรม Executive PG ของ upGrad ในการพัฒนาซอฟต์แวร์ – ความเชี่ยวชาญพิเศษในการพัฒนาแบบเต็มสแต็ ค รับคำปรึกษาจากผู้เชี่ยวชาญในอุตสาหกรรมและสร้างความรู้เชิงปฏิบัติโดยมีส่วนร่วมในโครงการที่ทำงานร่วมกันจริงกับเพื่อนร่วมงาน
สำรองที่นั่งได้แล้ววันนี้!
การเชื่อมโยงแบบสแตติกและไดนามิกคืออะไร
อ็อบเจ็กต์ที่กำหนดในขณะที่คอมไพล์เรียกว่า การรวมแบบสแตติก ในทางกลับกัน ประเภทของอ็อบเจ็กต์ไดนามิกการโยงจะถูกกำหนด ณ รันไทม์ แบบแรกใช้ในระหว่างการโอเวอร์โหลดเมธอดและแบบหลังในระหว่างการแทนที่เมธอด
อะไรคือความแตกต่างพื้นฐานสองประการระหว่างการแทนที่เมธอดและการโอเวอร์โหลดเมธอด
ใน Java การแทนที่เมธอดจะไม่แทนที่เมธอดสแตติก ไพรเวต และขั้นสุดท้าย ในขณะที่เมธอดโอเวอร์โหลดจะโอเวอร์โหลดเมธอดสแตติก ไพรเวต และเมธอดสุดท้ายใน Java นอกจากนี้ การแทนที่เมธอดของ subject ในการรวมไดนามิก และในทางกลับกัน เมธอดที่โอเวอร์โหลดต้องผ่านการโยงแบบสแตติก
ความแตกต่างระหว่างความแตกต่างและการสืบทอดใน Java คืออะไร?
ใน Java มีความแตกต่างหลายจุดระหว่าง Polymorphism และ Inheritance:
1. การสืบทอดเป็นตัวแทนของความสัมพันธ์ระหว่างพ่อแม่และลูกในโลกแห่งความเป็นจริงในการเข้ารหัส แต่ความหลากหลายคือตัวเร่งปฏิกิริยาที่ใช้ความสัมพันธ์นี้เพื่อทำให้โปรแกรมมีไดนามิกมากขึ้น
2. การสืบทอดช่วยให้สามารถนำรหัสกลับมาใช้ใหม่ได้จากคลาสย่อยโดยสืบทอดรหัสเดียวกันจากคลาสหลัก ในทางกลับกัน ความหลากหลายทำให้คลาสลูกสามารถกำหนดพฤติกรรมที่มีอยู่ใหม่ได้อีกครั้งภายในคลาสพาเรนต์