Narrowing Problem

[Micheal John]

class GFC125 {
  static float m(float i) {
System.out.println("Hi");
return i;
  }
  
  static double m(double i) {
return i;
  }
  
  public static void main (String[] args) {
    int a1 = 1; 
    long b1 = 2; 
    System.out.print(m(a1)+","+ m(b1));
  }
}

In the above coding, m(a1) a1 is int which is 32 bit and passing to float which is also 32 bit.so no problem.
But in m(a2), a2 is long (64 bit) and passing to a float (32 bit), which is narrowing. How it's returing the float value without explicit cast?
Why can't for m(a2), the compiler should choose the double, since both long and double are 64 bit?

[Rancy Chadha]

Hi Michael,

The output you are getting is correct. The reason is that long does get widened to float implicitly. The widening functionality works like this:

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

Now you would be wondering how long(64 bits) gets converted to float (32 bits) implicitely. For this,
http://radio.javaranch.com/corey/2004/06/01/1086120368000.html
link gives the best explanation. Please go through this article

Thanks,
Rancy

[Barry Gaunt]

"a2 is long (64 bit) and passing to a float (32 bit), which is narrowing"

This is plain wrong. long is convertable to float because the range of a long is accomodated by a float.

Take a good look at what the JLS says:

5.1.2 Widening Primitive Conversion
The following 19 specific conversions on primitive types are called the widening primitive conversions:

* byte to short, int, long, float, or double
* short to int, long, float, or double
* char to int, long, float, or double
* int to long, float, or double
* long to float or double
* float to double

Widening primitive conversions do not lose information about the overall magnitude of a numeric value.

<SNIP>

Conversion of an int or a long value to float, or of a long value to double, may result in loss of precision-that is, the result may lose some of the least significant bits of the value. In this case, the resulting floating-point value will be a correctly rounded version of the integer value, using IEEE 754 round-to-nearest mode (�4.2.4).

[Rancy Chadha]

Sorry about that widening diagram in prior post, what I meant is

byte
|
short char
| |
--------
|
int
|
long
|
float
|
double

[Micheal John]

Thanks for your reply.. Now I understood and I think I have to go thru the entire JLS one time..but it is diffcult to go thru' it as the JLS seems to be very hard to understand, since it's not written in the plain english.

[Marcus Green]

Whilst the JLS is good for "argument settling", you generally don't need to go through it for SCJP purposes. Just read one of the standard texts aimed at that exam (e.g. Sierra and Bates) very carefully and you should be OK.