Implicite casting from int to byte

Local variables:

final int a = 10;
byte b = a;

That works fine.

But:

final long a = 10;
byte b = a;

Doesn't work. Why?

Interesting...

1) final int aInt=127;
2) byte aByte=aInt;

If aInt value < -128 or >127, then the 2nd line gives a compilation error.

I have referred the below link:
http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#25363

But still I am confused. Can anyone please explain?

Thanks for your time.

Sridhar Gudipalli wrote:Interesting...

1) final int aInt=127;
2) byte aByte=aInt;

If aInt value < -128 or >127, then the 2nd line gives a compilation error.

I have referred the below link:
http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#25363

But still I am confused. Can anyone please explain?

Thanks for your time.

If aInt is <-128 or >127 it is out of the range of a byte. The only way to assign something <-128 or >127 to a byte is to use an explicit cast, and then you will be losing precision.

Smith,
Thankyou for your quick reply.

I understood the range issue.
But the below code gives the compilation error:

final long aLong=120;
byte aByte=aLong;

Here aLong value 120 is in byte range only!! Still it needs explicit casting to narrow. Is it due to bit representation?

Sridhar Gudipalli wrote:Smith,
Thankyou for your quick reply.

I understood the range issue.
But the below code gives the compilation error:

final long aLong=120;
byte aByte=aLong;

Here aLong value 120 is in byte range only!! Still it needs explicit casting to narrow. Is it due to bit representation?

To be honest, I'm not sure. I've been watching this thread to see if there is an answer too

.

In my opinion the answer lies in the bit representation. Does anyone know the correct answer? It's obvious that ranges <-128 and >127 need explicite casting. But what about the type of long?

final long a = 10; //the compiler knows that the value can not be changed
byte b = a; //compiler error

It must be connected with the bit representation.

What do you think about it?

This is actually specificially mentioned in the JLS, section 5.2 (assignment conversions).

In addition, if the expression is a constant expression (§15.28) of type byte, short, char or int :

A narrowing primitive conversion may be used if the type of the variable is byte, short, or char, and the value of the constant expression is representable in the type of the variable.

Basically, the compile time constant, check if it fits, and allow the assigment, rule doesn't apply to long. Or any other primative type not mentioned in that quote.

Henry

It must be connected with the bit representation.

What do you think about it?

The bit represention of byte, short, int, and long, is two's complement. To widen any type, you do a sign extension. To narrow, you truncate. The rules are the same going from any of the four to any other of the four types.

Henry

Got it. Thank you Henry!!

OK. But on the other hand it isn't logical. Why did the Java's designers go that way?
long is something special? I cannot understand that.

Mason Storm wrote:OK. But on the other hand it isn't logical. Why did the Java's designers go that way?
long is something special? I cannot understand that.

I suspect it has something to do with the size of a long. If you have a value that requires a long I would say the odds that you would need to cast it to a byte would be small, or, if your value is small enough, it should be an int.

"Mason Storm", please check your private messages for an important administrative matter.