การใช้หมายเหตุประกอบ null

NullPointerException เป็นหนึ่งในสาเหตุของความล้มเหลวส่วนใหญ๋ของโปรแกรม Java ในกรณีง่ายที่สุดคอมไพลเลอร์สามารถเตือนคุณโดยตรงเมื่อเห็นโค้ดเช่นนี้:

    Object o = null;
    String s = o.toString();

ด้วยการแตกกรณี / การวนซ้ำ และการเกิด exceptions ค่อนข้างเป็น การวิเคราะห์โฟลว์ ที่ซับซ้อน จะเป็นสิ่งจำเป็นเพื่อค้นหาว่ามีตัวแปรที่ไม่ถูกอ้างอิงถูกกำหนดให้มีค่า null / ไม่ null บนพาธบางพาธหรือทั้งหมดในโปรแกรมหรือไม่

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

การวิเคราะห์ null ระหว่างโพรซีเดอร์

นี้คือหมายเหตุประกอบ null ที่จะมาเกี่ยวข้อง โดยการระบุพารามิเตอร์เมธอดเป็น @NonNull คุณสามารถแจ้งคอมไพลเลอร์ ว่าคุณไม่ ต้องการ ค่า null ในตำแหน่งนี้

    String capitalize(@NonNull String in) {
        return in.toUpperCase();                // no null check required
    }
    void caller(String s) {
        if (s != null)
            System.out.println(capitalize(s));  // preceding null check is required
    }

ในการใช้งาน Design-by-Contract ค่านี้มีสองด้าน:

  1. โดยถือเป็น ความรับผิดชอบ ของผู้เรียกใช้ ที่จะต้องไม่ส่งค่า null เพื่อให้แน่ใจ เช่นโดยการตรวจสอบ null โดยชัดแจ้ง
  2. ผู้ประยุกต์ใช้ เมธอด capitalize การ รับประกัน ว่าอาร์กิวเมนต์ in จะไม่เป็น null ดังนั้นการยกเลิกการอ้างอิงโดยไม่มีการตรวจสอบค่า null สามารถทำได้ที่นี่

สำหรับค่าส่งคืนเมธอดที่สถานการณ์เป็นแบบสมมาตร:

    @NonNull String getString(String maybeString) {
        if (maybeString != null)
            return maybeString;                         // the above null check is required
        else
            return "<n/a>";
    }
    void caller(String s) {
        System.out.println(getString(s).toUpperCase()); // no null check required
    }
  1. ขณะนี้ผู้ประยุกต์ใช้ต้องให้แน่ในว่าไม่มีการส่งคืนค่า null
  2. ในทางกลับกัน ขณะนี้ผู้เรียกใช้ต้องรับกประกันว่าการยกเลิกการอ้างอิง ผลลัพธ์เมธอดโดยไม่มีการตรวจสอบสามารถทำได้

หมายเหตุประกอบที่มีอยู่

คอมไพลเลอร์ Eclipse Java สามารถถูก กำหนดค่า เพื่อใช้ชนิดหมายเหตุประกอบต่างกันสามชนิด สำหรับการวิเคราะห์ null ที่พัฒนา (ซึ่งถูกปิดใช้งานโดยดีฟอลต์):

หมายเหตุประกอบ @NonNull และ @Nullable ได้รับการสนับสนุนในตำแหน่งเหล่านี้:

@NonNullByDefault ได้รับการสนับสนุน

โปรดสังเกตว่า แม้ชื่อที่ระบุจริงของหมายเหตุประกอบเหล่านี้สามารถ กำหนดค่าได้ แต่โดยดีฟอลต์จะใช้ชื่อที่กำหนดด้านบน (จากแพ็กเกจ org.eclipse.jdt.annotation)

การตั้งค่า build path

JAR ที่มีหมายเหตุประกอบ null ดีฟอลต์มาพร้อมกับ Eclipse ใน eclipse/plugins/org.eclipse.jdt.annotation_*.jar JAR นี้ต้องอยู่บน build path ขณะคอมไพล์แต่ไม่จำเป็นขณะรันไทม์ (ดังนั้นคุณไม่จำเป็นต้องเตรียมสิ่งนี้สำหรับผู้ใช้ของโค้ดที่ถูกคอมไพล์ของคุณ)

