(1)
byte b = 10;
switch(b)
{
case 128:
System.out.println("here");
}
results in a compile time error.
But
(2)
byte b = 10;
integer i = 128;
System.out.println(b == i);
runs fine and produces a result of false.
Question:
Why byte can't be compared to int in (1), whereas byte can be compared to int in (2) ?
Alternatively, why code in (1) cannot compare byte and int values (but will result in loss of precision), whereas code in (2) could compare a byte and int fine ?
This message was edited 2 times. Last update was at by Larry Olson
Every case constant expression associated with a switch statement must be assignable to the type of the switch Expression.
There is no such restriction for if conditions (or I must say the == operator). When you compare byte == int, the byte is promoted to int, but this doesn't happen in switch statements...
I see. So it is the Java language specification that tells this. But it seems unnatural to force the switch statement to this behavior whereas it isn't the case while using == operator. One of those weird, strange quirks one has to remember
If you think about it, it is logical. The == operator allows comparison between byte and int because you might compare two variables i.e. something like this
So the compiler cannot tell whether i's value will be in the range of byte or not. But in the case of a switch statement, you cannot use variables as case values, so at the compile time you already know whether the case value is assignable to the switch expression or not. What is the whole point of allowing a case which can never be true?? In the example you showed, the case 128 can never be true, so what is the point of allowing it?? By flagging this as an error, the compiler helps you avoid such circumstances as its definitely a logical error...
0
