คุณสามารถบอกคำถามพื้นฐาน Java ขั้นพื้นฐานได้กี่คำถาม?
1. การใช้ == สัญลักษณ์
ก่อนอื่นให้ดูรหัสที่น่าสนใจยิ่งขึ้น
จำนวนเต็ม A = 1,000, b = 1000; จำนวนเต็ม c = 100, d = 100; โมฆะสาธารณะ mrun (ชื่อสตริงสุดท้าย) {ใหม่ runnable () {โมฆะสาธารณะเรียกใช้ () {system.out.println (ชื่อ); - } system.out.println (a == b); System.out.println (c == d); หากคุณได้รับคำตอบที่ถูกต้องสำหรับคำถามนี้และเข้าใจหลักการ หมายความว่าพื้นฐานของคุณโอเค หากคำตอบของคุณเป็นจริงและเป็นจริงรากฐานของคุณจะขาด
ก่อนอื่นให้เผยแพร่คำตอบเรียกใช้รหัสและเราจะได้รับความจริง เรารู้ว่า == เปรียบเทียบการอ้างอิงของวัตถุทั้งสอง ABCD ที่นี่เป็นทั้งวัตถุที่สร้างขึ้นใหม่ ในทางทฤษฎีควรป้อนเท็จ นี่คือสิ่งที่น่าสนใจเกี่ยวกับคำถามนี้ ไม่ว่าจะเป็นคำถามสัมภาษณ์หรือพื้นที่สนทนาฟอรัมอัตราการปรากฏตัวของคำถามนี้สูงมาก หลักการนั้นง่ายมาก มาดูคลาสจำนวนเต็ม Java แล้วคุณจะเข้าใจ
ค่าคงที่ของจำนวนเต็มสาธารณะ (int i) {return i> = 128 || ฉัน <-128? ใหม่จำนวนเต็ม (i): small_values [i + 128]; } / ** * แคชของอินสแตนซ์ที่ใช้โดย {@link Integer#valueof (int)} และการบ็อกซิ่งอัตโนมัติ * / integer สุดท้ายคงที่ [] small_values = จำนวนเต็มใหม่ [256]; คงที่ {สำหรับ (int i = -128; i <128; i ++) {small_values [i+128] = ใหม่จำนวนเต็ม (i); - เมื่อเราประกาศจำนวนเต็ม c = 100; ในเวลานี้การดำเนินการชกมวยอัตโนมัติจะดำเนินการ เพื่อให้ง่ายมันหมายถึงการแปลงชนิดข้อมูลพื้นฐานเป็นวัตถุจำนวนเต็มและแปลงเป็นวัตถุจำนวนเต็มเป็นวิธีการที่เรียกว่า คุณจะเห็นว่า -128-127 ถูกแคชเป็นจำนวนเต็ม คำอธิบายอย่างเป็นทางการคือมีการใช้จำนวนน้อยบ่อยขึ้นดังนั้นเพื่อเพิ่มประสิทธิภาพการทำงานตัวเลขระหว่างพวกเขาจะถูกแคช นี่คือเหตุผลที่คำตอบสำหรับคำถามนี้เป็นเท็จและ ture เมื่อค่าของวัตถุจำนวนเต็มที่ประกาศอยู่ระหว่าง -128-127 วัตถุเดียวกันจะถูกอ้างอิงดังนั้นผลลัพธ์จึงเป็นจริง
2. สตริง
จากนั้นดูรหัส
สตริง S1 = "ABC"; สตริง s2 = "abc"; สตริง s3 = สตริงใหม่ ("abc"); System.out.println (S1 == S2); System.out.println (S1 == S3); มาเดาว่าคำตอบสำหรับคำถามนี้คืออะไร?
ตามไวยากรณ์ของ == ก่อนอื่น S1, S2 และ S3 เป็นวัตถุที่แตกต่างกันสามชิ้น สามัญสำนึกผลลัพธ์ทั้งหมดจะเป็นเท็จ อย่างไรก็ตามผลลัพธ์การทำงานของโปรแกรมนั้นเป็นจริงและเท็จ เอาท์พุทที่สองเป็นสิ่งที่เข้าใจได้และเอาต์พุตครั้งแรกจริงก็ทำให้งงอีกครั้ง เรารู้ว่าตัวแปรประเภทพื้นฐานบางตัวและตัวแปรอ้างอิงของวัตถุถูกจัดสรรในหน่วยความจำสแต็กของฟังก์ชั่นในขณะที่วัตถุและอาร์เรย์ใหม่จะถูกเก็บไว้ในหน่วยความจำฮีป อย่างไรก็ตามนอกจากนี้ยังมีพื้นที่อื่นที่เรียกว่าสระว่ายน้ำคงที่ เช่นเดียวกับที่เราต้องการสตริง s1 = "abc";, ค่าของวัตถุสตริงที่ประกาศจะถูกเก็บไว้ในพูลคงที่ เมื่อเราสร้างวัตถุเช่น String S1 = "ABC", "ABC" ถูกเก็บไว้ในพูลคงที่ (เรียกอีกอย่างว่าพูลสตริง) เมื่อเราสร้างสตริงอ้างอิง S2 = "ABC" เลเยอร์พื้นฐานของ Java จะจัดลำดับความสำคัญการค้นหาว่ามี "ABC" อยู่ในสระคงที่หรือไม่ หากมีอยู่ให้ S2 ชี้ไปที่ค่านี้และจะไม่สร้างใหม่ หากไม่มีสระว่ายน้ำคงที่จะถูกสร้างและเพิ่มลงในสระว่ายน้ำ นั่นเป็นเหตุผลว่าทำไมคำตอบจึงเป็นจริงและเท็จ
3. คำหลักสุดท้าย <br /> ลองดูที่โค้ด
โมฆะสาธารณะ mrun (ชื่อสตริงสุดท้าย) {ใหม่ runnable () {โมฆะสาธารณะเรียกใช้ () {ลอง {thread.sleep (1,000); } catch (interruptedException e) {// toDo บล็อก catch block ที่สร้างขึ้นอัตโนมัติ E.PrintStackTrace (); } system.out.println (ชื่อ); } }.เริ่ม(); - ฉันเชื่อว่าทุกคนเขียนรหัสประเภทนี้มากมาย เมื่อคลาสภายในเข้าถึงตัวแปรท้องถิ่นพวกเขาจำเป็นต้องเพิ่มตัวดัดแปลงสุดท้ายก่อนที่ตัวแปรท้องถิ่นมิฉะนั้นคอมไพเลอร์จะรายงานข้อผิดพลาด โดยปกติเราจะทำเช่นเดียวกัน ตกลงคำถามที่สองคือทำไมต้องเพิ่มตัวดัดแปลงสุดท้าย? ฉันเชื่อว่าเพื่อนส่วนใหญ่ของฉันไม่เคยคิดเกี่ยวกับปัญหานี้ เมื่อใดก็ตามที่พวกเขาใช้มันเพียงเพิ่มมันโดยตรงและไม่เคยเจาะลึกลงไปในหลักการ สิ่งนี้ไม่เป็นที่พึงปรารถนาสำหรับโปรแกรมเมอร์ที่ยอดเยี่ยม เราต้องไม่เพียง แต่รู้ความจริง แต่ยังรวมถึงเหตุผล
ตอนนี้มาวิเคราะห์ว่าทำไมคุณต้องเพิ่มคำหลักสุดท้าย ก่อนอื่นวงจรชีวิตของชั้นเรียนภายในอยู่ในระดับสมาชิกในขณะที่วงจรชีวิตของตัวแปรท้องถิ่นอยู่ในร่างกายวิธีการ กล่าวอีกนัยหนึ่งสถานการณ์นี้จะเกิดขึ้น เมื่อวิธีการ MRUN ถูกดำเนินการเธรดใหม่จะทำงานและเธรดใหม่จะนอนเป็นวินาที เธรดหลักจะยังคงดำเนินการต่อไป MRUN จะถูกดำเนินการและวัฏจักรชีวิตของแอตทริบิวต์สิ้นสุดลง หลังจาก 1 วินาทีแล้ว syetem.out.printh (ชื่อ) จะถูกดำเนินการ อย่างไรก็ตามในเวลานี้ชื่อเสียชีวิตและไม่ได้อยู่ในความทรงจำอีกต่อไป Java คือการกำจัดข้อผิดพลาดนี้และต้องใช้ตัวแปรท้องถิ่นอย่างเคร่งครัดในคลาสภายในที่จะแก้ไขด้วยคำหลักขั้นสุดท้าย หลังจากตัวแปรโลคัลได้รับการแก้ไขโดยรอบชิงชนะเลิศแบบจำลองท้องถิ่นจะถูกเก็บไว้ในหน่วยความจำ เมื่อคลาสภายในเข้าถึงได้จะมีการเข้าถึงจริง นี่เป็นเหมือนการทำให้วงจรชีวิตของตัวแปรท้องถิ่นนานขึ้น ท้ายที่สุดมันเป็นวิศวกร Java ที่เติมเต็มในหลุมนี้ให้เราล่วงหน้ามิฉะนั้นฉันสงสัยว่ามีเพื่อนกี่คนที่จะกังวลเกี่ยวกับตัวแปรภายในท้องถิ่น
4. จำนวนเต็มและ int
ดูรหัสต่อไปนี้
จำนวนเต็ม a = จำนวนเต็มใหม่ (1,000); int b = 1,000; จำนวนเต็ม c = จำนวนเต็มใหม่ (10); จำนวนเต็ม d = จำนวนเต็มใหม่ (10); System.out.println (a == b); System.out.println (c == d);
คำถามนี้คือการติดตามคำถามแรก หากคุณสามารถรับคำตอบสำหรับคำถามนี้ได้อย่างรวดเร็วขอแสดงความยินดีแม้ว่าคุณจะเชี่ยวชาญฟังก์ชั่นการเปรียบเทียบ == อย่างละเอียดมากขึ้น
เปิดเผยคำตอบที่ถูกต้อง: จริงเท็จ
เพื่อนหลายคนงงงวยหลังจากเห็นคำตอบนี้ มาพูดถึงเรื่องที่สองก่อน ตามคำถามแรกไม่มีจำนวนเต็มแคช -128-127 ใช่ไหม สิ่งนี้ควรเป็นจริง แต่ถ้าคุณมองอย่างใกล้ชิดจำนวนเต็มที่นี่จะถูกสร้างขึ้นโดยเราไม่ได้ใช้แคชดังนั้นผลลัพธ์จึงเป็นเท็จ ทีนี้มาดูกันว่าทำไมคนแรกจึงเป็นจริงอีกครั้ง? ก่อนอื่นค่าที่นี่คือ 1,000 ซึ่งไม่มีส่วนเกี่ยวข้องกับแคชจำนวนเต็มอย่างที่เรารู้ เนื่องจากมันไม่มีส่วนเกี่ยวข้องกับแคช A จึงเป็นวัตถุจากใหม่ใหม่อินพุตควรเป็นเท็จ แต่โปรดทราบว่า B เป็นประเภท int ที่นี่ เมื่อ Int และ Integer Compare ==, Java จะยกเลิกจำนวนเต็มโดยอัตโนมัตินั่นคือแปลงจำนวนเต็มเป็นประเภท int ดังนั้นค่าของประเภท int จะถูกเปรียบเทียบที่นี่ดังนั้นผลลัพธ์จึงเป็นจริง
หลังจากทำคำถามสองสามข้ออย่างถูกต้องแล้วรีบตรวจสอบการละเว้นและเติมช่องว่างตามระดับการทดสอบของคุณเอง!