关于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不久，刷试题的时候看到这个，敲一下代码，发现是这种情况。这个问题好像意义也不大，不过作为面试题可能是个小坑。

写的有什么问题，还望指正，至于一开始说的拆/装箱的，还不懂。