ตัวสร้างโอเวอร์โหลดใน Java

Constructor Overloading คืออะไรในภาษาโปรแกรม? Java?

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

ตัวอย่างของคอนสตรัคเตอร์ที่ถูกต้องสำหรับคลาส ลงชื่อเข้าใช้ แสดงอยู่ด้านล่าง:

Account(int a);
Account (int a,int b);
Account (String a,int b);

เหตุใดเราจึงต้องการการโอเวอร์โหลดคอนสตรัคเตอร์ใน Java?

ตัวสร้างโอเวอร์โหลดใน Java ช่วยเพิ่มความยืดหยุ่นและประสิทธิภาพของโค้ดโดยอนุญาตให้มีคอนสตรัคเตอร์หลายตัวในคลาสเดียว โดยแต่ละตัวมีรายการพารามิเตอร์ที่แตกต่างกัน

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

ตัวอย่าง: การโอเวอร์โหลดคอนสตรัคเตอร์ใน Java

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการโอเวอร์โหลดคอนสตรัคเตอร์ใน Java โดยใช้คลาสชื่อ ทดลอง.

ขั้นตอน 1) พิมพ์รหัสในตัวแก้ไข

class Demo{
      int  value1;
      int  value2;
      /*Demo(){
       value1 = 10;
       value2 = 20;
       System.out.println("Inside 1st Constructor");
     }*/
     Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Constructor");
    }
    Demo(int a,int b){
    value1 = a;
    value2 = b;
    System.out.println("Inside 3rd Constructor");
   }
   public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
    Demo d1 = new Demo();
    Demo d2 = new Demo(30);
    Demo d3 = new Demo(30,40);
    d1.display();
    d2.display();
    d3.display();
 }
}

ขั้นตอน 2) บันทึก คอมไพล์ และรันโค้ด

ขั้นตอน 3) เกิดข้อผิดพลาด โปรดลองแก้ไขข้อผิดพลาดก่อนดำเนินการขั้นตอนต่อไปของการโอเวอร์โหลดคอนสตรัคเตอร์ใน Java.

ขั้นตอน 4) ทุกชั้นเรียนมีค่าเริ่มต้น ตัวสร้างใน Javaคอนสตรัคเตอร์เริ่มต้นสำหรับ การสาธิตคลาส is การสาธิต()หากคุณไม่ได้ระบุค่าดังกล่าว คอมไพเลอร์จะสร้างค่าให้คุณโดยอัตโนมัติและกำหนดค่าเริ่มต้นให้กับตัวแปรต่างๆ

อย่างไรก็ตาม หากคุณระบุคอนสตรัคเตอร์แบบมีพารามิเตอร์ เช่น สาธิต(int a) และต้องการใช้ค่าเริ่มต้น การสาธิต()จำเป็นต้องระบุอย่างชัดเจน

ขั้นตอน 5) ลบเครื่องหมายคอมเมนต์ออกจากบรรทัดที่ 4-8 ของโค้ด จากนั้นบันทึก คอมไพล์ และรันโปรแกรมอีกครั้งเพื่อสังเกตการเปลี่ยนแปลงพฤติกรรม

การเชื่อมโยงคอนสตรัคเตอร์ใน Java

พิจารณาสถานการณ์ที่คลาสพื้นฐานถูกขยายโดยลูก เมื่อใดก็ตามที่วัตถุของคลาสลูกถูกสร้างขึ้น ตัวสร้างของคลาสพาเรนต์จะถูกเรียกใช้ก่อน สิ่งนี้เรียกว่า การเชื่อมโยงตัวสร้าง.

ตัวอย่าง: เพื่อทำความเข้าใจการเชื่อมโยงคอนสตรัคเตอร์ (Constructor chaining) กับการโอเวอร์โหลดคอนสตรัคเตอร์ (Constructor Overloading) ใน Java

ขั้นตอน 1) คัดลอกโค้ดต่อไปนี้ลงในตัวแก้ไข

class Demo{
   int  value1;
   int  value2;
    Demo(){
      value1 = 1;
      value2 = 2;
      System.out.println("Inside 1st Parent Constructor");
   }
   Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Parent Constructor");
   }
  public void display(){
     System.out.println("Value1 === "+value1);
     System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
     DemoChild d1 = new DemoChild();
     d1.display();
  }
}
class DemoChild extends Demo{
    int value3;
    int value4;
    DemoChild(){
    //super(5);
     value3 = 3;
     value4 = 4;
    System.out.println("Inside the Constructor of Child");
    }
    public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
      System.out.println("Value1 === "+value3);
      System.out.println("Value2 === "+value4);
   }
}

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

ผลลัพธ์ที่คาดหวัง:

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 4

ขั้นตอน 3) คุณอาจสังเกตเห็นว่าคอนสตรัคเตอร์ของผู้ปกครอง การสาธิต() ทำงานตามค่าเริ่มต้น หากต้องการเรียกใช้คอนสตรัคเตอร์ที่มีการโอเวอร์โหลด สาธิต(int a) ให้ใช้คำหลักแทน “ สุดยอด”.

ไวยากรณ์:

super();
--or--
super(parameter list);

ตัวอย่าง: ถ้าคอนสตรัคเตอร์ของคลาสแม่เป็นแบบนี้ Demo(String Name, int a)คุณจะระบุ ซุปเปอร์(“Java”,5)- หากใช้คำสำคัญ ซุปเปอร์ ต้องเป็นบรรทัดแรกของโค้ดในคอนสตรัคเตอร์ของคลาสลูก

ขั้นตอน 4) ลบเครื่องหมายคอมเมนต์ออกจากบรรทัดที่ 26 แล้วรันโค้ด สังเกตผลลัพธ์

Output:

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value1 === 3
Value2 === 4

คำถามที่พบบ่อย