ส่งคืน null เป็น int ที่ได้รับอนุญาตกับผู้ประกอบการที่ประกอบไปด้วยสามส่วน แต่ไม่ใช่ถ้ามีคำสั่ง

ลองดูโค้ด Java อย่างง่ายในตัวอย่างต่อไปนี้:

public class Main {

    private int temp() {
        return true ? null : 0;
        // No compiler error - the compiler allows a return value of null
        // in a method signature that returns an int.
    }

    private int same() {
        if (true) {
            return null;
            // The same is not possible with if,
            // and causes a compile-time error - incompatible types.
        } else {
            return 0;
        }
    }

    public static void main(String[] args) {
        Main m = new Main();
        System.out.println(m.temp());
        System.out.println(m.same());
    }
}

ในโค้ด Java ที่ง่ายที่สุดนี้temp()เมธอดไม่มีข้อผิดพลาดคอมไพเลอร์แม้ว่าชนิดส่งคืนของฟังก์ชันคือintและเราพยายามคืนค่าnull(ผ่านคำสั่งreturn true ? null : 0;) NullPointerExceptionเมื่อรวบรวมนี้ทำให้เห็นได้ชัดว่าข้อยกเว้นเวลาทำงาน

อย่างไรก็ตามปรากฏว่าสิ่งเดียวกันนั้นผิดถ้าเราเป็นตัวแทนของผู้ประกอบการที่ประกอบไปด้วยifคำสั่ง (ในsame()วิธีการ) ซึ่งจะออกข้อผิดพลาดในการรวบรวมเวลา! ทำไม?

คอมไพเลอร์ตีความnullว่าเป็นโมฆะอ้างอิงกับIntegerใช้กฎการ autoboxing / unboxing สำหรับผู้ประกอบการตามเงื่อนไข (ตามที่อธิบายไว้ในJava Language Specification, 15.25 ) และย้ายอย่างมีความสุข สิ่งนี้จะสร้างNullPointerExceptionเวลารันไทม์ซึ่งคุณสามารถยืนยันได้โดยลองทำดู

ผมคิดว่าตีความเรียบเรียง Java true ? null : 0เป็นIntegerแสดงออกซึ่งสามารถแปลงโดยปริยายอาจจะให้intNullPointerException

สำหรับกรณีที่สองนิพจน์nullเป็นประเภท null พิเศษดูดังนั้นรหัสreturn nullทำให้ไม่ตรงกันประเภท

ที่จริงทั้งหมดที่อธิบายไว้ในข้อมูลจำเพาะภาษา Java

ชนิดของนิพจน์เงื่อนไขถูกกำหนดดังนี้:

• หากตัวถูกดำเนินการที่สองและที่สามมีประเภทเดียวกัน (ซึ่งอาจเป็นประเภทที่เป็นโมฆะ) แสดงว่าเป็นประเภทของนิพจน์เงื่อนไข

ดังนั้น "โมฆะ" ในประเภทของคุณ(true ? null : 0)จะได้รับ int แล้ว autoboxed เพื่อจำนวนเต็ม

ลองสิ่งนี้เพื่อยืนยันสิ่งนี้(true ? null : null)และคุณจะได้รับข้อผิดพลาดของคอมไพเลอร์

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

สำหรับโอเปอเรเตอร์ที่มีเงื่อนไขข้อกำหนดภาษา Java §15.25“ ผู้ปฏิบัติตามเงื่อนไข? :” จะตอบคำถามนี้อย่างดีในกฎสำหรับวิธีการใช้การแปลงประเภท:

• หากตัวถูกดำเนินการที่สองและที่สามมีประเภทเดียวกัน (ซึ่งอาจเป็นประเภทที่เป็นโมฆะ) แสดงว่าเป็นประเภทของนิพจน์เงื่อนไข
  
  ใช้ไม่ได้เพราะไม่ได้เป็นnullint

---

• หากหนึ่งในตัวถูกดำเนินการที่สองและที่สามเป็นประเภทบูลีนและประเภทของตัวถูกอื่นเป็นประเภทบูลีนแล้วประเภทของการแสดงออกตามเงื่อนไขเป็นบูลีน
  
  ใช้ไม่ได้เพราะไม่nullว่ามิได้intเป็นหรือbooleanBoolean

---

• หากหนึ่งในตัวถูกดำเนินการที่สองและที่สามเป็นประเภท null และประเภทของตัวถูกดำเนินการเป็นประเภทการอ้างอิงประเภทของการแสดงออกตามเงื่อนไขเป็นประเภทการอ้างอิงนั้น
  
  ไม่ใช้เนื่องจากnullเป็นประเภท null แต่intไม่ใช่ประเภทอ้างอิง

---

• มิฉะนั้นหากตัวถูกดำเนินการตัวที่สองและสามมีประเภทที่แปลงได้ (§5.1.8) เป็นประเภทตัวเลขก็มีหลายกรณี: […] การ
  
  ใช้งาน: nullถือว่าเป็นประเภทที่แปลงได้เป็นประเภทตัวเลขและกำหนดไว้ใน§5.1 8“Unboxing แปลง” NullPointerExceptionที่จะโยน

สิ่งแรกที่ต้องจำไว้ก็คือผู้ประกอบการที่ประกอบไปด้วย Java มี "ประเภท" และนี่คือสิ่งที่คอมไพเลอร์จะตรวจสอบและพิจารณาไม่ว่าสิ่งที่ประเภทที่แท้จริง / จริงของพารามิเตอร์ที่สองหรือสามคือ ขึ้นอยู่กับปัจจัยหลายประการประเภทผู้ประกอบการที่ถูกกำหนดในรูปแบบที่แตกต่างกันตามที่แสดงในJava Language Specification 15.26

