ประเภทข้อมูลอ้างอิงใน Java

หากไม่เข้าใจไวยากรณ์ของ Java ก็เป็นไปไม่ได้เลยที่จะกลายเป็นนักพัฒนาที่จริงจัง ดังนั้นวันนี้เราจึงเรียนรู้ไวยากรณ์ต่อไป ในบทความก่อนหน้านี้เราได้พูดถึงตัวแปรดั้งเดิม แต่เนื่องจากมีตัวแปรสองประเภท วันนี้เราจะพูดถึงประเภทที่สอง - ประเภทอ้างอิงใน Java แล้วมันคืออะไร? เหตุใดจึงจำเป็นต้องมีประเภทข้อมูลอ้างอิงใน Java สมมติว่าเรามีวัตถุทีวีที่มีคุณสมบัติบางอย่าง เช่น หมายเลขช่อง ระดับเสียง และติดธง:

public class TV {
   int numberOfChannel;
   int soundVolume;
   boolean isOn;
}

ประเภทง่าย ๆ เช่นintเก็บข้อมูลนี้ ได้อย่างไร โปรดจำไว้ว่า: ตัวแปรหนึ่งตัวintคือ 4 ไบต์ แต่ภายในมีตัวแปรสองตัว (4 ไบต์ + 4 ไบต์) ประเภทเดียวกันและด้วยboolean(+1 ไบต์)... รวม - 4 ถึง 9 แต่ตามกฎแล้ว ข้อมูลอีกมากมายจะถูกเก็บไว้ในวัตถุ จะทำอย่างไร? คุณไม่สามารถใส่วัตถุลงในตัวแปรได้ ณ จุดนี้ในเรื่องราวของเรา ตัวแปรอ้างอิงปรากฏขึ้น ตัวแปรอ้างอิงจะจัดเก็บที่อยู่ของตำแหน่งหน่วยความจำซึ่งมีวัตถุเฉพาะอยู่ นั่นคือนี่คือ "นามบัตร" พร้อมที่อยู่ซึ่งเราสามารถค้นหาวัตถุของเราในหน่วยความจำที่แชร์และดำเนินการบางอย่างกับมันได้ การอ้างอิงถึงวัตถุใด ๆ ใน Java เป็นตัวแปรอ้างอิง นี่คือลักษณะของวัตถุทีวีของเรา:

TV telly = new TV();

เราตั้ง ค่าตัวแปรประเภททีวีพร้อมชื่อtellyให้กับลิงก์ไปยังออบเจ็กต์ประเภททีวีที่สร้างขึ้น นั่นคือ JVM จัดสรรหน่วยความจำบนฮีปสำหรับอ็อบเจ็กต์ TV สร้างมันและที่อยู่ไปยังตำแหน่งในหน่วยความจำ ใส่ไว้ในตัวแปรtellyซึ่งถูกเก็บไว้ในสแต็ก คุณสามารถอ่านเพิ่มเติมเกี่ยวกับหน่วยความจำ เช่น สแตก และข้อมูลที่เป็นประโยชน์อื่นๆ ได้มากมายในการบรรยายนี้ คุณสังเกตเห็นตัวแปรประเภททีวีและวัตถุประเภททีวีหรือไม่? สิ่งนี้ไม่ได้เกิดขึ้นโดยไม่มีเหตุผล: ออบเจ็กต์บางประเภทจะต้องมีตัวแปรประเภทเดียวกันที่สอดคล้องกัน (ไม่นับการสืบทอดและการใช้งานอินเทอร์เฟซ แต่ตอนนี้เราไม่ได้คำนึงถึงสิ่งนี้) เราจะไม่เทซุปใส่แก้วใช่ไหม? ปรากฎว่าวัตถุของเราคือทีวีและตัวแปรอ้างอิงสำหรับวัตถุนั้นก็เหมือนกับแผงควบคุม การใช้รีโมตคอนโทรลนี้ทำให้เราสามารถโต้ตอบกับวัตถุและข้อมูลของมันได้ ตัวอย่างเช่น ตั้งค่าคุณลักษณะสำหรับทีวีของเรา:

