Casting

[Dishi Jain]

Integer iRef3 = (short)10; // constant in range: casting by narrowing to short,
                                       // widening to int, then boxing
short s = 10;                  // narrowing
// Integer   iRef1 = s;    // short not assignable to Integer

Why can't the second one as well follow the same steps?
"widening to int, then boxing" , while //Line 4 gives compilation error!!!

Is it like while assigning non-constant variable Casting is required?

[alex galvao]

Don't use Object and primitive, use primitive and primitive
for example:

int iRef3 = (short)10;   
short s = 10;
int   iRef1 = s;

[Minhaj Mehmood]

Take a look on great 5 Golden Rules of widening, boxing & varargs


hope this helps.

[Gaurav Sagar]

Dishi Jain wrote:

Integer iRef3 = (short)10; // constant in range: casting by narrowing to short,
                                       // widening to int, then boxing
short s = 10;                  // narrowing
// Integer   iRef1 = s;    // short not assignable to Integer

Why can't the second one as well follow the same steps?
"widening to int, then boxing" , while //Line 4 gives compilation error!!!
Is it like while assigning non-constant variable Casting is required?

In your case, Line 1 would give a compilation error, 'cause of the incompatibility; and yes non-constant variable when narrowing need casting.

Regards,
Gaurav

[gaurav gupta sitm]

widening followed by boxing not allowed

Double l1=1323.12f;

[Gaurav Sagar]

gaurav gupta sitm wrote:widening followed by boxing not allowed

Double l1=1323.12f;

The thumb rule states that, "Autoboxing occurs strictly between the primitive datatype and its wrapper class only", not to be confused with widening and casting.
In the above code, line 1 would compile only if you explicitly cast the float to a double.

Regards,
Gaurav

[Henry Wong]

Dishi Jain wrote:

Integer iRef3 = (short)10; // constant in range: casting by narrowing to short,
                                       // widening to int, then boxing

Be careful of trying to figure out what combination of widening, narrowing, and auto-boxing are allowed, based on compile time constants. Compile time constants has special rules that allow certain combinations to be allowed that isn't allowed without compile time constants.

Henry

[Sunny Bhandari]

Hi Dishi,

Its very easy to get confused with this concept

Widening and auto(un) boxing don't go together.

I have seen many developers overlooking that...

[Dishi Jain]

Firstly,

Integer iRef3 = (short)10;

is working fine for me. No compile time errors.
Because as per the description in Khalid Mughal, widening and then Boxing is taking place, while it is not legal.
Secondly,

Double test=1323.12f;

doesnt work. Why is it not following the same steps as in earlier one.
Also what is the difference between,widening and casting as mentioned above?

[Stephan van Hulst]

Like Henry said, there are some special rules for compile time constants which do not follow the general rules. I'm not exactly sure, but I believe that when you assign a constant to a wrapper variable, it will work as long as you are using integral types, smaller than Long.

[Dishi Jain]

As per page number 254 in K&B,
You CANNOT widen and then box. (An int can't become a Long.)

Why???
I can widen int->long
and then Box long->Long !!

[Stephan van Hulst]

Yes, but not in the same single assignment. You can't do:

int i = 10;
Long j = i;

[Sunny Bhandari]

Ok Dishi,

Actually my statement was not fully correct.
The correct statement should be:

Implicit Widening and Auto(un)boxing don't work together.

In the code:

Integer iRef3 = (short)10; 

we are having explicit cast and hence it is working.

Don't get confused and try to write some variations of widening and auto(un)boxing in a test class and see what works and what doesn't

[Henry Wong]

Dishi Jain wrote:

Integer iRef3 = (short)10;

is working fine for me. No compile time errors.
Because as per the description in Khalid Mughal, widening and then Boxing is taking place, while it is not legal.

To repeat...

Stephan van Hulst wrote:Like Henry said, there are some special rules for compile time constants which do not follow the general rules.

Thanks Stephan.


Anyway... interestingly, there are no byte or short compile time constants. Byte and short compile time constants are just int compile time constants.

Literals are compile time constants. A "10" is a int compile time constant. A "(short) 10" is actually not a short compile time constant, but is actually an int compile time constant that has been truncated to a short value (which is still 10 here). And... assigning this int compile time constant to an Integer reference just does boxing (and nothing else).

Henry

[Henry Wong]

Dishi Jain wrote:

Double test=1323.12f;

doesnt work. Why is it not following the same steps as in earlier one.
Also what is the difference between,widening and casting as mentioned above?

In this case, there are float and double compile time constants... but... the special rules for implicit narrowing and boxing doesn't apply to Float and Double -- no special rules apply here.

And as your book mentioned, this doesn't work.

Henry