Strange 'var arg' method.

[Tom Kowalski]

I have discovered today really strange (for me) thing in Java. On one hand it makes sense, but on the other, I just want to scream 'What the heal?'. I put it here, because it might be useful for people who are learning for SCJP.

public void foo(Object...arg ) {
 System.out.println(arg.length);
}

...
Object list = new String[]{"j","a","v","a"};
foo(list); // will print 1
foo(new String[]{"j","a","v","a"}) //will print 4

...

[Tommy Delson]

I found this is totally normal, if we pay attention to closely line 6-8 we'll see the behavior clearly.

Line6 create an anonymous String array and assigned it to ref variable "list" type Object.
Line 7 passing a copy of "list" into foo() method that takes zero to many Objects.
Line 8 a new an anonymous array declared, initialized, and created in the foo() method.

Do you see the different between line 6 & 8?? That's where it get interesting....

[Tom Kowalski]

I don't want to be rough, but you have just 'read' what I have put in code. Nothing more, nothing less.

[Suhrid Karthik]

Tom Kowalski wrote:I have discovered today really strange (for me) thing in Java. On one hand it makes sense, but on the other, I just want to scream 'What the heal?'. I put it here, because it might be useful for people who are learning for SCJP.

public void foo(Object...arg ) {
 System.out.println(arg.length);
}

...
Object list = new String[]{"j","a","v","a"};
foo(list); // will print 1
foo(new String[]{"j","a","v","a"}) //will print 4

...

Good point ! When I tried compiling it, the compiler throws up this informative warning:

warning: non-varargs call of varargs method with inexact argument type for last parameter;
cast to java.lang.Object for a varargs call
cast to java.lang.Object[] for a non-varargs call and to suppress this warning
foo(new String[] {"j","a","v","a"});

So, in essence when you pass a String[] to foo, the call is treated as a non-varargs call.

[Tomasz Sochanski]

Nothing strange here. Signature:

public void foo(Object... arg )

means, that you can pass as an array of Objects or just one Object. If you pass one object it will be converted to one-element Object array, so in the code

Object list = new String[]{"j","a","v","a"};
foo(list);

you pass 'list' variable which is an Object type - this one is converted to one element Object array
However when you call:

foo(new String[]{"j","a","v","a"});

compiler first needs to cast String[] array either to Object or to Object[] (both are accepted for foo() method signature). It does it trying to cast to more specific parameter first (Object[]). If you don't wan't to let it choose which casting is better you can explicitely do your favourite casting before:

foo((Object) new String[]{"j","a","v","a"});  // output is 1, one element array of Objects is passed, you can prefer such behaviour if you want
foo((Object[]) new String[]{"j","a","v","a"}); // output is 4, four element array of Objects is passed

which results in 2 different arrays (first is one element array containing String[] array as the only element, second is 4 element Object[] array containing objects of type String)

[Matthew Brown]

It's a very interesting example. You've got to be careful with Object... arguments, because of they way they can match anything.

The relevant part of the Java Language Specification says:

The process of evaluating of the argument list differs, depending on whether the method being invoked is a fixed arity method or a variable arity method (§8.4.1).

If the method being invoked is a variable arity method (§8.4.1) m, it necessarily has n>0 formal parameters. The final formal parameter of m necessarily has type T[] for some T, and m is necessarily being invoked with k>=0 actual argument expressions.

If m is being invoked with k!=n actual argument expressions, or, if m is being invoked with k=n actual argument expressions and the type of the kth argument expression is not assignment compatible with T[], then the argument list (e1, ... , en-1, en, ...ek) is evaluated as if it were written as (e1, ..., en-1, new T[]{en, ..., ek}).

In this case, a String[] can be assigned to an Object[], but an Object (the reference type of the variable) can't be without an explicit cast.