คอฟฟี่เบรค #111. ความแตกต่างและการผูกแบบไดนามิกใน Java For loop ใน Java + forEach ตัวอย่างไวยากรณ์ลูป

ความแตกต่างและการผูกแบบไดนามิกใน Java

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

ความแตกต่างใน Java คืออะไร?

Polymorphism หมายถึง การมีหลายรูปแบบ ในการเขียนโปรแกรม หมายถึงความสามารถของสัญญาณหรือข้อความที่จะปรากฏในรูปแบบมากกว่าหนึ่งรูปแบบ

ตัวอย่างชีวิตจริง

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

ความสำคัญของความหลากหลาย

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

ประเภทของความหลากหลาย

ในภาษา Java นั้น polymorphism แบ่งได้เป็น 2 ประเภท คือ

1. ความหลากหลายเวลาคอมไพล์ (การเชื่อมโยงแบบคงที่)
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 โดยอิงตามประเภทข้อมูลพารามิเตอร์ที่แตกต่างกัน

ตัวอย่างที่ 2 พิจารณาโปรแกรมด้านล่าง:

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 โดยอิงตามจำนวนพารามิเตอร์ที่แตกต่างกัน

ตัวอย่างที่ 3

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
*/

ในตัวอย่างด้านบน ตัวแปรเริ่มต้นคือxที่มีค่า 1 การวนซ้ำจะทำงานต่อไปตราบเท่าที่ค่าxน้อยกว่าหรือเท่ากับ 5 - นี่คือเงื่อนไข x++เพิ่มค่าของxหลังจากการรันแต่ละครั้ง เราพิมพ์ค่าx ต่อไป ซึ่งหยุดหลังจาก 5 เนื่องจากเป็นไปตามเงื่อนไข การเพิ่มเป็น 6 เป็นไปไม่ได้เนื่องจากมากกว่าและไม่เท่ากับ 5 ในตัวอย่างต่อไปนี้ เราจะใช้ for loopเพื่อพิมพ์ค่าทั้งหมดในอาร์เรย์

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
}

คุณจะสังเกตเห็นว่าไวยากรณ์ที่นี่สั้นกว่าfor loop และforEach loop ยังเริ่มต้นด้วย forคำหลัก แทนที่จะเริ่มต้นตัวแปรด้วยค่า เราจะระบุประเภทข้อมูล ก่อน (จะต้องตรงกับประเภทข้อมูลของอาร์เรย์) ตามด้วยชื่อของตัวแปรของเราและชื่อของอาร์เรย์ คั่นด้วยเครื่องหมายทวิภาค นี่คือตัวอย่างที่จะช่วยให้คุณเข้าใจไวยากรณ์ได้ดีขึ้น:

int[] randomNumbers = {2, 5, 4, 7};
for (int x : randomNumbers) {
  System.out.println(x + 1);
}

/*
3
6
5
8
*/

ในตัวอย่างนี้ เราได้วนซ้ำแต่ละองค์ประกอบและเพิ่มค่าเริ่มต้นทีละ 1 ตามค่าเริ่มต้น การวนซ้ำจะหยุดเมื่อวนซ้ำองค์ประกอบทั้งหมดของอาร์เรย์ ซึ่งหมายความว่าเราไม่จำเป็นต้องส่งค่าใดๆ ไปยังตัวแปรของเราหรือระบุเงื่อนไขใดๆ สำหรับการวนซ้ำเพื่อสิ้นสุด

บทสรุป

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