คุณสมบัติของตัวสร้าง
- ชื่อของคอนสตรัคเตอร์ต้องเหมือนกับชื่อคลาส
- ประเภทการส่งคืนถือเป็นโมฆะ
- คอนสตรัคเตอร์ไม่สามารถเป็นแบบคงที่ นามธรรม และสุดท้ายได้
ประเภทของตัวสร้าง
- ค่าเริ่มต้น
- พารามิเตอร์น้อย
- พารามิเตอร์
1. ตัวสร้างเริ่มต้น
ตัวสร้างเริ่มต้นถูกสร้างขึ้นโดยคอมไพเลอร์ Java เมื่อ coder ไม่ได้ประกาศตัวสร้างใด ๆ สำหรับคลาสและตัวสร้างนี้ไม่มีอาร์กิวเมนต์ใด ๆ ไฟล์ Java ไม่มีรหัสใดๆ สำหรับตัวสร้างเริ่มต้น โค้ดคอนสตรัคเตอร์เริ่มต้นถูกสร้างขึ้นในขณะที่คอมไพล์โค้ด Java และเก็บไว้ในไฟล์ .ระดับ ไฟล์.
2. ตัวสร้างแบบไม่มีพารามิเตอร์
เมื่อคอนสตรัคเตอร์ถูกประกาศโดยไม่มีพารามิเตอร์หรืออาร์กิวเมนต์ คอนสตรัคเตอร์จะเรียกว่าคอนสตรัคเตอร์น้อย ตัวสร้างที่ไม่มีพารามิเตอร์ทำงานเหมือนตัวสร้างเริ่มต้นและตัวสร้างนี้สามารถมีคำสั่งหรือจะว่างเปล่าก็ได้
3. ตัวสร้างพารามิเตอร์
เมื่อคอนสตรัคเตอร์ถูกประกาศด้วยพารามิเตอร์ตั้งแต่หนึ่งตัวขึ้นไป คอนสตรัคเตอร์จะถูกเรียกว่าคอนสตรัคเตอร์แบบกำหนดพารามิเตอร์ ค่าพารามิเตอร์ของคอนสตรัคเตอร์จะถูกส่งต่อในเวลาที่สร้างอ็อบเจ็กต์
ตัวอย่างที่ 1: การสร้าง Parameter-Less Constructor
โค้ดต่อไปนี้แสดงวิธีใช้คอนสตรัคเตอร์แบบไม่มีพารามิเตอร์ มันถูกกล่าวถึงก่อนหน้านี้ว่าชื่อเมธอดตัวสร้างจะเหมือนกับชื่อคลาส ที่นี่ชื่อคลาสคือ ' คอน1 ' ดังนั้นชื่อคอนสตรัคเตอร์ที่ไม่มีพารามิเตอร์คือ ' คอน1() . ' สองตัวแปรคลาส ' ชื่อ ' และ ' อายุ ,' ประกาศไว้ที่นี่ ในขณะที่ประกาศตัวแปรวัตถุ ' วัตถุ ' คอนสตรัคเตอร์จะถูกเรียกและข้อความเฉพาะจะถูกพิมพ์ออกมา หลังจากนั้น จะมีการกำหนดค่าสองค่าในตัวแปรคลาสและพิมพ์ในภายหลังโดยใช้ 'Obj' วัตถุ.
สาธารณะ ระดับคอน1{//ประกาศตัวแปร
สตริง ชื่อ;
intอายุ;
//ตัวสร้างแบบไม่มีพารามิเตอร์
คอน1() {
ระบบ .ออก.println('ตัวสร้างถูกเรียก');
//เริ่มต้นตัวแปร
ชื่อ= 'ฟาฮิม เรซา';
อายุ= 30;
}
//main() เมธอด
สาธารณะ คงที่ โมฆะหลัก( สตริง []args) {
//สร้างวัตถุ
con1 obj= ใหม่คอน1();
//พิมพ์ค่าคุณสมบัติของอ็อบเจกต์
ระบบ .ออก.พิมพ์('อายุ' +วัตถุชื่อ + ' เป็น ' +วัตถุอายุ);
}
}
เอาท์พุท:
รูปภาพต่อไปนี้แสดงผลลัพธ์ของรหัส ตัวสร้างถูกเรียกในขณะที่สร้างวัตถุและข้อความ ตัวสร้างเรียกว่า ถูกพิมพ์ ค่าของ ' ชื่อ ' และ ' อายุ ’ ได้รับมอบหมายให้อยู่ภายในตัวสร้าง ค่าของตัวแปรเหล่านี้จะถูกพิมพ์ในภายหลัง
ตัวอย่างที่ 2: สร้างตัวสร้างพารามิเตอร์
รหัสต่อไปนี้จะคำนวณเงินเดือนรวมของพนักงานตามเงินเดือนพื้นฐานและพิมพ์ข้อมูลอื่น ๆ ของพนักงานนั้นควบคู่ไปกับเงินเดือนที่คำนวณได้ มีการประกาศตัวแปรคลาสเจ็ดตัว ตัวสร้างชื่อ ' คอน2() ,' มีสามพารามิเตอร์ พารามิเตอร์สองตัวแรกจะใช้ค่าสตริงใน ' ชื่อ ' และ ' โพสต์ ' พารามิเตอร์และพารามิเตอร์ที่สามจะใช้ค่าตัวเลขใน ' ขั้นพื้นฐาน ' พารามิเตอร์ ค่าของพารามิเตอร์เหล่านี้จะถูกส่งต่อในขณะที่สร้างวัตถุ ตัวสร้างจะเริ่มต้นตัวแปรคลาสด้วยค่าเหล่านี้และคำนวณค่าอื่น ๆ ตามค่าของ ' ขั้นพื้นฐาน ' พารามิเตอร์ ต่อไปจะพิมพ์ชื่อ ตำแหน่งงาน และเงินเดือนของพนักงาน
สาธารณะ ระดับcon2{// ประกาศตัวแปร
สตริง ชื่อ;
สตริง โพสต์;
intขั้นพื้นฐาน;
สองเท่าบ้านเช่า;
สองเท่าทางการแพทย์;
สองเท่าขนส่ง;
สองเท่าเงินเดือน;
// ตัวสร้างพารามิเตอร์
con2( สตริง ชื่อ, สตริง โพสต์,intขั้นพื้นฐาน) {
นี้.ชื่อ =ชื่อ;
นี้.โพสต์ =โพสต์;
นี้.ขั้นพื้นฐาน =ขั้นพื้นฐาน;
นี้.บ้านเช่า =ขั้นพื้นฐาน*0.3;
นี้.ทางการแพทย์ =ขั้นพื้นฐาน*0.2;
นี้.ขนส่ง =ขั้นพื้นฐาน*0.1;
เงินเดือน=ขั้นพื้นฐาน+บ้านเช่า+ทางการแพทย์+ขนส่ง;
}
//main() เมธอด
สาธารณะ คงที่ โมฆะหลัก( สตริง []args) {
//สร้างวัตถุ
con2 obj= ใหม่con2('มีร์ ซับบีร์','นักบัญชี',65000);
//พิมพ์ค่าคุณสมบัติของอ็อบเจกต์
ระบบ .ออก.พิมพ์('ชื่อพนักงาน: ' +วัตถุชื่อ + 'NS' + 'โพสต์: '+วัตถุโพสต์ +
'NS' + 'เงินเดือน: TK'+วัตถุเงินเดือน);
}
}
เอาท์พุท:
รูปภาพต่อไปนี้แสดงผลลัพธ์ของรหัส ที่นี่ ชื่อของพนักงาน ตำแหน่งงาน และเงินเดือนพื้นฐานจะแสดงอยู่ในคำสั่งการสร้างวัตถุ พิมพ์เงินเดือน ชื่อ และตำแหน่งงานทั้งหมดที่นี่
ตัวอย่างที่ 3: สร้างการโยงตัวสร้าง
สิ่งสำคัญคือต้องรู้เกี่ยวกับคุณลักษณะการสืบทอดของการเขียนโปรแกรมเชิงวัตถุเพื่อทำความเข้าใจแนวคิดของการผูกมัดตัวสร้าง เมื่อคลาสใหม่ถูกสร้างขึ้นโดยสืบทอดคลาสอื่น คลาสนั้นเรียกว่าการสืบทอด ในกรณีนี้ คุณสมบัติทั้งหมดของพาเรนต์หรือคลาสพื้นฐานสามารถเข้าถึงได้จากคลาสย่อยหรือคลาสที่ได้รับ เมื่อวัตถุของคลาสลูกถูกสร้างขึ้น มันจะเรียกตัวสร้างของคลาสหลักโดยอัตโนมัติก่อนที่จะเรียกตัวสร้างของตัวเอง NS ' ซุปเปอร์() ' เมธอดใช้ในภาษาอื่นเพื่อเรียกตัวสร้างพาเรนต์ แต่คอมไพเลอร์ Java เรียกเมธอดนี้โดยอัตโนมัติ การใช้ Constructor ในลักษณะนี้เรียกว่า Constructor chaining และกระบวนการนี้จะแสดงให้เห็นในตัวอย่างนี้ ที่นี่ชื่อคลาสหลักคือ ' พ่อแม่ ' และชื่อคลาสลูกคือ ' con3 .' มีอีกวิธีหนึ่งที่ชื่อว่า ' รวม() ’ ในคลาสย่อยที่รวมค่าที่กำหนดในตัวสร้างพาเรนต์และตัวสร้างย่อย
ระดับพ่อแม่{// ประกาศตัวแปร
สตริง strVal;
//ตัวสร้างหลัก
พ่อแม่(){
ระบบ .ออก.println('ตัวสร้างผู้ปกครองถูกเรียก');
strVal= 'ฉันชอบ ';
}
}
สาธารณะ ระดับcon3ยืดออกพ่อแม่{
// ประกาศตัวแปร
สตริง เด็กStrVal;
// ผู้สร้างเด็ก
con3(){
ระบบ .ออก.println('ผู้สร้างเด็กถูกเรียก');
เด็กStrVal=strVal+ 'การเขียนโปรแกรมจาวา';
}
//วิธีอื่นในการรวมสตริง
สตริง รวม()
{
กลับ นี้.เด็กStrVal;
}
//main() เมธอด
สาธารณะ คงที่ โมฆะหลัก( สตริง []args) {
//สร้างวัตถุ
con3 obj= ใหม่con3();
//พิมพ์ค่าคุณสมบัติของอ็อบเจกต์
ระบบ .ออก.พิมพ์(วัตถุรวม());
}
}
เอาท์พุท:
รูปภาพต่อไปนี้แสดงผลลัพธ์ของรหัส ข้อความแรกถูกพิมพ์จากตัวสร้างหลัก ในขณะที่ข้อความที่สองถูกพิมพ์จากตัวสร้างลูก ข้อความสุดท้ายถูกพิมพ์โดยการเรียก ' รวม() ' กระบวนการ.
บทสรุป
แนวคิดของคอนสตรัคเตอร์และการใช้คอนสตรัคเตอร์ต่างๆ ได้อธิบายไว้ในบทช่วยสอนนี้โดยใช้ตัวอย่างโค้ด Java แบบง่ายสำหรับผู้ใช้มือใหม่ที่สามารถทำตามได้ หวังว่าตัวอย่างเหล่านี้จะช่วยให้คุณเข้าใจพื้นฐานของ Java Constructor