ความแตกต่างและการผูกแบบไดนามิกใน Java
ที่มา: DZone Polymorphism เป็นหนึ่งในแนวคิดหลักของการเขียนโปรแกรมเชิงวัตถุ ไม่ว่าคุณจะเพิ่งเริ่มใช้โปรแกรม Java หรือเป็น Developer ที่มีประสบการณ์ คุณควรรู้ว่า Polymorphism คืออะไรและทำงานอย่างไร นักพัฒนาส่วนใหญ่อ้างว่ามีความเชี่ยวชาญในหัวข้อนี้เป็นอย่างดี แต่เมื่อพูดถึงคุณสมบัติที่ซับซ้อนอื่นๆ เช่น การเชื่อมโยงแบบคงที่และไดนามิก หลายคนสูญเสียความมั่นใจ
ความแตกต่างใน Java คืออะไร?
Polymorphism หมายถึง การมีหลายรูปแบบ ในการเขียนโปรแกรม หมายถึงความสามารถของสัญญาณหรือข้อความที่จะปรากฏในรูปแบบมากกว่าหนึ่งรูปแบบตัวอย่างชีวิตจริง
บุคคลสามารถแสดงคุณลักษณะได้หลายอย่างในเวลาเดียวกัน ตัวอย่างเช่น แม่สามารถเป็นภรรยา ลูกสาว น้องสาว พนักงานบริษัท และอื่นๆ ไปพร้อมๆ กันได้ ดังนั้นบุคคลอาจแสดงลักษณะที่แตกต่างกันภายใต้เงื่อนไขที่ต่างกัน สิ่งนี้เรียกว่าความหลากหลายความสำคัญของความหลากหลาย
Polymorphism เป็นหนึ่งในคุณสมบัติที่สำคัญที่สุดของภาษาการเขียนโปรแกรมเชิงวัตถุ (เช่น Java) ด้วยความช่วยเหลือของความหลากหลายทำให้งานเดียวกันสามารถดำเนินการได้หลายวิธีประเภทของความหลากหลาย
ในภาษา Java นั้น polymorphism แบ่งได้เป็น 2 ประเภท คือ- ความหลากหลายเวลาคอมไพล์ (การเชื่อมโยงแบบคงที่)
- ความหลากหลายแบบรันไทม์ (รันไทม์, การเชื่อมโยงแบบไดนามิก)
พหุสัณฐานเวลาคอมไพล์
ความหลากหลายเวลาคอมไพล์เรียกอีกอย่างว่าการเชื่อมโยงแบบคงที่ ความหลากหลายประเภทนี้สามารถทำได้ผ่านการโอเวอร์โหลดของฟังก์ชันหรือการโอเวอร์โหลดของผู้ปฏิบัติงาน แต่ใน Java สิ่งนี้จำกัดอยู่ที่ฟังก์ชันโอเวอร์โหลด เนื่องจาก Java ไม่รองรับโอเปอเรเตอร์โอเวอร์โหลด ฟังก์ชั่นโอเวอร์โหลด เมื่อมีอย่างน้อยสองฟังก์ชันหรือเมธอดที่มีชื่อฟังก์ชันเหมือนกัน แต่จำนวนพารามิเตอร์ที่มีอยู่แตกต่างกัน หรืออย่างน้อยหนึ่งประเภทข้อมูลของพารามิเตอร์ที่เกี่ยวข้องแตกต่างกัน (หรือทั้งสองอย่าง) จะเรียกว่าฟังก์ชัน หรือวิธีการโอเวอร์โหลด และฟังก์ชันเหล่านี้เรียกว่าฟังก์ชันโอเวอร์โหลด ตัวอย่างที่ 1 จนถึงตอนนี้เราได้ศึกษาแล้วว่าฟังก์ชันโอเวอร์โหลดคืออะไร ตอนนี้เรามาลองสาธิตการทำงานของซอฟต์แวร์ที่โอเวอร์โหลดกันclass Main {
// Method 1
// Method with 2 integer parameters
static int Addition(int a, int b)
{
// Returns sum of integer numbers
return a + b;
}
// Method 2
// having the same name but with 2 double parameters
static double Addition(double a, double b)
{
// Returns sum of double numbers
return a + b;
}
public static void main(String args[]) {
// Calling method by passing
// input as in arguments
System.out.println(Addition(12, 14));
System.out.println(Addition(15.2, 16.1));
}
}
-
โปรแกรมด้านบนประกอบด้วยฟังก์ชันคงที่สองฟังก์ชันที่มีชื่อเดียวกัน: นอกจากนี้
-
ที่นี่ ฟังก์ชันทั้งสองมีจำนวนพารามิเตอร์เท่ากัน แต่พารามิเตอร์ที่เกี่ยวข้องต่างกัน
-
วิธีที่ 1ยอมรับพารามิเตอร์จำนวนเต็มสองตัว ในขณะที่วิธีที่ 2 ยอมรับ พารามิเตอร์คู่สองตัว
-
จากฟังก์ชันหลัก ก่อนอื่นเราจะเรียกฟังก์ชันAddition(12, 14) พารามิเตอร์ที่ส่งเป็นจำนวนเต็ม (12 และ 14) ดังนั้นวิธีที่ 1จะถูกเรียกที่นี่
-
จากนั้นเราเรียก ฟังก์ชัน Addition(15.2, 16.1 ) เนื่องจากพารามิเตอร์ที่ส่งผ่านเป็น ประเภท ข้อมูลคู่ (15.2 และ 16.1) คราวนี้จึงจะเรียกวิธีที่ 2
-
นี่คือวิธีการทำให้ฟังก์ชันโอเวอร์โหลดสำเร็จใน Java โดยอิงตามประเภทข้อมูลพารามิเตอร์ที่แตกต่างกัน
class Main {
// Method 1
// Method with 2 integer parameters
static int Addition(int a, int b)
{
// Returns sum of integer numbers
return a + b;
}
// Method 2
// having the same name but with 3 integer parameters
static double Addition(double a, double b)
{
// Returns sum of integer numbers
return a + b;
}
public static void main(String args[]) {
// Calling method by passing
// input as in arguments
System.out.println(Addition(12, 14));
System.out.println(Addition(15.2, 16.1));
}
}-
โปรแกรมด้านบนประกอบด้วยฟังก์ชันคงที่สองฟังก์ชันที่มีชื่อเดียวกัน: นอกจากนี้
-
ที่นี่ ฟังก์ชันทั้งสองมีจำนวนพารามิเตอร์ต่างกัน แต่ชนิดข้อมูลของพารามิเตอร์สองตัวแรกที่สอดคล้องกันจะเหมือนกัน (จำนวนเต็ม)
-
วิธีที่ 1รับพารามิเตอร์จำนวนเต็มสองตัว และวิธีที่ 2รับพารามิเตอร์ชนิดข้อมูลจำนวนเต็มสามตัว
-
จากฟังก์ชันหลัก ก่อนอื่นเราจะเรียกฟังก์ชันAddition(2, 3) เนื่องจากพารามิเตอร์ที่ส่งเป็นจำนวนเต็ม (2 และ 3) พวกเขาจะเรียกวิธีที่ 1 ที่ นี่
-
จากนั้นเราเรียก ฟังก์ชัน Addition(4, 5, 6 ) พารามิเตอร์ที่ส่งผ่านเป็น ประเภท ข้อมูลคู่ (4, 5, 6) ดังนั้นพวกเขาจะเรียก วิธีที่ 2ในครั้งนี้
-
นี่คือวิธีที่ฟังก์ชันโอเวอร์โหลดใน Java โดยอิงตามจำนวนพารามิเตอร์ที่แตกต่างกัน
class Main {
// Method 1
// Method with 2 integer parameters
static int Addition(int a, int b)
{
// Return the sum
return a + b;
}
// Method 2
// having the same name but with 3 parameters
// 1st parameter is of type double and other parameters
// are of type integer
static double Addition(double a, int b, int c)
{
// Return the sum
return a + b + c;
}
public static void main(String args[]) {
// Calling method by passing
// input as in arguments
System.out.println(Addition(2, 4));
System.out.println(Addition(4.2, 6, 10));
}
}-
โปรแกรมด้านบนประกอบด้วยฟังก์ชันคงที่สองฟังก์ชันที่มีชื่อเดียวกัน: นอกจากนี้
-
ฟังก์ชันทั้งสองมีจำนวนพารามิเตอร์ต่างกัน และประเภทข้อมูลขององค์ประกอบแรกที่เกี่ยวข้องก็แตกต่างกันเช่นกัน
-
วิธีที่ 1รับพารามิเตอร์จำนวนเต็มสองตัว ในขณะที่วิธีที่ 2รับพารามิเตอร์สามตัว ตัวแรกเป็นชนิดdouble และอีกสองชนิดเป็นชนิดข้อมูลจำนวนเต็ม
-
จากฟังก์ชันหลัก ก่อนอื่นเราจะเรียกฟังก์ชันAddition(2, 4) เนื่องจากพารามิเตอร์ที่ส่งเป็นจำนวนเต็ม (2 และ 4) พวกเขาจะเรียกวิธีที่ 1 ที่ นี่
-
จากนั้นเราเรียก ฟังก์ชัน Addition(4.2, 6, 10 ) พารามิเตอร์แรกที่ ส่งผ่านเป็นประเภทจำนวนเต็มและพารามิเตอร์ที่เหลือเป็น ประเภทข้อมูล สองเท่า (4.2, 6, 10) ดังนั้น วิธีที่ 2จะถูกเรียกในครั้งนี้
-
นี่คือวิธีที่ Java ประสบความสำเร็จในการโอเวอร์โหลดฟังก์ชันโดยพิจารณาจากจำนวนพารามิเตอร์ที่แตกต่างกัน รวมถึงประเภทข้อมูลที่แตกต่างกันของพารามิเตอร์ที่เกี่ยวข้อง
ความหลากหลายแบบรันไทม์
ตัวเลือกนี้เรียกอีกอย่างว่าการเชื่อมโยงแบบไดนามิก ในกระบวนการนี้ การเรียกใช้ฟังก์ชันที่สร้างขึ้นสำหรับฟังก์ชันอื่นจะได้รับอนุญาตเฉพาะขณะรันไทม์เท่านั้น เราสามารถบรรลุการเชื่อมโยงแบบไดนามิกใน Java โดยใช้วิธีการแทนที่วิธีการเอาชนะ
การแทนที่เมธอดใน Java เกิดขึ้นเมื่อเมธอดในคลาสพื้นฐานมีคำจำกัดความในคลาสที่ได้รับ เมธอดหรือฟังก์ชันคลาสพื้นฐานเรียกว่าเมธอดที่ถูกแทนที่// Class 1
class Parent {
// Print method
void Print()
{
// Print statement
System.out.println("Inside Parent Class");
}
}
// Class 2
class Child1 extends Parent {
// Print method
void Print() { System.out.println("Inside Child1 Class"); }
}
// Class 3
class Child2 extends Parent {
// Print method
void Print()
{
// Print statement
System.out.println("Inside Child2 Class");
}
}
class Main {
public static void main(String args[]) {
// Creating an object of class Parent
Parent parent = new Parent();
parent.Print();
// Calling print methods
parent = new Child1();
parent.Print();
parent = new Child2();
parent.Print();
}
}-
โปรแกรมข้างต้นประกอบด้วยสามคลาส: Parent ( class 1 ), Child1 ( class 2 ) และChild2 ( class 3 ) คลาส 2และคลาส 3สืบทอดคลาส 1
-
ผู้ปกครอง มี วิธีที่เรียกว่าPrint( ) ภายในฟังก์ชันนี้ เราจะพิมพ์ " Inside Parent Class " Child1และChild2 ยังมี ฟังก์ชันPrint()ซึ่งโดยทั่วไปจะแทนที่ ฟังก์ชัน Print()ของ คลาส Parentและพิมพ์ " Inside Child1 Class " และ " Inside Child2 Class " ตามลำดับไปยังคอนโซล
-
จากฟังก์ชันหลัก ขั้นแรกเราสร้างอ็อบเจ็กต์ของคลาสพาเรนต์ที่เรียกว่า parent จากนั้นเราใช้วัตถุนี้เพื่อเรียกวิธีการพิมพ์ของคลาสหลัก ดังนั้น " Inside Parent Class " จะถูกพิมพ์บนคอนโซล
-
หลังจากนั้นเราจะเรียก ตัวสร้าง เริ่มต้น ของคลาส Child1 และเรียกใช้ฟังก์ชัน Print() โปรดทราบว่า ขณะนี้จะมีการเรียกเมธอด Print()ที่กำหนดไว้ใน คลาส Child1เนื่องจากเราได้แทนที่เมธอดPrint() ของ คลาสพาเรนต์แล้ว ดังนั้น " Inside Child1 Class " จะถูกพิมพ์บนคอนโซล
-
สุดท้ายนี้ เราเรียก คอนสตรัค เตอร์เริ่มต้น ของคลาส Child2 และเรียกใช้ฟังก์ชัน Print() ที่นี่ วิธี การ Print() ที่กำหนด ไว้ใน คลาส Child2 จะถูกเรียก เนื่องจากเราได้แทนที่ วิธี Print() ของคลาส พาเรนต์ ดังนั้น " Inside Child2 Class " จะถูกพิมพ์บนคอนโซล
-
นี่คือวิธีการเอาชนะวิธีการใน Java
ผลลัพธ์
ในบทความนี้ เราได้เรียนรู้ว่าความหลากหลายใน Java คืออะไร จากนั้นเราจะเจาะลึกในหัวข้อนี้และอภิปรายถึงความหลากหลายสองประเภทใน Java: ความหลากหลายแบบคอมไพล์ไทม์ และความหลากหลายแบบรันไทม์ เราได้แสดงให้เห็นผ่านโปรแกรมแล้วว่าการเชื่อมโยงแบบคงที่และไดนามิกสามารถทำได้ใน Java ได้อย่างไรFor loop ใน Java + forEach ตัวอย่างไวยากรณ์ลูป
ที่มา: FreeCodeCamp การวนซ้ำในการเขียนโปรแกรมคือลำดับของคำสั่งที่ดำเนินการอย่างต่อเนื่องจนกว่าจะตรงตามเงื่อนไขที่กำหนด ในบทความนี้ เราจะเรียนรู้เกี่ยวกับforและforEach loop ใน Java
สำหรับ Loop Syntax ใน Java
นี่คือไวยากรณ์สำหรับการสร้างfor loop :for (initialization; condition; increment/decrement) {
// code to be executed
}
-
forบ่งบอกว่าเรากำลังจะสร้างลูป ตามด้วยวงเล็บซึ่งมีทุกสิ่งที่เราต้องการเพื่อให้ลูปทำงานได้
-
การเริ่มต้นกำหนดตัวแปรเริ่มต้นเป็นจุดเริ่มต้นของการวนซ้ำ ซึ่งโดยปกติจะเป็นจำนวนเต็ม
-
เงื่อนไขระบุจำนวนครั้งที่ควรดำเนินการวนซ้ำ
-
การเพิ่มขึ้น / ลดลง การเพิ่มขึ้น / ลดลงค่าของตัวแปรเริ่มต้นแต่ละครั้งที่มีการรันลูป เมื่อค่าของตัวแปรเพิ่มขึ้น/ลดลง ตัวแปรจะมีแนวโน้มที่จะเป็นไปตามเงื่อนไขที่ระบุ
-
โปรดทราบว่าคำหลักแต่ละคำจะคั่นด้วยเครื่องหมายอัฒภาค ( ; )
for(int x = 1; x <=5; x++) {
System.out.println(x);
}
/*
1
2
3
4
5
*/int[] randomNumbers = {2, 5, 4, 7};
for (int i = 0; i < randomNumbers.length; i++) {
System.out.println(randomNumbers[i]);
}
// 2
// 5
// 4
// 7ไวยากรณ์ลูป forEach ใน Java
forEach loop ถูกใช้โดยเฉพาะเพื่อวนซ้ำองค์ประกอบของอาร์เรย์ นี่คือลักษณะของไวยากรณ์:for (dataType variableName : arrayName) {
// code to be executed
}int[] randomNumbers = {2, 5, 4, 7};
for (int x : randomNumbers) {
System.out.println(x + 1);
}
/*
3
6
5
8
*/
GO TO FULL VERSION