小问题，难倒很多人

Question

public static void main(String[] args){
int i=4;
System.out.println("value is"+((i>4) ? 99.9 : 9)));
}
运行后打印的结果是：9.0
为什么？？？

Answer 1

public static void main(String[] args) {
     int i = 4;
     System.out.println("value is " + (int)((i > 4) ? 99.9 : 9));
}

Answer 2

这个问题很难吗？还是我理解错了。。
你定义的i=4
打印结果是“如果i>4就输出99.9，否则就输出9”
i=4,当然不是大于4,
所以就输出9了。。
有什么不对吗？

Answer 3

(i>4) ? 99.9 : 9
这里99.9和9的数据类型是对等的，也就是都为浮点数，那么自然输出的也是浮点

Answer 4

再补充一句
隐式转换（自动转换）:小内存空间类型转换为大内存空间类型，精度不丢失。如short i=97; int j=short;
Java的浮动点类型默认就是double，所以你输出的那个9.0是double类型的，要想float类型后面加F

Answer 5

这个三元操作符要求?后面的两个表达式的值类型必须一致，而整个表达式返回值的类型会和那两个表达式的值类型一致。这就是导致隐含类型转换的原因，或者叫做Data Type Promotion。

Answer 6

System.out.println(1 != 1 ? new Double(5) : "bbbbb");不是一句隐式转换所能解决得了的。

Answer 7

严重关注，结果却是会是5.0，或者bbbbb

Answer 8

都转成Object了吧，println(Object o)会把toString()的内容输出，那么就是5.0或者bbbbb了

Answer 9

这个问题....   郁闷!
   比较
i>4?     的时候 如果是你>=的话 一样是9
   貌似 会自动转换 

Answer 10

99.9默认是double型，而 9你定义的是int型，“99.9 : 9”，int型会自动转换成double型；如果反过来会报错，需要强制转换。比如:
public static void main(String[] args){ 
  double i=4.0; 
  System.out.println("value is"+((i>4.0) ? 9 : (int)99.9))); 
} 

Answer 11

System.out.println(1 != 1 ? new Double(5) : "bbbbb"); 
结果不是bbbbb么。

Answer 12

java会自动把低级别类型的数据转成高级别的数据
99.9 浮点型
9 整型
整型会往浮点型转的。

Answer 13

(i>4) ? 99.9 : 9 
 本来i=4，判断为否，故输出后面的9，很容易的问题哈~

Answer 14

(i>4) ? 99.9 : 9 
这里99.9和9的数据类型是对等的，也就是都为浮点数，那么自然输出的也是浮点
java会自动把低级别类型的数据转成高级别的数据 
99.9 浮点型 
9 整型 
整型会往浮点型转的。

Answer 15

《Java编程规范》
对于条件表达式
1、如果第二和第三个操作数有相同的类型，那么这个类型就是条件表达式的类型
2、如果一个操作数的类型是T，T表示byte、short或char，而另一个操作数是一个int类型的常量表达式，它的值是可以用类型T表示的，那么条件表达式的类型就是T。 
3、否则，将对操作数类型运用二进制数字提升，而条件表达式的类型就是第二个和第三个操作数被提升之后的类型。 

Answer 16

首先纠正一下楼主的错误
1、
int i = 4;
System.out.println("value is"+((i>4) ? 99.9 : 9))); 
右括号多了一个(红色部分)
2、打印结果是 value is9.0 而不是9.0
3、为什么会是9.0呢
((i>4) ? 99.9 : 9)
建议楼主去看下 <<java解惑>>这本书的谜题8 就会明白了 
其实楼主可以记住三点就可以:   *   如果第二个和第三 个操作数具有相同的类型，那么它就是条件表达式的类 
       型。换句话说，你可以通过绕过混合类型的计算来避免大麻烦 。   
   *   如果一个操作数的类型是 T，T 表示 byte、short 或 char，而另 一个操作 
       数是一个 int 类型的常量表达式，它的值是可以用类型 T 表示的，那么条 
       件表达式的类型就是 T。   
   *   否则，将对操作数类型运用二进制数字提升，而条件表达式的类型就是第 
       二个和第三个操作数被提升之后的类型。  2、3 两点是关键。  

Answer 17

float的精度大于int的精度，所以判断后打印的结果应该是高精度的数值类型。99.9是float型，9是int型，这种情况在不同精度数值计算时非常常见

Answer 18

(i>4) ? 99.9 : 9 
按道理说，应该输出9，但是输出9.0，我是这样理解的：
i定义的是int型的，但它在？前面只返回一个boolean型的值；
而99.9和9则系统默认的是double型的！再加上99.9和9是对等的，int可以向double隐式转换！

Answer 19

  *  如果一个操作数的类型是 T，T 表示 byte、short 或 char，而另 一个操作 
      数是一个 int 类型的常量表达式，它的值是可以用类型 T 表示的，那么条 
      件表达式的类型就是 T。  
  *  否则，将对操作数类型运用二进制数字提升，而条件表达式的类型就是第 
      二个和第三个操作数被提升之后的类型。  其实也就是两个类型做运算时。类型需一致，优先级要明确。

Answer 20

因为?:的两个操作数一个是int 一个是double,所以返回的是double

Answer 21

这个时候就没有隐式转换了，，，输出的就是：后面的。
System.out.println((1 != 1) ?  "b" :new Double(5));
输出5.0System.out.println(1 != 1 ? new Double(5) : "bbbbb");
输出bbbbb
这个谁给解释下？？？？？？？

Answer 22

其实这个原理很简单，比如： short a=1；
                           a=a+1;
                           System.out.println(a);
编译就会出错，这个道理是一样的。

Answer 23

String类型和浮点型还能相互转换呢？这个还真的不知道

Answer 24

个人认为是多态调用不同的toString
System.out.println(1 != 1?  new Double(5):new String ("bbbb")); 输出也是“bbbb”

Answer 25

看来你没弄明白 隐式转换问题，还有三元用算符问题。
你要输出9的话
System.out.println("value is"+((i>4) ? 99.9 : （short）9))); 
一下也可以

Answer 26

不对吧，换成short，它还是会转成double的，所以输入仍然是9.0

Answer 27

简单一句，数据类型的隐式转换，前后均为double类型

Answer 28

public static void main(java.lang.String[])   throws java.lang.Exception;
  Signature: ([Ljava/lang/String;)V
  Code:
   0:   iconst_4
   1:   istore_1
   2:   getstatic       #19; //Field java/lang/System.out:Ljava/io/PrintStream;
   5:   new     #25; //class java/lang/StringBuilder
   8:   dup
   9:   ldc     #27; //String value is
   11:  invokespecial   #29; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
   14:  iload_1
   15:  iconst_4
   16:  if_icmple       25
   19:  ldc2_w  #32; //double 99.9d
   22:  goto    28
   25:  ldc2_w  #34; //double 9.0d
   28:  invokevirtual   #36; //Method java/lang/StringBuilder.append:(D)Ljava/lang/StringBuilder;
   31:  invokevirtual   #40; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   34:  invokevirtual   #44; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   37:  return
如果变为:
  System.out.println("value is "+((i>4) ?  9: 7.0f));   19:  ldc     #32; //float 9.0f
   21:  goto    26
   24:  ldc     #33; //float 7.0f
总结:
JVM把  9: 7.0f 当成一个符号来处理,复合java的向上转型.
over

Answer 29

System.out.println("values is "+((i>4)? 98:99));
//改成这样就输出99了