มีตัวแก้ไขปัญหาแบบด่วนสองตัวบนการอ้างอิงที่ถูกแก้ไขไม่ได้ไปยัง @NonNull, @Nullable หรือ @NonNullByDefault ที่เพิ่ม JAR เข้ากับ build path:

การแปลความหมายหมายเหตุประกอบ null

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

  1. คำแนะนำเป็นระยะสำหรับตัวอ่าน (บุคคลหรือคอมไพลเลอร์)
  2. ออกแบบตามสัญญา: ข้อมูลจำเพาะ API สำหรับเมธอดบางส่วนและทั้งหมด
  3. ข้อมูลจำเพาะทั้งหมดโดยใช้ระบบชนิดที่ขยายเพิ่ม

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

Design by contract: API specification

ในการแรก การใช้หมายเหตุประกอบ null สำหรับข้อมูลจำเพาะ API ใน Design by Contract เพียงหมายถึงลายเซ็นของเมธอด API ทั้งหมดที่ควรใส่หมายเหตุประกอบแบบครบถ้วน เช่น ยกเว้นสำหรบัชนิด primitive เช่น int ชนิดการส่งคืนแต่ละพารามิเตอร์ และแต่ละเมธอดควรทำเครื่องหมายเป็น @NonNull หรือ @Nullable ตั้งแต่นี้จะหมายถึงการแทรกหมายเหตุประกอบ null จำนวนมาก เป็นการดีที่ทราบว่าใน โค้ดที่ออกแบบอย่างดี (โดยเฉพาะเมธอด API) @NonNull ใช้บอก มากกว่า @Nullable หมายเลขจำนวนหมายเหตุประกอบสามารถลดลงโดย การประกาศ @NonNull เป็น default โดยใช้หมายเหตุประกอบ @NonNullByDefault ที่ระดับแพ็กเกจ

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

ด้วยพื้นฐานเหล่านี้ เราสามารถแม็พหมายเหตุประกอบพารามิเตอร์ทั้งหมดกับ เงื่อนไขล่วงหน้า ได้โดยตรงและ แปลหมายเหตุประกอบการส่งคืนเป็น เงื่อนไขภายหลัง ของเมธอด

การระบุชนิดย่อยและการแทนที่

ในโปรแกรมมิงแบบอ็อบเจ็กต์ แนวคิดของ Design by Contract ต้องแอดเดรสมากขึ้นหนึ่งมิติ: การระบุชนิดย่อย และการแทนที่ (ผลของคำว่า "แทนที่" จะถูกใช้ในแง่ของ หมายเหตุประกอบ @Override ใน Java 6: methods overriding or implementing another method from a super-type) ไคลเอ็นต์เรียกใช้เมธอดังนี้:

    @NonNull String checkedString(@Nullable String in)

ควรให้ถือว่า การประยุกต์ใช้ทั้งหมด ของเมธอดนี้เติมเต็มสัญญาแล้ว ดังนั้นเมื่อพบการประกาศเมธอดใน I1 เราต้องไม่ยอมรับคลาสใดๆ Cn ประยุกต์ใช้ I1 มี การประยุกต์ใช้ที่เข้ากันไม่ได้ โดยเฉพาะอย่างยิ่ง ไม่ถูกต้องถ้ามี Cn พยายาม แทนที่เมธอดนี้ด้วยการประยุกต์ใช้ที่ประกาศพารามิเตอร์เป็น @NonNull ถ้าเรา จะ อนุญาตวิธีนี้ ไคลเอ็นต์โมดูลที่โปรแกรมจาก I1 สามารถส่งค่า null เป็นอาร์กิวเมนต์ได้อย่างถูกต้องแต่การประยุกต์ใช้อาจถือว่าเป็นค่าที่ไม่เป็น null - การยกเลิกการอ้างถึงที่ไม่ถูกทำเครื่องหมายภายในการประยุกต์ใช้เมธอดจะได้รับอนุญาตแต่ขยายขึ้นในตอนรันไทม์ ดังนั้น ข้อมูลจำเพาะพารามิเตอร์ @Nullable บังคับใช้การแทนที่ทั้งหมด เพื่อยอมรับ null เป็นค่าถูกต้องที่ต้องการ

