About Question enthuware.ocajp.i.v7.2.1052 :

[Sweetpin2]

I am not able to understand the explanation of above question.

An interesting observation is that if you do javap on the following class, you will see the same signature for method m1 and m2. This shows that a var-arg parameter of type T is same as an array of type T.
class TestClass {
String m1(int[] i) { return ""+i.length; }
String m2(int... i) { return ""+i.length; }
}


javap TestClass produces this:

java.lang.String m1(int[]);
java.lang.String m2(int[]);


Conversely, the following code will not compile:

class TestClass {
String m1(int[] i) { return ""+i.length; }
String m1(int... i) { return ""+i.length; } // Compiler determines that this is a duplicate method.
}

Can you help me by giving detail explanation.

[admin]

There is nothing much going on here. The ... notation is translated by the compiler into an array argument. So int ... and int[] are the same thing.

[terence_j_coffey]

I ran the following using Eclipse and it worked fine.
Have I misunderstood your explanation, as this appears to contradict your conclusion ?

public class TestClass {

String m1 (int[] i) { System.out.println(i.length); return ""+i.length ;}
String m2 (int...i) { System.out.println(i.length); return ""+i.length ;}
public static void main(String[] args) {
TestClass tc = new TestClass();
int[] a = { 1,2,3,4,5};
tc.m1(a);
tc.m2(1,2,3,4);

}

}

Compiled from "TestClass.java"
public class TestClass {
public TestClass();
java.lang.String m1(int[]);
java.lang.String m2(int...);
public static void main(java.lang.String[]);
}

[admin]

Why do you think it should not compile? I don't see any contradiction with the explanation.

-Paul.

[Marthinus]

javap TestClass produces this when I run it:

class app.TestClass {
app.TestClass();
java.lang.String m1(int[]);
java.lang.String m2(int...);
}

I just put it in an app package. Don't believe that should change anything?

[admin]

Not sure what you mean. Please specify exactly what is your doubt.

[danko82]

I really don't understand why this is wrong:
public void test1(int[] i){}

If I understood well int[] i, int i[] and int... i are the same.
Can you explain me better the question?
Thanks

[admin]

This is a rule of the Java language. Even though a var-arg parameter of type int is very similar to int[], they are not interchangeable. Therefore, int[] cannot be substituted for int... in the code.

Also, there is a fundamental difference - int... can take one int argument, while int[] i or int i[] must take an int array. You can't just pass one int to a method that takes int array.

[lukaszet]

This is a rule of the Java language. Even though a var-arg parameter of type int is very similar to int[], they are not interchangeable. Therefore, int[] cannot be substituted for int... in the code.

Also, there is a fundamental difference - int... can take one int argument, while int[] i or int i[] must take an int array. You can't just pass one int to a method that takes int array.

Sorry, I still don't understand it. Why below option is invalid?

Code: Select all

public void test1(int[] i){}

test1(10); //1
test1(10, 20); //2

In some questions I've encountered main method that takes one String as an argument which is converted to array of lenght 1. Isn't (int[] i) similar to (String[] args)?

[admin]

1. Because i is an array of ints, but you are passing either a single int.
2. Because method test1 takes a parameter that is an array of ints, but you are passing two individual ints.

main method does not take one or two or any number of Strings as an argument. main method takes a String array as an argument. What you do is, you specify one string or multiple strings on the command line. The JVM puts all of them into a String array and then passes that array to the main method.

As mentioned above the ... operator and [] are not interchangeable. i.e. ... and [] are not exactly same although in some aspects they do operate similarly.

HTH,
Paul.