“ สิ่งนี้” สามารถเป็นค่าว่างใน Java ได้หรือไม่

เห็นบรรทัดนี้ในวิธีการคลาสและปฏิกิริยาแรกของฉันคือการเยาะเย้ยนักพัฒนาที่เขียนมัน .. แต่แล้วฉันคิดว่าฉันควรแน่ใจว่าฉันคิดถูกก่อน

public void dataViewActivated(DataViewEvent e) {
    if (this != null)
        // Do some work
}

เส้นนั้นจะประเมินเป็นเท็จหรือไม่?

ไม่มันไม่ได้ หากคุณกำลังใช้thisว่าคุณอยู่ในอินสแตนซ์จึงthisไม่เป็นโมฆะ

JLS กล่าวว่า:

เมื่อใช้เป็นนิพจน์หลักคีย์เวิร์ดนี้แสดงถึงค่าที่อ้างอิงไปยังอ็อบเจ็กต์ที่เรียกใช้เมธอดอินสแตนซ์ (§15.12) หรือกับอ็อบเจ็กต์ที่กำลังสร้าง

หากคุณเรียกใช้เมธอดจากอ็อบเจกต์แสดงว่าอ็อบเจ็กต์นั้นมีอยู่หรือคุณจะมีNullPointerExceptionมาก่อน (หรือเป็นวิธีการคงที่ แต่คุณไม่สามารถใช้thisมันได้)

แหล่งข้อมูล:

• JLS - thisคำหลัก

เหมือนกับถามตัวเองว่า "ฉันยังมีชีวิตอยู่ไหม" thisไม่สามารถเป็นโมฆะได้

ไม่เลยคีย์เวิร์ด "this" แสดงถึงอินสแตนซ์ที่มีชีวิตปัจจุบัน (อ็อบเจ็กต์) ของคลาสนั้นภายในขอบเขตของคลาสนั้นซึ่งคุณสามารถเข้าถึงฟิลด์และสมาชิกทั้งหมด (รวมถึงคอนสตรัคเตอร์) และคีย์เวิร์ดที่มองเห็นได้ของคลาสพาเรนต์

และที่น่าสนใจยิ่งกว่านั้นลองตั้งค่า:

this = null;

ลองคิดดู? มันจะเป็นไปได้ยังไงมันจะไม่เหมือนกับการตัดกิ่งไม้ที่คุณกำลังนั่งอยู่ เนื่องจากคีย์เวิร์ด 'this' อยู่ในขอบเขตของคลาสดังนั้นทันทีที่คุณพูด this = null; ที่ใดก็ได้ในชั้นเรียนโดยทั่วไปคุณจะขอให้ JVM ปลดปล่อยหน่วยความจำที่กำหนดให้กับวัตถุนั้นในระหว่างการดำเนินการบางอย่างซึ่ง JVM ไม่สามารถอนุญาตให้เกิดขึ้นได้เนื่องจากจำเป็นต้องกลับมาอย่างปลอดภัยหลังจากเสร็จสิ้นการดำเนินการนั้น

ยิ่งไปกว่านั้นการพยายามthis = null;จะทำให้คอมไพเลอร์ผิดพลาด เหตุผลนั้นค่อนข้างง่ายคีย์เวิร์ดใน Java (หรือภาษาใด ๆ ) ไม่สามารถกำหนดค่าได้เช่นคีย์เวิร์ดไม่สามารถเป็นค่าด้านซ้ายของการดำเนินการกำหนดได้

ตัวอย่างอื่น ๆ คุณไม่สามารถพูดได้ว่า:

true = new Boolean(true);
true = false;

หากคุณรวบรวม-target 1.3หรือก่อนหน้านี้แล้วด้านนอก อาจจะthis nullหรืออย่างน้อยก็เคย ...

ไม่ใช่ในการเรียกเมธอดของอินสแตนซ์ของคลาสอินสแตนซ์จะต้องมีอยู่ thisตัวอย่างที่ถูกส่งผ่านไปโดยปริยายเป็นพารามิเตอร์กับวิธีการที่อ้างอิงโดย ถ้าthisเป็นเช่นnullนั้นจะไม่มีอินสแตนซ์ที่จะเรียกใช้เมธอด

การบังคับใช้ภาษานั้นไม่เพียงพอ VM จำเป็นต้องบังคับใช้ เว้นแต่ VM จะบังคับใช้คุณสามารถเขียนคอมไพเลอร์ที่ไม่บังคับใช้การตรวจสอบค่าว่างก่อนที่จะเรียกใช้เมธอดที่เขียนใน Java opcodes สำหรับวิธีการเช่นการภาวนา ได้แก่ การโหลดโทษเกี่ยวกับเรื่องนี้ไปยังกองเห็น: http://java.sun.com/docs/books/jvms/second_edition/html/Compiling.doc.html#14787 การแทนที่สิ่งนี้สำหรับการอ้างอิงว่างย่อมส่งผลให้การทดสอบเป็นเท็จ

