Constructor Chaining คืออะไร?
คอนสตรัคเตอร์ใน Java เป็นวิธีเฉพาะที่ใช้ในการสร้างอ็อบเจกต์ของคลาส ตัวสร้างจะถูกเรียกใช้ทุกครั้งที่มีการสร้างวัตถุของคลาส สามารถใช้เพื่อกำหนดค่าให้กับคุณสมบัติของวัตถุ ณ เวลาที่สร้าง อาจมีตัวสร้างหลายตัวในคลาส Java ที่มีรายการพารามิเตอร์ต่างกัน Constructor chaining ใช้เพื่อเรียกใช้ตัวสร้างที่แตกต่างกันของคลาส / คลาสพาเรนต์เดียวกันในเวลาสร้างวัตถุ
Constructor chaining ถูกนำมาใช้ใน Java อย่างไร?
มีสองวิธีในการผูกมัดตัวสร้างตามวิธีการเรียกตัวสร้าง มีดังนี้
- ใช้ คำสำคัญ นี้ () - เพื่อเรียกตัวสร้างของคลาสเดียวกัน
- ใช้ คำหลัก super() - เพื่อเรียกตัวสร้างของคลาสแม่
ซึ่งจะอธิบายไว้ในตัวอย่างต่อไปนี้
ตัวอย่างการผูกมัดตัวสร้าง #1 – ตัวสร้างถูกโยงโดยใช้คำหลัก this()
เราได้ประกาศตัวสร้างสี่ตัวสำหรับ DerivedClass หนึ่งไม่มีข้อโต้แย้งและอีกสามข้อมีข้อโต้แย้งต่างกัน ภายในแต่ละคอนสตรัคเตอร์ คำหลัก
this()ใช้เพื่อเรียกคอนสตรัคเตอร์ถัดไปของคลาสเดียวกัน
package com.tutorialwriting.constchaining;
public class DerivedClass{
String firstName;
String country;
int age;
public DerivedClass() {
this("Maggie");
}
public DerivedClass(String firstName) {
this(firstName, 15);
}
public DerivedClass(String firstName, int age) {
this(firstName, age, "Australia");
}
public DerivedClass(String firstName, int age, String country) {
this.firstName = firstName;
this.age = age;
this.country = country;
}
void displayValues() {
System.out.println("First Name : " + firstName);
System.out.println("Country : " + country);
System.out.println("Age : " + age);
}
public static void main(String args[]) {
DerivedClass object = new DerivedClass();
object.displayValues();
}
}
ผลลัพธ์ของการดำเนินการ
ตัวอย่างการโยงตัวสร้าง # 2 - ตัวสร้างถูกโยงโดยใช้คำหลัก super()
ที่นี่ คลาสลูกเรียกคอนสตรัคเตอร์ของคลาสพาเรนต์โดยใช้คีย์เวิร์ด
super() BaseClass มีตัวสร้างสามตัว ตัวสร้างที่ไม่มีข้อโต้แย้งเรียกหนึ่งในสามตัวสร้างอาร์กิวเมนต์ของ BaseClass โดยใช้
this( )
package com.tutorialwriting.constchaining;
public class BaseClass {
public BaseClass() {
this("Male", "English", "1989/11/10");
System.out.println("I'm executed third!!!");
}
public BaseClass(String firstName, String surname, int idNo) {
System.out.println("I'm executed first!");
System.out.println("First name : " + firstName);
System.out.println("Surname : " + surname);
System.out.println("ID Number : " + idNo);
}
public BaseClass(String gender, String nationality, String birthDate) {
System.out.println("I'm executed second!!");
System.out.println("Gender : " + gender);
System.out.println("Nationality : " + nationality);
System.out.println("Birth Date : " + birthDate);
}
}
DerivedClass มีคอนสตรัคเตอร์สองตัว แต่ละอันเรียกคอนสตรัคเตอร์ที่แตกต่างกันของคลาสซุปเปอร์โดยใช้
super( )
package com.tutorialwriting.constchaining;
public class DerivedClass extends BaseClass {
public DerivedClass() {
super();
}
public DerivedClass(String firstName, String surname, int idNo) {
super(firstName, surname, idNo);
}
public static void main(String args[]) {
DerivedClass object2 = new DerivedClass("Paul", "Wilson", 123456);
DerivedClass object1 = new DerivedClass();
}
}
ผลลัพธ์ของการดำเนินการ
การเรียกตัวสร้างโดยนัยและชัดเจน
Java มีสองวิธีที่แตกต่างกันในการเรียกตัวสร้าง: การเรียกโดยนัยและการเรียกอย่างชัดเจน
- การโทรที่ชัดเจนหมายถึงการเรียกตัวสร้างอย่างชัดเจนในรหัสโดยใช้this()หรือsuper( )
- การเรียกโดยปริยายหมายถึงการเรียกตัวสร้างที่ไม่มีข้อโต้แย้งของซูเปอร์คลาสโดยปริยายเมื่อไม่มีการเรียกที่ชัดเจนจากตัวสร้างคลาสลูก กล่าวอีกนัยหนึ่ง คอมไพลเลอร์เพิ่ม การเรียก super()เป็นบรรทัดแรกของตัวสร้างใดๆ ของคลาสลูก ถ้าโปรแกรมเมอร์ไม่เรียกsuper()ในโค้ด อย่างชัดเจน
ทำไมเราต้องผูกมัดตัวสร้าง?
มีจุดประสงค์ที่แตกต่างกันหลายประการของการมีคอนสตรัคเตอร์เชนใน Java ดังที่แสดงไว้ด้านล่าง
- เป็นวิธีการเข้าถึงคุณสมบัติของตัวสร้างอื่น ๆ หรือคุณสมบัติของคลาสพาเรนต์
- ขณะที่เรียกใช้คอนสตรัคเตอร์อื่นๆ จะมีเพียงอ็อบเจกต์เดียวเท่านั้นที่ถูกใช้งาน ซึ่งเป็นอินสแตนซ์ปัจจุบันของคลาส การเริ่มต้นเกิดขึ้นในที่เดียว แต่เรามีสิทธิ์เรียกการใช้งานคอนสตรัคเตอร์ที่แตกต่างกันผ่านสายโซ่ สิ่งนี้ช่วยอย่างมากในการจัดการหน่วยความจำและการบำรุงรักษาโค้ด
บทสรุป
ในบทช่วยสอนนี้ เราได้กล่าวถึงการผูกมัดตัวสร้างใน Java คอนสตรัคเตอร์เป็นเซกเมนต์โค้ดที่เหมือนเมธอดซึ่งถูกเรียกใช้ขณะสร้างอ็อบเจกต์ คลาส Java สามารถมีตัวสร้างจำนวนเท่าใดก็ได้ที่มีรายการพารามิเตอร์ต่างกัน Constructor chaining เป็นวิธีที่สะดวกในการจัดการการกำหนดค่าเริ่มต้นที่แตกต่างกันด้วยอินสแตนซ์เดียวของคลาส ประเด็นสำคัญที่ควรสังเกตจากบทช่วยสอนนี้แสดงไว้ด้านล่าง
- ถ้าโปรแกรมเมอร์ไม่ได้เพิ่มลงในโค้ดอย่างชัดเจน คอมไพลเลอร์จะเพิ่มตัวสร้างแบบไม่มีอาร์กิวเมนต์สาธารณะให้กับคลาส Java สิ่งนี้เรียกว่าตัวสร้างเริ่มต้น
- this()และsuper()ควรเขียนเป็นบรรทัดแรกของตัวสร้าง
- this()ใช้เพื่อเรียกคอนสตรัคเตอร์ของคลาสเดียวกันในขณะที่super()ใช้เพื่อเรียกคอนสตรัคเตอร์ของคลาสซูเปอร์ทันที
- ควรมีตัวสร้างอย่างน้อยหนึ่งตัวภายในคลาสที่ไม่มีคำหลักthis()
- หากไม่ได้เพิ่มอย่างชัดเจน คอมไพเลอร์จะเพิ่มการเรียก super()ที่ไม่มีข้อโต้แย้งให้กับตัวสร้างคลาสย่อยทุกตัว สิ่งนี้จะช่วยสร้างอินสแตนซ์ของคลาสได้อย่างถูกต้อง