telly.isOn = true;
telly.numberOfChannel = 53;
telly.soundVolume = 20;

ที่นี่เราใช้ตัวดำเนินการจุด.เพื่อเข้าถึงและเริ่มใช้องค์ประกอบภายในของวัตถุที่ตัวแปรอ้างถึง ตัวอย่างเช่น ในบรรทัดแรก เราบอกตัวแปรtelly: “ให้ตัวแปรภายในisOnของวัตถุที่คุณกำลังอ้างอิงแก่เราและตั้งค่าให้เป็นจริง” (เปิดทีวีให้เรา)

นิยามตัวแปรอ้างอิงใหม่

สมมติว่าเรามีตัวแปรสองตัวที่เป็นประเภทอ้างอิงและวัตถุที่พวกมันอ้างถึง:

TV firstTV = new TV();
TV secondTV = new TV();

ถ้าเราเขียน:

firstTV = secondTV;

นี่จะหมายความว่าเราได้กำหนดตัวแปรแรกเป็นค่าสำเนาของที่อยู่ (ค่าของบิตที่อยู่) ให้กับวัตถุที่สอง และตอนนี้ตัวแปรทั้งสองอ้างอิงถึงวัตถุที่สอง (กล่าวอีกนัยหนึ่ง รีโมทคอนโทรลสองตัวสำหรับสิ่งเดียวกัน โทรทัศน์). ในเวลาเดียวกัน วัตถุแรกถูกทิ้งไว้โดยไม่มีตัวแปรที่อ้างอิงถึงวัตถุนั้น เป็นผลให้เรามีวัตถุที่ไม่สามารถเข้าถึงได้เนื่องจากตัวแปรนั้นเป็นเธรดที่มีเงื่อนไขซึ่งหากไม่กลายเป็นขยะก็แค่อยู่ในหน่วยความจำและใช้พื้นที่ วัตถุนี้จะถูกทำลายจากหน่วยความจำในภายหลังโดย ตัวรวบรวมขยะ คุณสามารถแยกเธรดที่เชื่อมต่อกับวัตถุโดยไม่ต้องมีลิงก์อื่น:

secondTV = null;

ด้วยเหตุนี้ จะมีเพียงลิงก์เดียวไปยังวัตถุ - firstTVและsecondTVจะไม่ชี้ไปที่ใครเลยอีกต่อไป (ซึ่งไม่ได้ป้องกันเราจากการกำหนดลิงก์ไปยังวัตถุบางอย่างเช่นทีวีในอนาคต)

คลาสสตริง

แยกกัน ฉันอยากจะพูดถึงคลาสString นี่คือคลาสพื้นฐานที่ออกแบบมาสำหรับการจัดเก็บและการทำงานกับข้อมูลที่จัดเก็บเป็นสตริง ตัวอย่าง:

String text = new String("This TV is very loud");

ที่นี่เราได้ส่งสตริงที่จะจัดเก็บไว้ใน Constructor ของวัตถุ แต่ไม่มีใครทำอย่างนั้น ท้ายที่สุดแล้ว คุณสามารถสร้างสตริงได้:

String text = "This TV is very loud";

สะดวกกว่ามากใช่ไหม? ในแง่ของความนิยมในการใช้งานStringมันไม่ได้ด้อยกว่าประเภทดั้งเดิม แต่ยังคงเป็นคลาส และตัวแปรที่อ้างอิงถึงไม่ใช่ประเภทดั้งเดิม แต่เป็นประเภทอ้างอิง เราStringมีความสามารถอันยอดเยี่ยมในการเชื่อมสตริงเข้าด้วยกัน:

String text = "This TV" + " is very loud";

เป็นผลให้เราจะได้รับข้อความอีกครั้ง: This TV is very loudเนื่องจากทั้งสองบรรทัดจะรวมกันเป็นหนึ่งทั้งหมด และตัวแปรจะอ้างอิงถึงข้อความฉบับเต็มนี้ ความแตกต่างที่สำคัญคือStringนี่คือคลาสที่ไม่เปลี่ยนรูป มันหมายความว่าอะไร? ลองใช้ตัวอย่างนี้:

String text = "This TV";
text = text + " is very loud";

