BETA: Method resolving, un/boxing varargs mock question

[Eduardo Rodrigues]

Hi guys.
For me this are the hardest subject, up to now...
So, just for fun, try to guess which calls will compile and which won�t, and why... Latter, comment the calls which won�t compile and try to guess the output...

 
 
    public static void main(String[] args) {
 
        //A
        method(1);
        
        //B
        method(new Integer(1),new Integer(1));
        
        //C
        method(new Integer(1)+1);
        
        //D
        method(1,new Integer(1));
        
        //E
        method(1,1);
        
        //F
        method(new Integer(1),1);
        
        //G
        method(1+new Integer(1));
        
    }
    
    public static void method(Integer i){
        System.out.println("method(Integer i)");
    }
    
    public static void method(Integer i, Integer ... args){
        System.out.println("method(Integer i, Integer ... args)");
    }
    
    public static void method(Integer i, int ... args){
        System.out.println("method(Integer i, int ... args)");
    }
    
    public static void method(int i){
        System.out.println("method(int i)");
    }
    
    public static void method(int i, Integer ... args){
        System.out.println("method(int i, Integer ... args)");
    }
    
    public static void method(int i, int ... args){
        System.out.println("method(int i, int ... args)");
    }
 

I don�t understand why the compiler allows this stuff. I think that the only way to call the 'methods which don�t compile' is using reflection...

Well, post your answers, let�s discuss this hard topic...

Have fun!

Bye...

[Joyce Lee]

Hi Eduardo,

Thanks for posting this question.

The compiler determines which method to call by going thru' 3 phases.

Extracted from JLS3 Section 15.12.2:

------------
The first phase (�15.12.2.2) performs overload resolution without permitting boxing or unboxing conversion, or the use of variable arity method invocation. If no applicable method is found during this phase then processing continues to the second phase.

The second phase (�15.12.2.3) performs overload resolution while allowing boxing and unboxing, but still precludes the use of variable arity method invocation. If no applicable method is found during this phase then processing continues to the third phase.

The third phase (�15.12.2.4) allows overloading to be combined with variable
arity methods, boxing and unboxing.
------------

Here's what I think based on the rules above:
//A
method(1); // OK
Without boxing/unboxing and arity methods, the compiler can find an exact method in phase 1, i.e. method(int i).

//B
method(new Integer(1),new Integer(1)); // Compilation error
It isn't able to pass phase 1 since there's no method(Integer x, Integer y). Not for phase 2 too since there's no method(int x, int y), method(int x, Integer y) or method(Integer x, y). For phase 3, any of the following signature combination is possible, hence result in ambiguity during compilation:

  
    public static void method(Integer i, Integer ... args){
        System.out.println("method(Integer i, Integer ... args)");
    }
    
    public static void method(Integer i, int ... args){
        System.out.println("method(Integer i, int ... args)");
    }
 
    public static void method(int i, Integer ... args){
        System.out.println("method(int i, Integer ... args)");
    }
    
    public static void method(int i, int ... args){
        System.out.println("method(int i, int ... args)");
    }

Same for D, E, F.

//C
method(new Integer(1)+1);
//G
method(1+new Integer(1));
According to JLS3 5.6.2 Binary Numeric Promotion, the result type of the two operands will be int.

The following program is legal:

public class BinaryTest {
    public static void main(String[] args) {
        method(new Double(1) + new Double(1));    
    
    }
    public static void method(double i) { // this one is called.
        System.out.println("double");
    }
       public static void method(Double i) {
        System.out.println("Double");
    }        
}     

After converting to int for both C and G, the compiler can find a matching method in phase 1, i.e. method(int i). Hence compilation passed.

What do you think?
[ January 26, 2005: Message edited by: Joyce Lee ]

[Joyce Lee]

To demonstrate phase 1, here's an example without variable arity-method and it's compiled without error.

  
public class ArgTest {
    public static void main(String[] args) {
        method(new Integer(1), new Integer(1));
    }
 
    public static void method(Integer x, Integer y) {
        System.out.println("method(Integer x, Integer y)");
    }
    
    public static void method(int x, int y) {
        System.out.println("method(int x, int y)");
    }
    
    public static void method(Integer x, int y) {
        System.out.println("method(Integer x, int y)");
    }
    
    public static void method(int x, Integer y) {
        System.out.println("method(int x, Integer y)");
    }   
}

method(Integer x, Integer y) is called because it passes the phase 1 test without bothering boxing/unboxing or variable arity-method.

[Joyce Lee]

To demonstrate phase 2, removing method(Integer x, Integer) would cause compilation error. That's because boxing/unboxing is at work in phase 2. Any of the following combination is fine for method(new Integer(1), new Integer(1)), hence result in ambiguity during compilation.

  
  public static void method(int x, int y) {
        System.out.println("method(int x, int y)");
    }
    
    public static void method(Integer x, int y) {
        System.out.println("method(Integer x, int y)");
    }
    
    public static void method(int x, Integer y) {
        System.out.println("method(int x, Integer y)");
    }   

[Joyce Lee]

If method(new Integer(1), new Integer(1)) fails to pass phase 1 and 2, any of the following combination is fine in phase 3. But only one is allowed otherwise ambiguity happens during compilation. Whew!

  
    public static void method(Integer ... y) {
        System.out.println("method(Integer ... y)");
    }
    
    public static void method(int ... y) {
        System.out.println("method(int ... y)");
    }
    
    public static void method(Integer x, int ... y) {
        System.out.println("method(Integer x, int ... y)");
    }
 
more combinations ...