ในคำถามข้างต้นเราควรพิจารณากรณีสุดท้าย:

มิฉะนั้นตัวถูกดำเนินการที่สองและสามเป็นประเภทS1และS2ตามลำดับ ให้T1เป็นชนิดที่เป็นผลมาจากการใช้การแปลงมวยS1และให้T2เป็นชนิดที่เป็นผลมาจากการใช้การแปลงมวยS2 ชนิดของนิพจน์เงื่อนไขคือผลลัพธ์ของการใช้การแปลงการจับภาพ (.15.1.10) กับlub (T1, T2) (§15.12.2.7)

นี่คือไกลโดยกรณีที่ซับซ้อนมากที่สุดเมื่อคุณดูที่การใช้การแปลงจับ (§5.1.10)และส่วนใหญ่ของทั้งหมดในหลุบ (T1, T2)

ในภาษาอังกฤษธรรมดาและหลังจากการทำให้เข้าใจง่ายสุดขีดเราสามารถอธิบายขั้นตอนการคำนวณ "Least Common Superclass" (ใช่ลองคิดถึง LCM) ของพารามิเตอร์ที่สองและสาม สิ่งนี้จะทำให้เราเป็นผู้ประกอบการ "พิมพ์" อีกครั้งสิ่งที่ฉันเพิ่งพูดคือการทำให้เข้าใจง่ายมาก (พิจารณาคลาสที่ใช้อินเทอร์เฟซทั่วไปหลายตัว)

ตัวอย่างเช่นหากคุณลองทำสิ่งต่อไปนี้:

long millis = System.currentTimeMillis();
return(true ? new java.sql.Timestamp(millis) : new java.sql.Time(millis));

คุณจะสังเกตเห็นว่าประเภทของการแสดงออกตามเงื่อนไขนั้นเป็นjava.util.Dateเพราะ "Least Common Superclass" สำหรับTimestamp/ Timeคู่

เนื่องจากnullสามารถถูกล็อกอัตโนมัติกับสิ่งใด ๆ "Least Common Superclass" เป็นIntegerคลาสและนี่จะเป็นชนิดส่งคืนของนิพจน์เงื่อนไข (ตัวดำเนินการที่ประกอบไปด้วย) ด้านบน ค่าส่งคืนจะเป็นตัวชี้ null ของประเภทIntegerและนั่นคือสิ่งที่จะถูกส่งกลับโดยผู้ประกอบการที่ประกอบไปด้วย

ณ รันไทม์เมื่อ Java Virtual Machine ยกเลิกการIntegerทำเครื่องหมาย a NullPointerExceptionจะถูกส่งออกไป สิ่งนี้เกิดขึ้นเนื่องจาก JVM พยายามเรียกใช้ฟังก์ชันnull.intValue()ซึ่งnullเป็นผลมาจากการล็อคอัตโนมัติ

ในความคิดของฉัน (และเนื่องจากความคิดเห็นของฉันไม่ได้อยู่ในข้อกำหนดภาษา Java หลายคนจะพบว่ามันผิดอยู่ดี) คอมไพเลอร์ทำงานได้ไม่ดีในการประเมินการแสดงออกในคำถามของคุณ ระบุว่าคุณเขียนtrue ? param1 : param2คอมไพเลอร์ควรกำหนดทันทีว่าพารามิเตอร์แรกnull- จะถูกส่งกลับและควรสร้างข้อผิดพลาดคอมไพเลอร์ นี้จะค่อนข้างคล้ายกับเมื่อคุณเขียนและเรียบเรียงบ่นเกี่ยวกับรหัสใต้ห่วงและธงด้วยwhile(true){} etc...Unreachable Statements

กรณีที่สองของคุณค่อนข้างตรงไปตรงมาและคำตอบนี้ยาวเกินไปแล้ว ... ;)

แก้ไข:

หลังจากการวิเคราะห์อื่นฉันเชื่อว่าฉันผิดที่จะบอกว่าnullค่าสามารถบรรจุ / autoboxed เพื่ออะไร พูดคุยเกี่ยวกับระดับจำนวนเต็มมวยอย่างชัดเจนประกอบด้วยในการอัญเชิญnew Integer(...)คอนสตรัคหรืออาจจะเป็นInteger.valueOf(int i);(ผมพบว่ารุ่นนี้อยู่ที่ไหนสักแห่ง) อดีตจะขว้างNumberFormatException(และสิ่งนี้ไม่เกิดขึ้น) ในขณะที่สองจะไม่สมเหตุสมผลเนื่องจากintไม่สามารถnull...

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

private int temp() {

    if (true) {
        Integer x = null;
        return x;// since that is fine because of unboxing then the returned value could be null
        //in other words I can say x could be null or new Integer(intValue) or a intValue
    }

    return (true ? null : 0);  //this will be prefectly legal null would be refrence to Integer. The concept is one the returned
    //value can be Integer 
    // then null is accepted to be a variable (-refrence variable-) of Integer
}

เกี่ยวกับสิ่งนี้:

public class ConditionalExpressionType {

    public static void main(String[] args) {

        String s = "";
        s += (true ? 1 : "") instanceof Integer;
        System.out.println(s);

        String t = "";
        t += (!true ? 1 : "") instanceof String;
        System.out.println(t);

    }

}

ผลลัพธ์เป็นจริงจริง

Eclipse รหัสสี 1 ในการแสดงออกตามเงื่อนไขเป็น autoboxed

ฉันเดาว่าคอมไพเลอร์จะเห็นประเภทผลตอบแทนของการแสดงออกเป็นวัตถุ