ในทางกลับกัน ข้อมูลจำเพาะการส่งคืน @NonNull บังคับการแทนที่ทั้งหมด เพื่อให้แน่ใจว่าจะไม่มีการส่งคืน null

ดังนั้น คอมไพลเลอร์ต้องตรวจสอบว่าไม่มีการแทนที่ใดที่เพิ่มหมายเหตุประกอบพารามิเตอร์ @NonNull (หรือพารามิเตอร์การส่งคืน @Nullable) ที่ไม่มีอยู่ใน super-type

สิ่งที่น่าสนใจ การนิยามอีกครั้งแบบย้อนกลับจะถูกต้อง: การเพิ่มหมายเหตุประกอบพารามิเตอร์ @Nullable หรือหมายเหตุประกอบการส่งคืน @NonNull (คุณอาจพิจารณาว่าเป็น "การปรับปรุง" ของเมธอด โดยยอมรบค่ามากขึ้น และสร้างค่าส่งคืนที่เจาะจงมากขึ้น)

super-types เก่า

ข้อควรพิจารณาก่อนหน้านี้เพิ่มความยุ่งยากเมื่อโค้ดที่มีหมายเหตุประกอบถูกเขียนเป็น sub-type ของชนิด "เก่า" (เช่น ไม่มีหมายเหตุประกอบ) (ซึ่งอาจมาจากไลบรารีของบริษัทอื่น ดังนั้นไม่สามารถเปลี่ยนแปลง) ถ้าคุณอ่านส่วนล่าสุดอย่างระมัดระวัง คุณอาจเห็นว่าเราไม่สามารถยอมรับ เมธอด "เก่า" ที่ถูกแทนที่โดยเมธอดที่มีพารามิเตอร์ @NonNull (เนื่องจากไคลเอ็นต์ที่ใช้ super-type ไม่ "เห็น " การบังคับใช้ @NonNull)

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

การยกเลิกค่าดีฟอลต์ที่เป็น null

สถานการณ์จะยุ่งยาก ถ้า sub-type ของชนิด "เก่า" มีอยู่ในแพ็กเกจซึ่ง @NonNullByDefault ถูกระบุ ในตอนนี้ชนิดที่มี super-type ไม่ถูกใส่หมายเหตุประกอบ จะต้องทำเครื่องหมายพารามิเตอร์ทั้งหมดในเมธอดการแทนที่เป็น @Nullable: แม้การข้ามหมายเหตุประกอบพารามิเตอร์ไม่ได้รับอนุญาตเนื่องจากจะถูกแปลให้เหมือนพารามิเตอร์ @NonNull ซึ่งถูกห้ามใช้ในตำแหน่งนั้น นั่นคือเหตุผลที่คอมไพลเลอร์ Eclipse Java สนับสนุนการยกเลิก ค่าดีฟอลต์ null: โดยการใส่หมายเหตุประกอบเมธอด หรือชนิดที่มี @NonNullByDefault(false) ค่าดีฟอลต์ที่ใช้ได้จะถูกยกเลิกสำหรับอิลิเมนต์นี้ และพารามิเตอร์ที่ไม่ถูกใส่หมายเหตุประกอบถูกแปลอีกครั้งเป็น ไม่ถูกระบุ ขณะนี้ sub-typing จะใช้ได้อีกครั้งโดยไม่เพิ่มหมายเหตุประกอบ @Nullable ที่ไม่ต้องการ:

class LegacyClass {
    String enhance (String in) { // clients are not forced to pass nonnull.
        return in.toUpperCase();
    }
}
 
@NonNullByDefault
class MyClass extends LegacyClass {
	
    // ... methods with @NonNull default ...
 
    @Override
    @NonNullByDefault(false)
    String enhance(String in) { // would not be valid if @NonNullByDefault were effective here
        return super.enhance(in);
    }
}

ประโยชน์ของ Design-by-Contract

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

