Possible Duplicate:
Eclipse bug? When is a short not a short?
In Java I can assign a short
or a byte
inside blocks like this:
short s = 20000;
byte b = 120;
Because 20000 is a short
value and 120 is a byte
value, if I attempt to try:
short s = 67000;
byte b = 128;
I will get an error that states it cannot compile from int
to byte
where
byte b = (byte)12232;
will not even trigger a warning that value may get lost. In a function call I'm forced to cast it anyways:
void test(short s){}
test(1) //invalid
test((short)1) //valid
While on return
types it is okay again.
short test(){
return 1; //valid
}
Why does the compiler sometimes deside to know the bounds of numbers (at least from constants), while it seem that it forgets it elsewhere?
Integral numeric literals in Java are of just two kinds: int
(which are declared as 123
), and long
(which are declared as 123L
).
short s = 1
is allowed because it is an assignment and a narrow conversion is allowed thereshort s = 67000
doesn't work because you are exceeding the maximum value that can rapresented with a short
short s = (short)67000
works because you are placing a cast so you are explicitly requesting the type checker to ignore the fact that 67000 exceeds the maximum valuetest(1)
doesn't work because it's a method invocation, a narrow conversion is not allowed (int -> short) and 1
is always evaluated as an integer literal by the compiler