Another question about Widening and Boxing

[Gary Marshall]

class Eggs {
//	  int doX(Long x, Long y) { return 1; }
//	  int doX(long... x) { return 2; }
	  int doX(Integer x, Integer y) { return 3; }
//	  int doX(Number n, Number m) { return 4; }
//	  int doX(int a, int b) { return 5; }
//	  int doX(long r, long f) { return 6; }

	  public static void main(String[] args) {
	    new Eggs().go();
	  }
	  void go() {
	    short s = 7;  
	    System.out.print(doX(s,s) + " ");  
	    System.out.println(doX(7,7));
	  }
	}

With this code the compiler complains that "The method doX(Integer, Integer) in the type Eggs is not applicable for the arguments
(short, short)".
What I am thinking is that the compiler widened the 's' short variables to two integers, but it does not (will not?) also box these two integers to two Integers. Is this correct? Is it true that the compiler will NOT box a variable after it has just widened it? That is, will the compiler do one or the other, not both?

Thank you for your time.
Gary

[saikiran venkata]

widening followed by boxing is not allowed......

boxing followed by widening is allowed........,

short --> int --> Integer is not allowed

short -->Short --> Object is allowed.

short -->Short --> Integer is not allowed because they are siblings, not a valid widening.

[Gary Marshall]

Thank you for your response

boxing followed by widening is allowed........,

and

short -->Short --> Integer is not allowed because they are siblings, not a valid widening.

So does this mean that a wrapper object could only be widened to an Object? If thats true, I wonder why one would want to do so? hmmm...

Thanks again
Gary

[Prasad Kharkar]

It is not necessary that all the Wrappers will be widened to Object class

Wrapper classes are subclasses of class Number

so they can be widened to class Number also

[Gary Marshall]

OK. Thank you

Given this code:

class Eggs {
  int doX(Long x, Long y) { return 1; }
  int doX(long... x) { return 2; }
  int doX(Integer x, Integer y) { return 3; }
  int doX(Number n, Number m) { return 4; }

  public static void main(String[] args) {
    new Eggs().go();
  }
  void go() {
    short s = 7;  
    System.out.print(doX(s,s) + " ");  
    System.out.println(doX(7,7));
  }
}

Result is " 4 3"

I wonder why, since widening is favored over boxing, and that the JVM uses the method with the smallest argument that is wider than the parameter, why didn't the compiler/JVM do this:

short --> Widen to int ==> select the " int doX(long... x)" method. (BTW: This is the method that is selected when the "int doX(Number n, Number m) " method is commented out).

Instead, the compiler/JVM looks like it did this:

short --> Boxed short to Short --> Widened to Number ==> selected the "int doX(Number n, Number m) " method.

Why would it do this if Widening "beats" Boxing?

thanks
Gary

[Prasad Kharkar]

Gary Marshall wrote:


short --> Widen to int ==> select the " int doX(long... x)" method. (BTW: This is the method that is selected when the "int doX(Number n, Number m) " method is commented out).

Always remember that variable arguments is a new concept and to keep the old code in java safe, the var- args are always chosen at last so here, boxing will be preferred
Widening Beats Boxing applies when they are used separately
see the following code

class Eggs {
  int doX(Long x, Long y) { return 1; }
  int doX(long x, long y) { return 2; } // modified and var-args removed, and it is called now both times
  int doX(Integer x, Integer y) { return 3; }
  int doX(Number n, Number m) { return 4; }

  public static void main(String[] args) {
    new Eggs().go();
  }
  void go() {
    short s = 7;  
    System.out.print(doX(s,s) + " ");  //prints 2 because of widening
    System.out.println(doX(7,7)); // prints 2 because of widening
  }
}

now look the following code

class Eggs {
  int doX(Long x, Long y) { return 1; }
//  int doX(long x, long y) { return 2; }
  int doX(Integer x, Integer y) { return 3; }
  int doX(Number n, Number m) { return 4; }

  public static void main(String[] args) {
    new Eggs().go();
  }
  void go() {
    short s = 7;  
    System.out.print(doX(s,s) + " ");  // prints 4 as Boxing and Widening is possible
    System.out.println(doX(7,7));// this is direct boxing now as there is no method to which integet 7 can be widened
  }
}

Widening beats boxing when there are two overloaded methods in which one has just Widening parameters and another has Boxing parameters

Hope this helps
hth

[Javin Paul]

Interesting thread but got little confused between priority of widening and boxing .
just to make it clear if both widening and boxing is applicable for any place I see widening is happening before boxing as per above example.

is that true for all jdk compiler or does it varies ?

Thanks
Javin

[Gary Marshall]

Javin Paul wrote:
just to make it clear if both widening and boxing is applicable for any place I see widening is happening before boxing as per above example.

is that true for all jdk compiler or does it varies ?

Thanks
Javin

Don't take my response as final but I do know that Boxing came on the scene as of Java 5. So I'm thinking your results will be different vs what you see in this thread if you are using a pre-Java5 jdk compiler.

Gary

[Javin Paul]

Hi Gary,

Pre JDK 5.0 is OK , Since there is no boxing so no question of priority between widening and boxing , I am asking about JDK 5.0 and above ?

Thanks
Javin

[Ram Narayan.M]

Definitely >JDK 5.0 will support this...