primitive narrowing conversions

[Ravinder Singh]

Please help me with this...
Q. Why can't we perform primitive narrowing conversions (without cast) from long constant type to byte, char, short or int even when the value is in the range of destination types?

Here is an example:

//primitive conversions
 
class PrimitiveConversions {
 
public static void main(String args[]) {
 
// 1.int constants to byte, short and char compiles and runs-
//...fine if within the range of the destination type.
 

byte b = 100;// compiles as expected
short s = 120;// compiles as expected
char c = 70;// compiles as expected
 
// OR
 
final int i = 90;
byte b1 = i;// compiles as expected
short s1 = i;// compiles as expected
char c1 = i;// compiles as expected
 

// 2. integer constant long to byte, short, char and int DOESN't compile-
//...without cast.
 
final long l = 120;
byte b2 = l;// doesn't compile as expected
short s2 = l;// doesn't compile as expected
char c2 = l;// doesn't compile as expected
int i2 = l; // doesn't compile as expected
 
}
 
}

--------------
Ravinder Singh

[Edwin Dalorzo]

See JLS under Assignment Conversion.

[gaurav singhal]

Hi Ravinder,

Casts can be implicit or explicit. An implicit cast means you don't have to write code for the cast; the conversion happens automatically. Typically, an implicit cast happens when you're doing a widening conversion. In other words, putting a smaller thing (say, a byte) into a bigger container (like an int). Remember those "possible loss of precision" compiler errors we saw in the assignments section? Those happened when we tried to put a larger thing (say, a long) into a smaller container (like a short). The large-value-into-small-container conversion is referred to as narrowing and requires an explicit cast, where you tell the compiler that you're aware of the danger and accept full responsibility.

But now you will find it weird that why byte is holding the int value.

The following is legal,
byte b = 27;
but only because the compiler automatically narrows the literal value to a byte. In other words, the compiler puts in the cast. The preceding code is identical to the following:

byte b = (byte) 27; // Explicitly cast the int literal to a byte
It looks as though the compiler gives you a break, and lets you take a shortcut with assignments to integer variables smaller than an int.

Similarily it is true for byte char and short. But when you cast the long to byte the compiler do not narrow the literal automaticaly by putting cast thats why you get the compiler error.

Gaurav