นอกจากนั้น จากข้อมูลจำเพาะอินเตอร์เฟสนี้ การวิเคราะห์โฟลว์ระหว่างโพรซีเดอร์สามารถ เลือกข้อมูลที่มี และแสดงข้อผิดพลาด/คำเตือนที่มีความสำคัญมากยิ่งขึ้น หากปราศจากหมายเหตุประกอบ ค่าใดๆ ที่โฟลว์เข้าหรืออกจากเมธอดมีค่า null ที่ไม่รู้จัก ดังนั้นการวิเคราะห์ null ยังคงไม่แสดงสิ่งใดเกี่ยวกับการใช้งาน ด้วยหมายเหตุประกอบ null ระดับ API ค่า null ของค่าส่วนใหญ่จะทราบจริง และมี NPEs น้อยมากที่จะไม่ทราบโดยคอมไพลเลอร์ อย่างไรก็ตาม คุณควรทราบว่ายังคงมี loopholes อยู่ โดยที่ค่าที่ ไม่ได้ระบุโฟลว์อยู่ในการวิเคราะห์ ทำให้ไม่สามารถดำเนินการข้อความสั่งได้เสร็จไม่ว่า NPEs จะ เกิดขึ้นตอนรันไทม์หรือไม่

ดำเนินการข้อมูลจำเพาะโดยใช้ระบบชนิดที่ขยาย

การสนับสนุนหมายเหตุประกอบ null ได้ถูกกำหนดในวิธีที่เข้ากันได้ กับส่วนขยายในอนาคต โดยที่คอมไพลเลอร์จะสามารถรับประกันได้ว่าโปรแกรม ที่ได้รับการรับรองจะไม่ก่อให้เกิด NullPointerException ตอนรันไทม์ (ที่มี caveats ทั่วไป เกี่ยวกับส่วนที่ไม่สามารถตรวจสอบได้เช่น reflection) ขณะที่ไม่มีการให้สัญญาเกี่ยวกับส่วนใหญ่ที่จะมีในอนาคต แนวคิดพื้นฐาน ก็คือการแปลความหมายที่แตกต่างกันของสิ่งที่เรามีอยู่แล้ว

โดยการแปลหมายเหตุประกอบ null เป็นส่วนหนึ่งของระบบชนิดเราดับเบิลจำนวน ชนิดในโปรแกรมที่กำหนด: สำหรับคลาสที่กำหนด Cn คลาสเอง ไม่ถูกพิจารณาว่าเป็นชนิดถูกต้องอีกต่อไป แต่ "@NonNull Cn" และ "@Nullable Cn" เท่านั้นที่เป็นชนิดที่ใช้ประโยชน์ได้ ดังนั้น โดยหลักการแล้วทุกค่าในโปรแกรม เราจะทราบว่าสามารถเป็น null (และต้องตรวจสอบก่อนยกเลิกการอ้างอิง) หรือไม่ ถ้าเราไม่รวมอ็อพชันที่สาม (ชนิดที่ไม่มีหมายเหตุประกอบ) คอมไพลเลอร์อาจแฟล็ก ทุก การใช้งานที่ไม่ปลอดภัยอย่างเข้มงวด

การประยุกต์ใช้ปัจจุบันมีข้อจำกัดหลักๆ สองข้อเกี่ยวกับเป้าหมายนี้:

ณ วันนี้ และไม่ว่าข้อจำกัดปัจจุบันเป็นอย่างไร การมองเห็นโปรแกรมที่ตรวจสอบ อย่างสมบูรณ์และระบุแบบครบถ้วนจะมีความหมายโดยนัยอยู่แล้วว่ากำหนดการวิเคราะห์ ปัจจุบัน และข้อผิดพลาด/คำเตือนที่รายงานโดยคอมไพลเลอร์ รายละเอียดจะถูกแสดงโดยการอธิบายกฏที่คอมไพลเลอร์ตรวจสอบ และข้อความที่เกิดขึ้นเมื่อมีการละเมิดกฏ

ข้อความคอมไพลเลอร์ที่อธิบาย

บนเพจการกำหนดค่าตามความชอบ ที่สอดคล้องกัน กฏแต่ละข้อถูกตรวจสอบโดยคอมไพลเลอร์จะอยู่ภายใต้ส่วนหัวต่อไปนี้:

การละเมิดข้อมูลจำเพาะ null

