Java类型转换示例

Question

I have an exam soon and I want someone to check my explanations why some conversions are allowed by the compiler, and some aren't.

byte--> short --> int --> long --> float --> double

So I can always cast (unexplicitly) from small to big ie from byte to long for example. But to go in this direction <-- I have to explicitly typecast. So far so good, but questions at the exam are still kinda tricky.

int value1 = (double) 10;

Not allowed. Eclipse says cannot convert from double to int. But isn't 10 an integer already?? I don't really get it.

byte value2 = (int) 120.0;

Allowed. So the 120.0 gets cut to 120 which is then an integer which is within the range of a byte. But for example the follwing

byte value3 = (int) 33500.0;

is not allowed. Because it's not within the range of a byte?

double value4 = (int) 13.2;

Allowed. 13.2 gets cut to 13 which is an integer. You can always assign small to big.

int value = 10f;

not allowed. Because you cannot convert from float to int, but however

int value = (int) 10f

is allowed, since now it's casted explicitly.

double someValue = (int) 12.3;

Allowed, I guess. But this doesn't make a lot of sense, does it? Since 12.3 is already a double.

short v1 = (int) 42.0;

Allowed. But Why?? I thought you cannot go in this <-- direction.

Answer 1

This is described in JLS Sec 5.2 :

Assignment contexts allow the use of one of the following:

• an identity conversion (§5.1.1)
• a widening primitive conversion (§5.1.2)

...

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.

Your examples can all be explained with these rules:

 double value4 = (int) 13.2; 

(int) 13.2 is of type int , so a widening primitive conversion is applied.

 int value = (int) 10f; 

(int) 10f is of type int , so an identity conversion is applied.

 double someValue = (int) 12.3; 

(int) 12.3 is of type int - its value is 12 - so a widening primitive conversion is applied. The fact that 12.3 is a double is irrelevant here - you're not assigning 12.3 to the variable, you're assigning (int) 12.3 == 12 .

 byte value2 = (int) 120.0; short v1 = (int) 42.0; 

These are allowed because the expressions are constants of int type, and their values can be represented in byte and short respectively, so the narrowing primitive conversion case applies.

 int value1 = (double) 10; int value = 10f; 

These isn't allowed because it would require a narrowing conversion from floating point types to int. Only some constant integer values can be implicitly narrowed (not long ).

 byte value3 = (int) 33500.0; 

This isn't allowed, despite the expression being of type int , because (int) 33500.0 == 33500 is outside the range of byte .

Answer 2

There are two types of casting:

1. Implicit Type Casting (widening conversion)
2. Explicit Type Casting (narrowing conversion)

The sequence you mentioned byte--> short --> int --> long --> float --> double is for Implicit Type Casting.

Example:
short v1 = 4;
int i = v1;
System.out.print(i);

Output: 4

The one in which we use (datatype) ahead of the value to change it to the other is known as Explicit Type Casting.With this we can assign larger data type values to the smaller ones.

    Example:
    short v1 = (int)42.0;
    System.out.print(v1);

Output: 42

Hope you got all your answers.