ลำดับการเริ่มต้นตัวแปรแบบคงที่
1. กฎง่ายๆ
ก่อนอื่นมาดูรหัส Java ที่พบบ่อยที่สุด:
การทดสอบระดับสาธารณะ {public Static test1 t = new test1 (); สาธารณะคงที่ int a = 0; สาธารณะคงที่ int b; โมฆะคงที่สาธารณะหลัก (สตริง [] arg) {system.out.println (test.a); System.out.println (test.b); }} คลาส test1 {public test1 () {test.a ++; test.b ++; -นี่คือการเดาว่าผลลัพธ์ของคอนโซลคืออะไร?
ตกลงบางทีคุณอาจเดาผลลัพธ์ด้านล่างดังนั้นคุณยังคงคุ้นเคยกับ Java
คัดลอกรหัสดังนี้: 0 1
หากคุณไม่เข้าใจว่าทำไมผลลัพธ์ข้างต้นจึงเป็นเอาต์พุตฉันจะบอกคุณ
การเริ่มต้นตัวแปร Java Static เป็นไปตามกฎต่อไปนี้:
หลังจากอ่านสิ่งนี้คุณจะเข้าใจว่าคุณค่าของการทดสอบมีการเปลี่ยนแปลงสามครั้ง
ตั้งค่าเป็น 0 เมื่อประกาศ >> test1 :: test1 ถูกตั้งค่าเป็น 1 >> test.a เริ่มต้นเป็น 0
2. กฎที่ซับซ้อน
หากคุณเข้าใจสิ่งนี้โปรดดูรหัสด้านล่าง
คลาสสาธารณะ A {สาธารณะคงที่ int b = ba; สาธารณะคงที่ a plus = ใหม่ a ("a"); public Static Final int finalint = (int) (math.random ()*100); สาธารณะคงที่ B P = ใหม่ B ("A"); สาธารณะคงที่สตริงสุดท้าย FinalSTR = "FinalSTR"; สาธารณะคงที่จำนวนเต็มสุดท้าย FinalInteger = New Integer (10); สาธารณะคงที่ int a = 1; สาธารณะคงที่ b c = null; สาธารณะ A (สตริงจาก) {System.out.println ("----------- เริ่มต้น A :: A ----------------"); System.out.println ("a :: a, จาก ="+จาก); System.out.println ("a :: a, ab ="+ab); System.out.println ("a :: a, a.finalint ="+a.finalint); System.out.println ("a :: a, ba ="+ba); System.out.println ("a :: a, b.plus ="+b.plus); System.out.println ("----------- สิ้นสุด A :: A ----------------"); } โมฆะคงที่สาธารณะหลัก (สตริง [] arg) {system.out.println ("หลัก, ab ="+ab); System.out.println ("หลัก, bt ="+bt); System.out.println ("Main, Ca ="+Ca); }} คลาส B {สาธารณะคงที่ int t = aa; สาธารณะคงที่ A Plus = ใหม่ A ("B"); สาธารณะคงที่ int a = 1; สาธารณะ B (สตริงจาก) {System.out.println ("----------- เริ่มต้น B :: B -------------------"); System.out.println ("B :: B, จาก ="+จาก); System.out.println ("b :: b, ba ="+ba); System.out.println ("b :: b, aa ="+aa); System.out.println ("b :: b, ap ="+ap); System.out.println ("B :: B, A.plus ="+A.Plus); System.out.println ("B :: B, A.FinalInt ="+A.FinalInt); System.out.println ("B :: B, A.FinalInt ="+A.FinalInt); System.out.println ("B :: B, A.FinalInt ="+A.FinalInt); System.out.println ("B :: B, A.FinalInt ="+A.FinalInt); System.out.println ("B :: B, A.FinalInteger ="+A.FinalInteger); System.out.println ("B :: B, A.finalstr ="+A.finalstr); System.out.println ("----------- สิ้นสุด b :: b ----------------"); }} คลาส C {สาธารณะคงที่สุดท้าย a = ใหม่ a ("c");}คุณยังเดาผลลัพธ์ผลลัพธ์ได้หรือไม่? ฉันเขียนมันขณะทดสอบดังนั้นฉันจึงไม่เดา ฮ่าฮ่า
ผลการออกคอนโซลคือ:
----------- เริ่มต้น :: a ---------------- a :: a, จาก = ba :: a, ab = 0a :: a, a.finalint = 0a :: a, ba = 0a :: a, b.plus = null ----------- จบ :: a ------------------------------------------ A.finalint = 0a :: a, ba = 1a :: a, b.plus=a@a90653---------- จบ :: a --------------------------- เริ่มต้น b :: b ---------------- b :: b, จาก = ab :: b, ba = 1b :: b, aa = 0b: A.finalint = 61b :: b, A.finalinteger = nullb :: b, a.finalstr = finalstr. b.plus=a@a90653---------- จบ A :: A -------------------- Main, CA = A@61De33
คุณไม่ได้เดาผลลัพธ์นี้ฮ่าฮ่า
ต้องใช้เวลามากในการอธิบายผลการดำเนินการของโปรแกรมทีละคน ที่นี่เราจะเขียนกฎโดยตรงตามด้วยการเริ่มต้นตัวแปร Java Static
กฎในย่อหน้าแรกยังคงถูกต้อง แต่ก็ไม่ได้ดี
การเริ่มต้นของข้อมูลคงที่
การเพิ่มฟิลด์ที่มีคุณสมบัติคงที่เป็นฟิลด์คลาสที่เรียกว่าซึ่งหมายความว่าเจ้าของฟิลด์นี้ไม่ใช่วัตถุ แต่เป็นคลาส ไม่ว่าจะสร้างวัตถุจำนวนเท่าใดก็มีข้อมูลแบบคงที่เพียงสำเนาเดียว
ฟิลด์คงที่จะเริ่มต้นในชั้นเรียนเสมอจากนั้นฟิลด์ทั่วไปจะเริ่มต้น จากนั้นเริ่มต้นตัวสร้าง อย่างไรก็ตามหากวัตถุของคลาสนี้ไม่ได้สร้างวัตถุจะไม่เริ่มต้นและจะถูกดำเนินการเพียงครั้งเดียว
เช่นเดียวกับในรหัสต่อไปนี้ในคลาส StaticInitialization ตารางตารางคงที่ = ตารางใหม่ (); ขั้นแรกจากนั้นวัตถุตารางจะไม่เริ่มต้นมิฉะนั้นจะไม่เริ่มต้น
ชามคลาส {ชาม (เครื่องหมาย int) {print ("ชาม (" + marker + ")"); } void f1 (int marker) {print ("f1 (" + marker + ")"); }} ตารางคลาส {ชามแบบคงที่ 1 = ชามใหม่ (1); ตาราง () {print ("table ()"); Bowl2.f1 (1); } void f2 (int marker) {print ("f2 (" + marker + ")"); } ชามแบบคงที่ 2 = ชามใหม่ (2);} ตู้ชั้นเรียน {ชามชาม 3 = ชามใหม่ (3); ชามแบบคงที่ 4 = ชามใหม่ (4); ตู้ () {พิมพ์ ("ตู้ ()"); Bowl4.f1 (2); } void f3 (int marker) {print ("f3 (" + marker + ")"); } ชามสแตติกชาม 5 = ชามใหม่ (5);} คลาสสาธารณะ StaticInitialization {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {พิมพ์ ("การสร้างตู้ใหม่ () หลัก"); ตู้ใหม่ (); พิมพ์ ("การสร้างตู้ใหม่ () หลัก"); ตู้ใหม่ (); table.f2 (1); ตู้บอร์ด F3 (1); } ตารางตารางคงที่ = ตารางใหม่ (); ตู้เก็บของแบบคงที่ = ตู้ใหม่ ();}เอาท์พุท:
ชาม (1) ชาม (2) ตาราง () F1 (1) ชาม (4) ชาม (5) ชาม (3) ตู้ () F1 (2) สร้างตู้ใหม่ () ใน MainBowl (3) ตู้ () F1 (2) สร้างตู้ใหม่ () ใน Mainbowl
การเริ่มต้นแบบคงที่ที่แสดง (นั่นคือบล็อกคงที่)
การวางคำสั่งการเริ่มต้นหลายครั้งในรั้งคงที่เรียกว่าบล็อกคงที่ ในความเป็นจริงมันถูกเขียนขึ้นร่วมกันโดยการเขียนสถิติหลายอย่างและสาระสำคัญก็เหมือนกัน ดำเนินการเฉพาะเมื่อวัตถุถูกสร้างขึ้นเป็นครั้งแรกหรือฟิลด์ของคลาสถูกเข้าถึงเป็นครั้งแรกและเพียงครั้งเดียวเท่านั้น
คลาสถ้วย {ถ้วย (เครื่องหมาย int) {print ("Cup (" + marker + ")"); } void f (int marker) {print ("f (" + marker + ")"); }} คลาสถ้วย {cup cup1 แบบคงที่; ถ้วยถ้วยคงที่; คงที่ {cup1 = ถ้วยใหม่ (1); Cup2 = ถ้วยใหม่ (2); } ถ้วย () {พิมพ์ ("ถ้วย ()"); }} คลาสสาธารณะ ExplicitStatic {โมฆะสาธารณะคงที่หลัก (สตริง [] args) {print ("ภายใน main ()"); Cups.cup1.f (99); // (1)} // ถ้วยถ้วยคงที่ = ถ้วยใหม่ (); // (2) // ถ้วยถ้วยคงที่ถ้วย = ถ้วยใหม่ (); // (2)}เอาท์พุท:
ด้านในหลัก () ถ้วย (1) ถ้วย (2) F (99)
การเริ่มต้นอินสแตนซ์ที่ไม่คงที่
ไม่มีอะไรจะพูดเกี่ยวกับเรื่องนี้มันเป็นเพียงการเริ่มต้นธรรมดาดำเนินการตามลำดับและสามารถดำเนินการหลายครั้ง
mug class {mug (int marker) {print ("mug (" + marker + ")"); } void f (int marker) {print ("f (" + marker + ")"); }} แก้วระดับสาธารณะ {mug mug1; mug2; {mug1 = แก้วใหม่ (1); mug2 = mug ใหม่ (2); พิมพ์ ("MUG1 & MUG2 เริ่มต้น"); } mugs () {print ("mugs ()"); } mugs (int i) {print ("mugs (int)"); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {print ("ภายใน main ()"); แก้วใหม่ (); พิมพ์ ("แก้วใหม่ () เสร็จสิ้น"); แก้วใหม่ (1); พิมพ์ ("แก้วใหม่ (1) เสร็จสิ้น"); -ด้านใน Main () แก้ว (1) แก้ว (2) MUG1 & MUG2 InitializedMugs () แก้วใหม่ () เสร็จสิ้น MUG (1) แก้ว (2) MUG1 & MUG2 InitializedMugs (int) แก้วใหม่ (1) เสร็จสมบูรณ์