Varargs overloading problem

[Harinath subu]

Could you resolve this problem

//Program for Overloading varargs
class A{
void metodA(int... a){
// -------Body of the method ---------
}
void methodA(double... b){
//----------- mody of the method
}
}


class B{
{
public static void main(String[] args){
A a=new A();
a.methodA(1,2,3,4,5); // i am getting the problem over here(ambiguity error) why this occurs....
}
}

//#################################################################################################

//If i did the same program with a single argument it works
class A{
void metodA(int a){
// -------Body of the method ---------
}
void methodA(double b){
//----------- mody of the method
}
}


class B{
{
public static void main(String[] args){
A a=new A();
a.methodA(1); //here it works perfectly
}
}

[Nitish Bangera]

Are you really getting a ambiguity error or are you getting the illegal start of expression error. Well the illegal start of expression error is because of the extra { near class B. As far ambiguity is concerned, how these methods can be ambiguous as the method signatures are totally different. One is int[] and the other is double[].

[Akanksha Mittal]

Even I am getting the Ambiguous error

" The method method(int[]) is ambiguous for the type <ClassName>"

Also I tried all posible combinations among int, float, double and long; I was getting the same error.

When I tried a Class, Subclass combination, I was not getting the error.

Can anyone help why this ambiguity in Number Types only?

[Vijitha Kumara]

Hi Harinath subu,
Please use codetags when posting code here. And Welcome to Javaranch

[Vinay Dinakar]

It worked fine for me.
Java(TM) SE Runtime Environment (build 1.6.0_01-b06)

[Raju Champaklal]

actually you get an ambiguity error when you use the combination of var-args and widening + var-args together

[Neha Daga]

Raju Champaklal wrote:actually you get an ambiguity error when you use the combination of var-args and widening + var-args together

can you explain it in detail?

[Raju Champaklal]

for example m(int... i) and m(Integer... i)/m(long... l) would give a compile error....if you invoke it with m(4).....

widening + varargs or boxing + varargs with var args.....i hope am right

because cant beleive you are asking me to explain

[Neha Daga]

I think you are also not very sure how and why compiler behaves this way. As here method is overloaded with int and double arguments which are different.

I think this should explain why is it happening.

[Raju Champaklal]

you mean this

This seems to be the problem when finding the most specific method, because it is neither int[] <: float[] nor float[] <: int[], so ambiguous.

It is (nearly) impossible to convert between arrays of primitives when passing them by reference. Imagine: changes to the converted referenced array should have to be written back to original array of other primitive type!

But then there >should< have be done any other trick when implementing varargs, because as mentioned before it is just a silly feature if it is not possible to overload in such a simple manner as max(int... a) with max(float... a)

awesome Neha...tussi great ho

[Ankit Garg]

Raju Champaklal wrote:awesome Neha...tussi great ho

Please only use English language on javaranch. Javaranch is visited by users from all around the globe not from only India...

[Raju Champaklal]

"tussi great ho" means "you are awesome" .......just joking...wont use hindi again

[Vinay Dinakar]

 public class Main {

    public static void main(String[] str){

   a a1 = new a();

     a1.fun(3,4); // ambiguity error.. why ?

     a1.fun(); // ambiguity error as both fun(int... ) and fun(short... ) matches as it is taking zero args

     a1.fun(3); //ambiguous with (int... i) and (float... f). i am assuming that compiler treats 3 and 3.0 same when var-arg is used

	 a1.fun(3f,3); // beacuse of 3f, compiler will know which one to invoke (float... f)

	 a1.fun(new int[]{1,2,3}); // since it is mentioned as int[], compiler will know that it has to invoke fun(int... )

	 a1.fun_one(2); // ambiuity error as  int... and Integer... are same w.r.t overloading var-args.

    }
}

class a {

    void fun(int... i){
     System.out.println("int...");
    }

    void fun(short... s){
	     System.out.println("short... ");
    }

    void fun(float... f){
		     System.out.println("float... ");
    }


    void fun_one(Integer... I){
			     System.out.println("Integer... ");
    }


	void fun_one(int... i){
				     System.out.println("Integer... ");
    }

}   

My question is:

-- Tell me if my assumptions are correct or wrong , which i mentioned in comments ?
-- how different it is when overloading var-agrs (int... i) and (float... f) from (int i) and (float f). ?

[Raju Champaklal]

what i understood from that link is that jvm choses the most specific method...now since 4 is an int and int is more specific than float so int will be chosen...and i hope you know that float[] and int[] cannot be casted to each other so they cant be compared....like int[] cant be casted or compared with Integer[] so compiler wont be able to find out the most specific out of them......they both look the same to the compiler....

P.s Arrays are objects....