ดูเหมือนว่าทุกอย่างจะง่ายดาย: เราประกาศตัวแปร และกำหนดค่าให้กับมัน ในบรรทัดถัดไปเราจะเปลี่ยนมัน แต่เราไม่เปลี่ยนแปลงจริงๆ เนื่องจากนี่คือคลาสที่ไม่เปลี่ยนรูป ในบรรทัดที่สอง ค่าเริ่มต้นจะไม่เปลี่ยนแปลง แต่จะถูกสร้างขึ้นใหม่ ซึ่งจะประกอบด้วยค่า+ " is very loud"แรก

ค่าคงที่อ้างอิง

ในบทความเกี่ยวกับประเภทดั้งเดิม เราได้กล่าวถึงหัวข้อค่าคงที่ ตัวแปรอ้างอิงจะทำงานอย่างไรเมื่อเราประกาศให้เป็นที่ สิ้นสุด

final TV telly = new TV();

คุณอาจคิดว่าสิ่งนี้จะทำให้วัตถุไม่เปลี่ยนรูป แต่ไม่ นั่นไม่เป็นความจริง ตัวแปรอ้างอิงที่มีตัวดัดแปลงfinalจะถูกผูกไว้กับวัตถุเฉพาะโดยไม่มีความสามารถในการยกเลิกการผูกมัน แต่อย่างใด (กำหนดใหม่หรือเทียบเคียงกับnull) นั่นคือหลังจากตั้งค่าของตัวแปรแล้ว ให้โค้ดเช่น:

telly = new TV();

หรือ

telly = null;

จะทำให้เกิดข้อผิดพลาดในการรวบรวม นั่นคือfinalจะมีผลเฉพาะกับลิงก์เท่านั้น และไม่มีผลกระทบต่อออบเจ็กต์นั้นเอง หากเราทำให้มันไม่แน่นอนในตอนแรก เราก็สามารถเปลี่ยนสถานะภายในของมันได้โดยไม่มีปัญหาใดๆ:

telly.soundVolume = 30;

บางครั้งตัวแปรถูกกำหนดให้เป็นตัวแปรสุดท้ายแม้จะอยู่ในอาร์กิวเมนต์ของเมธอดก็ตาม!

public void enableTV (final TV telly){
   telly.isOn = true;
}

สิ่งนี้ทำเพื่อว่าในระหว่างกระบวนการเขียนวิธีการ ข้อโต้แย้งเหล่านี้ไม่สามารถถูกแทนที่ได้ ดังนั้นจึงสร้างความสับสนน้อยลง จะเกิดอะไรขึ้นถ้าเราแสดงfinalตัวแปรอ้างอิงที่อ้างถึงวัตถุที่ไม่เปลี่ยนรูปล่ะ? เช่นString:

final String PASSWORD = "password";

เป็นผลให้เราจะได้รับค่าคงที่ ซึ่งเป็นค่าอะนาล็อกของค่าคงที่ประเภทดั้งเดิม เนื่องจากที่นี่เราไม่สามารถกำหนดการอ้างอิงใหม่หรือเปลี่ยนสถานะภายในของวัตถุได้ (ข้อมูลภายใน)

มาสรุปกัน

1. แม้ว่าตัวแปรอย่างง่ายจะเก็บบิตของค่า ตัวแปรอ้างอิงจะเก็บบิตที่แสดงถึงวิธีการดึงข้อมูลอ็อบเจ็กต์
2. การอ้างอิงวัตถุได้รับการประกาศสำหรับวัตถุประเภทเดียวเท่านั้น
3. คลาสใดๆ ใน Java จะเป็นประเภทการอ้างอิง
4. ค่าเริ่มต้นของตัวแปรอ้างอิงใดๆ ใน Java nullคือ
5. Stringเป็นตัวอย่างมาตรฐานของประเภทการอ้างอิง คลาสนี้ก็ไม่เปลี่ยนรูปเช่นกัน
6. ตัวแปรอ้างอิงที่มีตัวดัดแปลงfinalจะถูกผูกไว้กับออบเจ็กต์เดียวเท่านั้นโดยไม่มีความเป็นไปได้ในการกำหนดนิยามใหม่