深入探讨Java三目运算符的用法丨【奔跑吧！JAVA】

Java三目运算符

先看格式： (表达式1)?(表达式2):(表达式3)

对于三目运算符，第一个表达式的值必须是boolean类型的值，但是对后两个表达式的类型，则没有要求，也不必相同。但有时涉及类型转换，转的有点让人莫名奇妙的。

亲自试验之后，发现有如下情况：

首先，总的原则就是能自动类型转换的就自动转换；不能自动转的，就不转。（自动类型转换和自动拆/装箱，默认是拆箱吧？）

如：

    int a = 65;
        char b = 'A';
        Object o_11 = true ? a : b;
        Object o_12 = false ? a : b;
        System.out.println("o_11:   " + o_11.getClass());
        System.out.println("o_12:   " + o_12.getClass());
 
        int c = 65;
        String d = "A";
        Object o_21 = true ? c : d;
        Object o_22 = false ? c : d;
        System.out.println("o_21:   " + o_21.getClass());
        System.out.println("o_22:   " + o_22.getClass());

输出结果是：

o_11:   class java.lang.Integer
o_12:   class java.lang.Integer
o_21:   class java.lang.Integer
o_22:   class java.lang.String

下面在看一看具体的情况:
1.表达式2和表达式3都是常量：

这种情况的类型转换颇为复杂，看一看代码输出的结果吧

代码如下：

        Object o_31 = false ? 'A' : (int) 65;
        Object o_32 = false ? (byte) 65 : (int) 65;
        Object o_33 = false ? (short) 65 : (int) 65;
        Object o_34 = false ? 'A' : (byte) 65;
        Object o_35 = false ? 'A' : (short) 65;
        Object o_36 = false ? (short) 65 : (long) 65;
        Object o_37 = false ? (int) 65 : (double) 65;
        Object o_38 = false ? 'A' : (int) 65535;
        Object o_39 = false ? 'A' : (int) 65536;
        System.out.println("o_31:   " + o_31.getClass());
        System.out.println("o_32:   " + o_32.getClass());
        System.out.println("o_33:   " + o_33.getClass());
        System.out.println("o_34:   " + o_34.getClass());
        System.out.println("o_35:   " + o_35.getClass());
        System.out.println("o_36:   " + o_36.getClass());
        System.out.println("o_37:   " + o_37.getClass());
        System.out.println("o_38:   " + o_38.getClass());
        System.out.println("o_39:   " + o_39.getClass());

输出结果如下：

o_31:   class java.lang.Character
o_32:   class java.lang.Byte
o_33:   class java.lang.Short
o_34:   class java.lang.Integer
o_35:   class java.lang.Integer
o_36:   class java.lang.Long
o_37:   class java.lang.Double
o_38:   class java.lang.Character
o_39:   class java.lang.Integer

规律：前3中结果，int型是大类型，但是结果确实小类型的；中间4种结果，小类型的转为大类型；最后两种结果，则和值的大小有关。
总结：

a.int型和小于它的类型组合时（char、byte、short），当值不超过小类型的值范围，最终结果为小类型；超过时为int型；

b.除了情况a外时，最后结果会转换为大类型；

c.char和byte、short的组合，则会转换为int型。

（和运算时的自动类型转换结果不一样，好乱啊）

2.其中一个表达式是一个常量，另一个表达式是某种类型T。

代码如下：

        int xint = 65;
        char ychar = 'A';
        String str = "A";
        Object O_41 = false ? xint : 'A';
        Object O_42 = false ? ychar : 65;
        Object O_43 = false ? str : 65;
        Object O_44 = true ? str : 65;
        System.out.println("o_41:   " + O_41.getClass());
        System.out.println("o_42:   " + O_42.getClass());
        System.out.println("o_43:   " + O_43.getClass());
        System.out.println("o_44:   " + O_44.getClass());

输出结果：

o_41:   class java.lang.Integer
o_42:   class java.lang.Character
o_43:   class java.lang.Integer
o_44:   class java.lang.String

规律就是：
当常量可以表示成变量的T类型时，就转为T类型。

3.表达式2和表达式3都是变量的情况

代码如下：

        int xint = 65;
        char xchar = 'A';
        byte xbyte = 65;
        short xshort = 65;
        long xlong = 65;
        String str = "A";
 
        Object o_51 = false ? xint : xchar;
        Object o_52 = false ? xint : xbyte;
        Object o_53 = false ? xshort : xbyte;
        Object o_54 = false ? xlong : xint;
        Object o_55 = false ? xchar : xbyte;
        Object o_56 = false ? xlong : xbyte;
        Object o_57 = false ? str : xint;
        Object o_58 = true ? str : xint;
        System.out.println("o_51:   " + o_51.getClass());
        System.out.println("o_52:   " + o_52.getClass());
        System.out.println("o_53:   " + o_53.getClass());
        System.out.println("o_54:   " + o_54.getClass());
        System.out.println("o_55:   " + o_55.getClass());
        System.out.println("o_56:   " + o_56.getClass());
        System.out.println("o_57:   " + o_57.getClass());
        System.out.println("o_58:   " + o_58.getClass());

输出结果：

o_51:   class java.lang.Integer
o_52:   class java.lang.Integer
o_53:   class java.lang.Short
o_54:   class java.lang.Long
o_55:   class java.lang.Integer
o_56:   class java.lang.Long
o_57:   class java.lang.Integer
o_58:   class java.lang.String

这种情况和第一种两个常量的情况有点不同
这时只是把小类型转换为大类型（char和其他先转为中间类型int）。

活动名称及链接地址：【奔跑吧！JAVA】有奖征文火热进行中：https://bbs.huaweicloud.com/blogs/265241