เนื่องจากการละเมิดข้อมูลจำเพาะเราจัดการสถานการณ์ใดๆ ที่หมายเหตุประกอบ null อ้างว่าถูกละเมิดโดยการประยุกต์ใช้จริง สถานการณ์ทั่วไปให้ผลลัพธ์ จากการระบุค่า (โลคัล, อาร์กิวเมนต์, ส่งคืนเมธอด) เป็น @NonNull ขณะที่ การประยุกต์ใช้จริงระบุค่าที่เป็น null ได้ ต่อไปนี้คือนิพจน์ที่พิจารณาว่า เป็น null ได้ถ้าโดยปกติทราบว่าประเมินค่าเป็น null หรือถ้าถูกประกาศ ด้วยหมายเหตุประกอบ @Nullable

อย่างที่สอง กลุ่มนี้ยังมีกฏสำหรับเมธอดการแทนที่ดังที่อธิบาย ด้านบน ต่อไปนี้เมธอด super จะสร้างการอ้างอิง (เช่น ค่า null นั้นเป็นอาร์กิวเมนต์ที่ถูกต้อง) ขณะที่การแทนที่พยายามลองหลบเลี่ยงข้ออ้างนี้ (โดยสมมติว่าค่า null นั้น ไม่ใช่ อาร์กิวเมนต์ที่ถูกต้อง) ดังกล่าวถึงเมื่อให้อาร์กิวเมนต์เป็นค่าพิเศษจากที่ไม่มีหมายเหตุประกอบเป็น @NonNull คือการละเมิดข้อมูลจำเพาะ เนื่องจากค่ามีสัญญาว่าควรโยงโคลเอ็นต์ (ที่จะไม่ส่ง null) แต่ไคลเอ็นต์ใช้ super-type ที่ไม่รู้จักสัญญานี้ ดังนั้นไคลเอ็นต์จะไม่ทราบถึงสิ่งที่ถูกคาดหวัง

รายการสถานการณ์แรกเกี่ยวกับการละเมิดข้อมูลจำเพาะถูกกำหนด ที่นี่ สิ่งสำคัญคือต้องเข้าใจว่าข้อผิดพลาดในกลุ่มนี้ ไม่ควรถูกข้าม เนื่องการวิเคราะห์ null ทั้งหมดจะถูกดำเนินการตามสมมติฐานที่ผิด โดยเฉพาะอย่างยิ่ง เมื่อคอมไพลเลอร์เห็นค่าที่มีหมายเหตุประกอบ @NonNull คอมไพลเลอร์จะถือเอาว่า null จะไม่มีทางเกิดขึ้นตอนรันไทม์ ซึ่งเป็นกฏเกี่ยวกับการละเมิดข้อมูลจำเพาะซึ่งทำให้แน่ใจว่าการให้เหตุผลเช่นนี้เหมาะสม ดังนั้น ขอแนะนำอย่างยิ่งให้คงปัญหาประเภทนี้ถูกกำหนดเป็น ข้อผิดพลาด ไว้

ความขัดแย้งระหว่างหมายเหตุประกอบ null และการอนุมาน null

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

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

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

ลักษณะการวิเคราะห์สแตติกที่กำหนด การวิเคราะห์โฟลว์อาจไม่สามารถเห็นว่า การใช้พาธการเรียกใช้งานร่วมกันกับค่าจะไม่สามารถเป็นไปได้ เนื่องจากตัวอย่าง พิจารณา ความสัมพันธ์ของตัวแปร:

   String flatten(String[] inputs1, String[] inputs2) { 
        StringBuffer sb1 = null, sb2 = null;
        int len = Math.min(inputs1.length, inputs2.length);
        for (int i=0; i<len; i++) {
            if (sb1 == null) {
                sb1 = new StringBuffer();
                sb2 = new StringBuffer();
            }
            sb1.append(inputs1[i]);
            sb2.append(inputs2[i]); // warning here
        }
        if (sb1 != null) return sb1.append(sb2).toString();
        return "";
    }