ในเมธอดคลาสแบบคงที่thisไม่ได้กำหนดไว้เนื่องจากthisเชื่อมโยงกับอินสแตนซ์ไม่ใช่คลาส ฉันเชื่อว่ามันจะทำให้คอมไพเลอร์มีข้อผิดพลาดในการพยายามใช้thisคีย์เวิร์ดในบริบทคงที่

ปกติthisไม่สามารถnullอยู่ในโค้ด Java ¹จริงได้และตัวอย่างของคุณใช้แบบปกติthisและตัวอย่างของคุณใช้ตามปกติดูคำตอบอื่น ๆ สำหรับรายละเอียดเพิ่มเติม

ที่มีคุณภาพและthis ควรไม่เป็นnullแต่เป็นไปได้ที่จะทำลายนี้ พิจารณาสิ่งต่อไปนี้:

public class Outer {
   public Outer() {}

   public class Inner {
       public Inner() {}

       public String toString() {
           return "outer is " + Outer.this;  // Qualified this!!
       }
   }
}

เมื่อเราต้องการสร้างอินสแตนซ์Innerเราต้องทำสิ่งนี้:

public static void main(String[] args) {
    Outer outer = new Outer();
    Inner inner = outer.new Inner();
    System.out.println(inner);

    outer = null;
    inner = outer.new Inner();  // FAIL ... throws an NPE
}

ผลลัพธ์คือ:

outer is Outer@2a139a55
Exception in thread "main" java.lang.NullPointerException
        at Outer.main(Outer.java:19)

แสดงว่าความพยายามของเราในการสร้างInnerโดยnullอ้างอิงถึงOuterล้มเหลว

ในความเป็นจริงถ้าคุณติดภายในซอง "Pure Java" คุณจะไม่สามารถทำลายสิ่งนี้ได้

อย่างไรก็ตามแต่ละInnerอินสแตนซ์มีfinalฟิลด์สังเคราะห์ที่ซ่อนอยู่(เรียกว่า"this$0") ซึ่งมีการอ้างอิงถึงไฟล์Outer. หากคุณมีเล่ห์เหลี่ยมจริงๆคุณสามารถใช้วิธี "ไม่บริสุทธิ์" เพื่อกำหนดnullให้กับฟิลด์ได้

• คุณสามารถใช้ Unsafeเพื่อทำมัน
• คุณสามารถใช้โค้ดเนทีฟ (เช่น JNI) เพื่อทำได้
• คุณสามารถทำได้โดยใช้การสะท้อน

ไม่ว่าคุณจะทำด้วยวิธีใดผลลัพธ์สุดท้ายก็คือOuter.thisนิพจน์จะประเมินเป็นnull² 2

ในระยะสั้นจะเป็นไปได้สำหรับการที่มีคุณสมบัติที่จะเป็นthis nullแต่จะเป็นไปไม่ได้หากโปรแกรมของคุณปฏิบัติตามกฎ "Pure Java"

^{1 - ฉันลดกลเม็ดต่างๆเช่น "เขียน" bytecodes ด้วยมือและส่งต่อเป็น Java จริงปรับแต่ง bytecodes โดยใช้ BCEL หรือคล้ายกันหรือกระโดดลงในโค้ดเนทีฟและดำเนินการกับรีจิสเตอร์ที่บันทึกไว้ IMO นั่นไม่ใช่ Java สมมุติว่าสิ่งเหล่านี้อาจเกิดขึ้นเนื่องจากข้อบกพร่องของ JVM ... แต่ฉันจำไม่ได้ว่าทุกรายงานข้อผิดพลาด}

^{2 - จริงๆแล้ว JLS ไม่ได้บอกว่าพฤติกรรมจะเป็นอย่างไรและอาจขึ้นอยู่กับการนำไปใช้ ... เหนือสิ่งอื่นใด}

เมื่อคุณเรียกใช้วิธีการnullอ้างอิงNullPointerExceptionจะถูกส่งออกจาก Java VM นี่เป็นไปตามข้อกำหนดดังนั้นหาก Java VM ของคุณปฏิบัติตามข้อกำหนดอย่างเคร่งครัดthisก็จะไม่เป็นnullเช่นนั้น

thisหากวิธีการเป็นแบบคงที่แล้วมีไม่ใด ๆ ถ้าเมธอดเป็นเสมือนthisจะไม่สามารถเป็นโมฆะได้เนื่องจากในการเรียกใช้เมธอดเวลารันจะต้องอ้างอิง vtable โดยใช้thisตัวชี้ ถ้าเมธอดไม่ใช่เสมือนจริงก็เป็นไปได้ว่าthisเป็นโมฆะ

C # และ C ++ อนุญาตให้ใช้เมธอดที่ไม่ใช่เสมือน แต่ใน Java เมธอดที่ไม่คงที่ทั้งหมดเป็นเสมือนดังนั้นthisจะไม่เป็นโมฆะ

tl; dr, "this" สามารถเรียกได้จากเมธอดที่ไม่คงที่เท่านั้นและเราทุกคนรู้ว่าเมธอดแบบไม่คงที่ถูกเรียกจากอ็อบเจ็กต์บางประเภทซึ่งไม่สามารถเป็นโมฆะได้