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

举报
holo.yh 发表于 2021/05/20 19:53:58 2021/05/20
【摘要】 Java三目运算符:    (表达式1)?(表达式2):(表达式3)对于三目运算符,第一个表达式的值必须是boolean类型的值,但是对后两个表达式的类型,则没有要求,也不必相同。但有时涉及类型转换,转的有点让人莫名奇妙的。亲自试验之后,发现有如下情况:首先,总的原则就是能自动类型转换的就自动转换;不能自动转的,就不转。(自动类型转换和自动拆/装箱,默认是拆箱吧?)如:           ...

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

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

举报
请填写举报理由
0/200