คอมไพลเลอร์จะรายงานการเข้าถึงตัวชี้ null สำคัญที่การเรียกใช้ sb2.append(..). ผู้อ่านสามารถเห็นได้ว่าไม่มีอันตรายจริงเนื่องจากจริงๆ แล้ว sb1 และ sb2 สัมพันธ์กันในแนทางที่ตัวแปรทั้งสองเป็น null หรือทั้งสองไม่เป็น null สำหรับคำถามที่ว่า sb1 ไม่ใช่ null ดังนั้น sb2 ไม่ใช่ null ด้วย โดยไม่ได้เข้าดูในรายละเอียดว่าทำไมการวิเคราะห์ความสัมพันธ์นั้นจึงเกินความสามารถ ของคอมไพลเลอร์ Eclipse Java โปรดจำไว้ว่าการวิเคราะห์นี้ไม่มีประสิทธิภาพ ของ theorem prover ทั้งหมด ดังนั้นความสามารถรายงานปัญหาบางอย่างซึ่งการวิเคราะห์ที่มีความสามารถ มากกว่าก็อาจระบุข้อผิดพลาดไม่ถูกต้องได้

ถ้าคุณต้องการใช้ประโยชน์จากการวิเคราะห์โฟลว์ ขอแนะนำให้คุณให้ความช่วยเหลือเล็กน้อยแก่คอมไพลเลอร์ เพื่อให้สามารถ "เห็น" ข้อสรุปของคุณ การช่วยนี้อาจเป็นเพียงการแบ่ง if (sb1 == null) ออกเป็นสอง ifs แยกกัน หนึ่งสำหรับตัวแปรโลคัลแต่ละตัว ซึ่งเสียเวลาไม่มากเพื่อ ให้ได้รับประโยชน์ที่ตอนนี้คอมไพลเลอร์สามารถเห็นสิ่งที่เกิดขึ้นและตรวจสอบโค้ดของคุณได้ การสนทนาส่วนใหญ่เกี่ยวกับหัวข้อนี้จะมีอยู่ ด้านล่าง

เลิกทำเครื่องหมายการแปลงจากชนิดที่ไม่ใช่หมายเหตุประกอบเป็นชนิด @NonNull

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

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

    @SuppressWarnings("null")
    @NonNull Foo foo = Library.getFoo(); // implicit conversion
    foo.bar(); 

Snippet โค้ดด้านบนถือว่า Library.getFoo() ส่งคืน Foo โดยไม่ระบุหมายเหตุประกอบ null เราสามาราถรวมค่าส่งคืนเข้าในโปรแกรม ที่มีหมายเหตุประกอบโดยการกำหนดค่าให้แก่ตัวแปรโลคัล @NonNull ซึ่งทริกเกอร์คำเตือน เกี่ยวกับการแปลงที่ไม่มีการตรวจสอบ โยดการเพิ่ม SuppressWarnings("null") ที่สอดคล้องกันในการประกาศนี้ ถือว่าเรารับทราบอันตรายและยอมรับความรับผิดชอบที่ต้องตรวจสอบว่า ไลบรารีดำเนินการตามที่ต้องการจริง

คำแนะนำเพื่อให้สร้างโค้ดที่วิเคราะห์ได้ดีขึ้น

ถ้าการวิเคราะห์โฟลว์ไม่สามารถเห็นว่าจริงๆ แล้วค่าไม่ใช่ null กลยุทธ์ที่ง่ายที่สุดคือเพิ่ม ตัวแปรโลคัลที่สองที่มีหมายเหตุประกอบเป็น @NonNull เสมอ จากนั้น ถ้าคุณแน่ใจว่าค่าที่กำหนดให้แก่ค่าโลคัลนี้จะไม่เป็น null ตอนรันไทม์ คุณสามารถใช้เมธอด helper ดังนี้:

    static @NonNull <T> T assertNonNull(@Nullable T value, @Nullable String msg) {
        if (value == null) throw new AssertionError(msg);
        return value;
    }
    @NonNull MyType foo() {
        if (isInitialized()) {
            MyType couldBeNull = getObjectOrNull();
            @NonNull MyType theValue = assertNonNull(couldBeNull, 
                    "value should not be null because application " +
                    "is fully initialized at this point.");
            return theValue;
        }
        return new MyTypeImpl();
    }

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

คำแนะนำสำหรับการปรับใช้หมายเหตุประกอบ null

ในการรีลีส JDT เวอร์ชัน 3.8.0 การรวบรวมคำแนะนำสำหรับปรับใช้หมายเหตุประกอบ null ยังคงมีการดำเนินการอยู่ ด้วยเหตุนั้น ขณะนี้ข้อมูลนี้ยังคงได้รับการเก็บไว้ใน วิกิ Eclipse