คำนำ
ใน Java วัตถุจะต้องเริ่มต้นอย่างถูกต้องก่อนที่จะสามารถใช้งานได้ซึ่งกำหนดโดยข้อกำหนด Java
การเริ่มต้นอัตโนมัติ (เริ่มต้น)
สมาชิกข้อมูลพื้นฐานทั้งหมดของชั้นเรียนจะเริ่มต้น รันตัวอย่างต่อไปนี้เพื่อดูค่าเริ่มต้นเหล่านี้:
ชั้นเรียนเริ่มต้น {บูลีน t; ถ่าน C; ไบต์ B; กางเกงขาสั้น; int i; ยาว l; ลอย F; Double D; โมฆะสาธารณะแสดง () {System.out.println ("ค่าเริ่มต้นประเภทพื้นฐาน/n" + "บูลีน <----->" + t + "/n" + "ถ่าน <------>" + c + "/n" + "ไบต์ <------->" + b + "/n" + " l + "/n" + "float <------>" + f + "/n" + "double <----->" + d + "/n"); }} คลาสสาธารณะ initValue {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {ค่าเริ่มต้น d = ใหม่ค่าเริ่มต้น (); D.SHOW (); -【ผลการดำเนินงาน】:
ค่าเริ่มต้นประเภทพื้นฐาน
บูลีน <------> เท็จ
ถ่าน <------>
ไบต์ <------> 0
สั้น <------> 0
int <------> 0
ยาว <------> 0
ลอย <------> 0.0
สองเท่า <-----> 0.0
โดยที่ ค่าเริ่มต้นของประเภทถ่านเป็นโมฆะ
สำหรับประเภทข้อมูลที่ไม่ได้ใช้งานการจัดการของวัตถุยังเริ่มต้นด้วย:
บุคคลในชั้นเรียน {ชื่อสตริงส่วนตัว; // setter} คลาสเริ่มต้น {person p; โมฆะสาธารณะแสดง () {system.out.println ("บุคคล <---->" + p); }} คลาสสาธารณะ initValue {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {ค่าเริ่มต้น d = ใหม่ค่าเริ่มต้น (); D.SHOW (); -【ผลการดำเนินงาน】:
บุคคล <------> NULL
จะเห็นได้ว่าค่าเริ่มต้นที่จับนั้นเป็นโมฆะ ซึ่งหมายความว่าหากวิธีการที่คล้ายกับ p.setName ถูกเรียกโดยไม่ระบุค่าเริ่มต้นสำหรับ P จะมีข้อยกเว้นเกิดขึ้น
การเริ่มต้นกฎระเบียบ
หากคุณต้องการกำหนดค่าเริ่มต้นให้กับตัวแปรด้วยตัวคุณเองคุณสามารถกำหนดค่าในขณะที่กำหนดตัวแปร
ค่าเริ่มต้นของคลาส {บูลีน t = true; ถ่าน c = 'a'; ไบต์ b = 47; สั้น s = 0xff; int i = 24; Long L = 999; ลอย f = 1.2f; double d = 1.732; โมฆะสาธารณะแสดง () {system.out.println ("บูลีน <----->" + t + "/n" + "ถ่าน <------>" + c + "/n" + "ไบต์ <------>" + b + "/n" + "<------>" + "/n" + " "float <------>" + f + "/n" + "double <------>" + d + "/n"); }} คลาสสาธารณะ initValue {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {ค่าเริ่มต้น d = ใหม่ค่าเริ่มต้น (); D.SHOW (); -มันสามารถเริ่มต้นได้ด้วยวิธีเดียว
บุคคลในชั้นเรียน {int i = set (); -วิธีการเหล่านี้ยังสามารถใช้ตัวแปรอิสระได้:
คนในชั้นเรียน {int i; int j = set (i); - การเริ่มต้นสร้าง
ข้อได้เปรียบของการเริ่มต้นผู้สร้างคือค่าเริ่มต้นสามารถกำหนดได้ในระหว่างการรันไทม์ ตัวอย่างเช่น:
คนชั้นเรียน {อายุ int; บุคคล () {อายุ = 89; -อายุจะเริ่มต้นเป็น 0 และจากนั้นกลายเป็น 89 นี่เป็นจริงสำหรับทุกประเภทพื้นฐานรวมถึงจัดการกับวัตถุ
ลำดับการเริ่มต้น
ในชั้นเรียนลำดับของการเริ่มต้นจะถูกกำหนดโดยลำดับที่ตัวแปรถูกกำหนดภายในคลาส แม้ว่าคำจำกัดความของตัวแปรจะกระจายไปทั่วกลางคำจำกัดความของวิธีการตัวแปรจะยังคงเริ่มต้นก่อนที่จะเรียกวิธีการใด ๆ (รวมถึงตัวสร้าง) ตัวอย่างเช่น:
PET คลาส {PET (อายุ int) {System.out.println ("สัตว์เลี้ยง (" + อายุ + ")"); }} คนในชั้นเรียน {PET T1 = สัตว์เลี้ยงใหม่ (1); person () {system.out.println ("--- person () ---"); T3 = สัตว์เลี้ยงใหม่ (33); } สัตว์เลี้ยง t2 = สัตว์เลี้ยงใหม่ (2); void show () {system.out.println ("show ----- กำลังวิ่ง"); } สัตว์เลี้ยง T3 = สัตว์เลี้ยงใหม่ (3);} คลาสสาธารณะ orderofinitialization {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {บุคคล p = บุคคลใหม่ (); P.Show (); -【ผลการดำเนินงาน】:
สัตว์เลี้ยง (1)
สัตว์เลี้ยง (2)
สัตว์เลี้ยง (3)
--บุคคล()---
สัตว์เลี้ยง (33) <br/>
แสดง ----- กำลังวิ่ง
ในตัวอย่างข้างต้นแม้ว่าคำจำกัดความของ T1, T2 และ T3 นั้นอยู่เหนือชั้นเรียนลำดับของการเริ่มต้นจะถูกกำหนดโดยคำจำกัดความของคำจำกัดความของ T1, T2 และ T3 (เปลี่ยน T1, T2 และ T3 ด้วยตัวคุณเองเพื่อดูผลลัพธ์) เมื่อมีการเรียกตัวสร้างบุคคล T3 จะถูกเริ่มต้นใหม่
การเริ่มต้นของข้อมูลคงที่
หากข้อมูลคงที่กระบวนการเดียวกันจะดำเนินการ หากเป็นประเภทดั้งเดิมและไม่ได้เริ่มต้นมันจะได้รับค่าเริ่มต้นประเภทดั้งเดิมแบบดั้งเดิมของตัวเองโดยอัตโนมัติ หากเป็นที่จับของวัตถุมันจะได้รับค่า NULL เว้นแต่วัตถุจะถูกสร้างและเชื่อมต่อกับมัน หากเริ่มต้น ณ เวลานิยามวิธีที่ใช้จะแตกต่างจากค่าที่ไม่คงที่เนื่องจากแบบคงที่มีพื้นที่เก็บข้อมูลเพียงแห่งเดียว ตัวอย่างเช่น:
ชามคลาส {ชาม (เครื่องหมาย int) {system.out.println ("ชาม (" + marker + ")"); } void f (int marker) {system.out.println ("f (" + marker + ")"); }} ตารางคลาส {ชามคงที่ b1 = ชามใหม่ (1); ตาราง () {system.out.println ("ตาราง ()"); b2.f (1); } void f2 (int marker) {system.out.println ("f2 (" + marker + ")"); } ชามคงที่ b2 = ชามใหม่ (2);} ตู้ชั้นเรียน {ชาม b3 = ชามใหม่ (3); ชามคงที่ b4 = ชามใหม่ (4); ตู้ () {system.out.println ("ตู้ ()"); b4.f (2); } void f3 (int marker) {system.out.println ("f3 (" + marker + ")"); } ชามคงที่ b5 = ชามใหม่ (5);} คลาสสาธารณะ StaticInitialization {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {system.out.println ("การสร้างตู้ใหม่ () หลัก"); ตู้ใหม่ (); System.out.println ("การสร้างตู้ใหม่ () ในหลัก"); ตู้ใหม่ (); t2.f2 (1); T3.F3 (1); } ตารางคงที่ t2 = ตารางใหม่ (); ตู้แบบคงที่ t3 = ตู้ใหม่ ();}【ผลการดำเนินงาน】:
ชาม (1)
ชาม (2)
โต๊ะ()
F (1)
ชาม (4)
ชาม (5)
ชาม (3)
ตู้()
F (2)
การสร้างตู้ใหม่ () ในหลัก
ชาม (3)
ตู้()
F (2)
การสร้างตู้ใหม่ () ในหลัก
ชาม (3)
ตู้()
F (2)
F2 (1)
F3 (1)
บล็อกรหัสสถิต
Java ช่วยให้การเริ่มต้นการเริ่มต้นแบบคงที่อื่น ๆ แบ่งออกเป็นบล็อกรหัสพิเศษในชั้นเรียน บล็อกรหัสนี้อยู่ในรูปแบบของคำหลักคงที่ตามด้วยร่างกายวิธีการที่เรียกว่าบล็อกรหัสคงที่ บล็อกรหัสคงที่จะถูกดำเนินการเฉพาะเมื่อวัตถุของคลาสนั้นถูกสร้างขึ้นเป็นครั้งแรกหรือสมาชิกคงที่ที่อยู่ในคลาสนั้นจะเข้าถึงเป็นครั้งแรก ตัวอย่างเช่น:
บุคคลในชั้นเรียน {บุคคล (อายุ int) {system.out.println ("บุคคล (" + อายุ + ")"); } void f (อายุ int) {system.out.println ("f (" + อายุ + ")"); }} คนในชั้นเรียน {บุคคลคงที่ p1; คนคงที่ p2; คงที่ {p1 = บุคคลใหม่ (1); P2 = คนใหม่ (2); } persons () {system.out.println ("person ()"); }} คลาสสาธารณะ ExplicitStatic {โมฆะสาธารณะคงที่หลัก (สตริง [] args) {system.out.println ("ภายใน main ()"); person.p1.f (18); // 1} บุคคลคงที่ x = บุคคลใหม่ (); // 2 บุคคลคงที่ y = บุคคลใหม่ (); // 2}เมื่อเข้าถึงวัตถุคงที่ P1 ในบรรทัดที่ทำเครื่องหมาย 1 หรือหากบรรทัดที่ 1 มีความคิดเห็นและไม่ได้แสดงความคิดเห็นบรรทัดที่ 2 โมดูลการเริ่มต้นแบบคงที่สำหรับบุคคลจะทำงาน หากมีการแสดงความคิดเห็นทั้ง 1 และ 2 บล็อกรหัสสแตติกที่ใช้สำหรับบุคคลจะไม่ถูกดำเนินการ
ลำดับของคุณสมบัติคงที่และการดำเนินการบล็อกรหัสแบบคงที่
บุคคลในชั้นเรียน {บุคคล (อายุ int) {system.out.println ("บุคคล ("+อายุ+")"); }} คนในชั้นเรียน {บุคคลคงที่ p = บุคคลใหม่ (2); // 1 คงที่ {p = บุคคลใหม่ (3); } คนคงที่ p = บุคคลใหม่ (2); // 2} คลาสสาธารณะ compstaticInit {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {} บุคคลคงที่ x = บุคคลใหม่ ();};จากการวิเคราะห์ผลลัพธ์ของคำอธิบายประกอบ 1 การรักษา 2 และคำอธิบายประกอบ 2 การรักษา 1 จะเห็นได้ว่าลำดับของการดำเนินการของคุณสมบัติคงที่และบล็อกรหัสคงที่ขึ้นอยู่กับลำดับของการเข้ารหัส ใครก็ตามที่อยู่ข้างหน้าจะถูกดำเนินการก่อน
การเริ่มต้นของคุณสมบัติที่ไม่คงที่
สัตว์ชั้น {สัตว์ (อายุ int) {system.out.println ("สัตว์ (" + อายุ + ")"); } void f (อายุ int) {system.out.println ("f (" + อายุ + ")"); }} คลาสสาธารณะไม่ได้ใช้งาน {สัตว์ A1; สัตว์ A2; {a1 = สัตว์ใหม่ (1); a2 = สัตว์ใหม่ (2); System.out.println ("A1 & A2 เริ่มต้น"); } notstaticinit () {system.out.println ("notstaticinit"); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {system.out.println ("ภายใน main ()"); notstaticinit x = netstaticinit ใหม่ (); -คล้ายกับบล็อกรหัสคงที่ลำดับการเริ่มต้นของบล็อกรหัสที่ไม่ระบุชื่อที่มีคุณสมบัติที่ไม่คงที่ขึ้นอยู่กับ ลำดับการเข้ารหัส
กระบวนการเริ่มต้นวัตถุที่สืบทอดมา
แมลงคลาส {int i = 1; int J; แมลง () {prt ("i =" + i + ", j =" + j); J = 2; } int คงที่ x1 = PRT ("แมลงแบบคงที่ x1 เริ่มต้น"); Static Int PRT (String S) {System.out.println (s); กลับ 3; }} ด้วงคลาสสาธารณะขยายแมลง {int k = prt ("beeklt.k เริ่มต้น"); Beetle () {prt ("k =" + k); prt ("j =" + j); } int คงที่ x2 = prt ("bootle.x2 เริ่มต้น"); Static Int PRT (String S) {System.out.println (s); กลับ 4; } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {prt ("ด้วงคอนสตรัคเตอร์"); ด้วง b = ด้วงใหม่ (); -【ผลการดำเนินงาน】:
แมลงแบบคงที่ x1 เริ่มต้น
แบบคงที่ bootle.x2 เริ่มต้น
ด้วงคอนสตรัคเตอร์
i = 1, j = 0
beeklt.k เริ่มต้น
k = 4
J = 2
สิ่งแรกที่เกิดขึ้นเมื่อเรียกใช้จาวาบนด้วงคือตัวโหลดเพื่อค้นหาชั้นเรียนข้างนอก ในระหว่างกระบวนการโหลดตัวโหลดจะค้นพบคลาสพื้นฐานดังนั้นจึงโหลดตามนั้น กระบวนการนี้จะดำเนินการโดยไม่คำนึงว่าวัตถุของคลาสพื้นฐานจะถูกสร้างขึ้นหรือไม่ หากคลาสฐานมีคลาสฐานอื่นคลาสฐานอื่น ๆ จะถูกโหลดและอื่น ๆ ถัดไปดำเนินการเริ่มต้นแบบคงที่ในคลาสฐานรากจากนั้นดำเนินการในคลาสอนุพันธ์ถัดไปและอื่น ๆ นี่เป็นเพราะการเริ่มต้นของคลาสอนุพันธ์อาจขึ้นอยู่กับการเริ่มต้นของสมาชิกชั้นเรียนพื้นฐาน
เมื่อมีการโหลดคลาสทั้งหมดวัตถุสามารถสร้างได้ ขั้นแรกประเภทข้อมูลพื้นฐานทั้งหมดในวัตถุนี้ถูกตั้งค่าเป็นค่าเริ่มต้นและการจับวัตถุถูกตั้งค่าเป็น NULL จากนั้นดำเนินการสร้างผู้สร้างคลาสฐาน สถานการณ์นี้จะทำโดยอัตโนมัติ ( super()， และตัวสร้างของคลาสฐานยังสามารถระบุได้ผ่าน Super) หลังจากตัวสร้างคลาสพื้นฐานเสร็จสิ้นตัวแปรอินสแตนซ์คลาสที่ได้รับจะเริ่มต้นในลำดับดั้งเดิมของพวกเขาและส่วนของร่างกายที่เหลือของผู้สร้างจะถูกดำเนินการ
สรุปกระบวนการสร้างวัตถุ:
การดำเนินการแบบคงที่จะดำเนินการเฉพาะเมื่อคลาสถูกโหลดและเพียงครั้งเดียวเท่านั้น
ไม่คงที่จะดำเนินการเฉพาะเมื่อมีการสร้างอินสแตนซ์และดำเนินการทุกครั้งที่มีการสร้างวัตถุ
การดำเนินการคงที่จะดำเนินการก่อนที่จะไม่คงที่และคลาสพื้นฐานคงที่ก่อนการดำเนินการคงที่ผ่านคลาสอนุพันธ์;
คุณสมบัติการดำเนินการของคุณสมบัติคงที่และบล็อกรหัสคงที่ขึ้นอยู่กับตำแหน่งของพวกเขาในชั้นเรียนและผู้ที่ดำเนินการก่อน;
ลำดับการดำเนินการของคุณสมบัติที่ไม่คงที่และบล็อกตัวสร้างขึ้นอยู่กับตำแหน่งของพวกเขาในชั้นเรียนและผู้ที่ดำเนินการต่อหน้าพวกเขา
สรุป
ผ่านการแนะนำข้างต้นเรามีความเข้าใจในหลายวิธีในการเริ่มต้นวัตถุใน Java และวิธีดำเนินการรหัสการเริ่มต้นและยังแนะนำสถานการณ์ที่เราอาจใช้ตัวแปรที่ไม่ได้กำหนด หลังจากได้รับความเข้าใจอย่างละเอียดเกี่ยวกับปัญหาเหล่านี้คุณสามารถหลีกเลี่ยงความเสี่ยงในการเข้ารหัสเพื่อให้แน่ใจว่าวัตถุได้รับการเริ่มต้นอย่างสมบูรณ์ก่อนที่จะมองเห็นได้