ใน Methods and Data Members เราได้กล่าวถึงว่าอ็อบเจ็กต์ใน Java จะถูกเตรียมใช้งานเมื่อถูกสร้างขึ้น ในระหว่างการเริ่มต้น สมาชิกข้อมูลของออบเจ็กต์จะได้รับการกำหนดค่าเริ่มต้น เราสามารถเริ่มต้นได้อย่างชัดเจน หากเราไม่กำหนดค่าเริ่มต้นให้กับสมาชิกข้อมูล สมาชิกข้อมูลจะใช้ค่าเริ่มต้นเริ่มต้นตามประเภทของมัน
การกำหนดค่าเริ่มต้นอย่างชัดเจนต้องการให้เรากำหนดค่าเริ่มต้นเมื่อเขียนโปรแกรม ซึ่งบางครั้งก็ไม่สะดวก เราสามารถใช้ Constructor เพื่อเริ่มต้นวัตถุได้ ตัวสร้างสามารถเริ่มต้นสมาชิกข้อมูลและระบุการดำเนินการเฉพาะได้ การดำเนินการเหล่านี้จะดำเนินการโดยอัตโนมัติเมื่อมีการสร้างออบเจ็กต์
กำหนดตัวสร้าง
ตัวสร้างเป็นวิธีการ เช่นเดียวกับวิธีการทั่วไป เรากำหนดคอนสตรัคเตอร์ในคลาส ตัวสร้างมีลักษณะพื้นฐานดังต่อไปนี้:
1. ชื่อของตัวสร้างจะเหมือนกับชื่อของคลาส
2. ตัวสร้างไม่มีค่าส่งคืน
เรากำหนดคอนสตรัคเตอร์ของคลาส Human:
การทดสอบคลาสสาธารณะ { public static void main (String [] args) { Human aPerson = new Human (160); System.out.println (aPerson.getHeight () )} คลาส Human { /** * Constructor */ Human (int h) { this.height = h; System.out.println("ฉันเกิด"); } /** * accessor */ int getHeight() { return this.height; ความสูง int;} โปรแกรมข้างต้นจะพิมพ์โค้ดที่คัดลอกมาดังนี้:
ฉันเกิด
160
Constructor สามารถรับรายการพารามิเตอร์ได้เหมือนกับวิธีการทั่วไป ที่นี่ Constructor Human() รับค่าจำนวนเต็มเป็นพารามิเตอร์ ในเนื้อความของวิธีการ เรากำหนดพารามิเตอร์จำนวนเต็มให้กับความสูงของสมาชิกข้อมูล Constructor จะทำสองสิ่งเมื่อวัตถุถูกสร้างขึ้น:
Constructor สามารถรับรายการพารามิเตอร์ได้เหมือนกับวิธีการทั่วไป ที่นี่ Constructor Human() รับค่าจำนวนเต็มเป็นพารามิเตอร์ ในเนื้อความของวิธีการ เรากำหนดพารามิเตอร์จำนวนเต็มให้กับความสูงของสมาชิกข้อมูล Constructor จะทำสองสิ่งเมื่อวัตถุถูกสร้างขึ้น:
1. ระบุค่าเริ่มต้นสำหรับสมาชิกข้อมูล this.height = h;
2. ดำเนินการเริ่มต้นเฉพาะ System.out.println("I'm Born");
ด้วยวิธีนี้ เราสามารถตั้งค่าเริ่มต้นได้อย่างยืดหยุ่นเมื่อเรียก Constructor โดยไม่มีข้อจำกัดเหมือนกับการเริ่มต้นที่ชัดเจน
ตัวสร้างเรียกว่าอย่างไร? เมื่อเราสร้างคลาส เราทุกคนจะใช้ Human() ใหม่ จริงๆ แล้ว เรากำลังเรียก Constructor ของคลาส Human เมื่อเราไม่ได้กำหนดวิธีการนี้ Java จะจัดเตรียมตัวสร้างเปล่าให้เรียกใช้เมื่อใช้ new แต่เมื่อเรากำหนด Constructor แล้ว Java จะเรียก Constructor ที่กำหนดเมื่อสร้างอ็อบเจ็กต์ เมื่อโทรเราให้พารามิเตอร์ 160 คุณยังสามารถดูได้จากผลการวิ่งขั้นสุดท้ายว่าความสูงของวัตถุนั้นถูกกำหนดค่าเริ่มต้นไว้ที่ 160 จริงๆ
ลำดับความสำคัญของวิธีการเริ่มต้น
ในวิธีการและสมาชิกข้อมูล เราจะเห็นว่าถ้าเราระบุค่าเริ่มต้นที่ชัดเจน สมาชิกข้อมูลก็จะรับค่าเริ่มต้นที่ชัดเจนแทนค่าเริ่มต้นเริ่มต้น แต่ถ้าเราทั้งคู่ระบุค่าเริ่มต้นที่ชัดเจนและเตรียมข้อมูลเบื้องต้นให้กับสมาชิกข้อมูลเดียวกันในตัวสร้าง ค่าเริ่มต้นสุดท้ายจะถูกกำหนดโดยตัวสร้าง ตัวอย่างเช่น ตัวอย่างต่อไปนี้:
การทดสอบคลาสสาธารณะ { public static void main (String [] args) { Human aPerson = new Human (160); System.out.println (aPerson.getHeight () )} คลาส Human { /** * Constructor */ Human (int h) { this.height = h; } /** * accessor */ int getHeight() { return this.height; } int height=170; ผลการวิ่งคือ:
คัดลอกรหัสรหัสดังต่อไปนี้:
160
ค่าเริ่มต้นขั้นสุดท้ายของวัตถุสอดคล้องกับค่าในวิธีการก่อสร้าง ดังนั้น:
วิธีการสร้าง > ตัวเริ่มต้นที่ชัดเจน > ตัวเริ่มต้นเริ่มต้น
(อันที่จริง ลำดับความสำคัญที่เรียกว่าเกี่ยวข้องกับลำดับการดำเนินการระหว่างการเริ่มต้น ฉันจะเจาะลึกประเด็นนี้ในภายหลัง)
วิธีการโอเวอร์โหลด
คลาสสามารถกำหนดคอนสตรัคเตอร์ได้มากกว่าหนึ่งตัว ตัวอย่างเช่น:
การทดสอบคลาสสาธารณะ { public static void main (String [] args) { Human neZha = new Human (150, "shit"); System.out.println (neZha.getHeight () ) } คลาส Human { /** * ตัวสร้าง 1 */ Human(int h) { this.height = h; System.out.println("ฉันเกิด"); } /** * ตัวสร้าง 2 */ Human(int h, String s) { this.height = h; System.out.println("Ne Zha: ฉันเกิด, " + s); } /** * accessor */ int getHeight() { return this.height; ;} ผลการวิ่ง:
คัดลอกรหัสรหัสดังต่อไปนี้:
Ne Zha: ฉันเกิดแล้ว ไอ้เหี้ย
150
มีการกำหนดคอนสตรัคเตอร์สองตัวไว้ด้านบน ทั้งสองชื่อ Human ตัวสร้างทั้งสองมีรายการพารามิเตอร์ที่แตกต่างกัน
เมื่อใช้ new เพื่อสร้างอ็อบเจ็กต์ Java จะตัดสินใจว่าจะสร้างคอนสตรัคเตอร์ตัวใดตามพารามิเตอร์ที่ให้มา ตัวอย่างเช่น เมื่อสร้าง neZha เรามีพารามิเตอร์สองตัว: จำนวนเต็ม 150 และสตริง "shit" ซึ่งสอดคล้องกับรายการพารามิเตอร์ของวิธีสร้างที่สอง ดังนั้น Java จะเรียกวิธีสร้างที่สอง
ใน Java Java กำหนดวิธีการที่จะเรียกตามชื่อวิธีการและรายการพารามิเตอร์ สิ่งนี้เรียกว่าการโอเวอร์โหลดวิธีการ วิธีการสร้างสามารถโอเวอร์โหลดได้ และวิธีการทั่วไปก็สามารถโอเวอร์โหลดได้เช่นกัน เช่น เมธอด Breath() ด้านล่าง:
การทดสอบคลาสสาธารณะ { public static void main (String [] args) { Human aPerson = new Human (); aPerson.breath (10); }} คลาส Human { /** * Breath () 1 */ void Breath () { System.out.println("hu...hu..."); } /** * Breath() 2 */ void Breath(int rep) { int i; for(i = 0; i < rep; i++ ) { System.out.println("lu...lu..."); ผลการวิ่ง:
คัดลอกรหัสรหัสดังต่อไปนี้:
ลู...ลู...
ลู...ลู...
ลู...ลู...
ลู...ลู...
ลู...ลู...
ลู...ลู...
ลู...ลู...
ลู...ลู...
ลู...ลู...
ลู...ลู...
อย่างที่คุณเห็น เนื่องจากมีการระบุพารามิเตอร์ในระหว่างการโทร: จำนวนเต็ม 10 ซึ่งเป็นเมธอด Breath() ที่สองซึ่งมีการเรียกรายการพารามิเตอร์ที่ตรงกัน
สรุป
ลักษณะคอนสตรัคเตอร์: ชื่อเดียวกับคลาส ไม่มีค่าส่งคืน
วัตถุประสงค์ของตัวสร้าง: การเริ่มต้น, วิธีการดำเนินการเริ่มต้นมากเกินไป: ชื่อวิธีการ + รายการพารามิเตอร์ -> วิธีการที่ถูกเรียกจริง