Why is varargs always the last parameter in a method signature?

Question

Why does varargs have to be the last parameter in method signature?

I want to know the reason.

Flush

If thats not the way, then in the method usage, how can the compiler find out where the varargs end and next method arg begins? – Aftonag

The varargs can be distinguished by first identifying the non-varargs and taking the rest as the varargs irrespective of whether they appear at the start or the end. Currently if there are five arguments with the last one as varargs then it is resolved as whatever comes after the fourth is the varargs. This can be reversed also like if there are five arguments with the first as varargs, resolve from end to start, like the last four are normal and whatever is there excluding the last four are part of the first vararg :) I think it's just implemented this way since there is no real need till now – Nightingale

See the interview with C family of language creators here [ C Family Interview](gotw.ca/publications/c_family_interview.htm) where Gosling says "I had this personal rule that by and large I didn't put anything in just because I thought it was cool. Because I had a user community the whole time, I'd wait until several people ganged up on me before I'd stick anything in. If somebody said, "Oh, wouldn't that be cool," by and large I ignored them until two or three people came up to me and said "Java ought to do this." Then I'd start going, well, maybe people will actually use it." – Nightingale

Answer 1

Because it makes the compiler's life simpler. There's no real reason why it couldn't have more arguments after, but it would require a much more complex compiler and so the spec was written that way.

Kersey

Thanks for your answer, but by above comments I think this not possible,for sample: 'public void test(String...names,String code)', compiler can't distinguish between names and code parameter. – Flush

Yes it can. It counts all of the arguments, sticks the last in code, and all the others in names. – Kersey

You are right to say that "varargs must always be last" makes the Java compiler team's work much easier. However, this isn't really a parsing issue, since the parser generates ASTs. This rule just makes a whole lot of other parts of the compiler, such as overload resolution, much easier. – Berkley

@Adam Mihalcin I don't know AST concept,please discuss more and its relation with varargs issue. – Flush

@MJM The definition of an AST is outside the scope of your question, but here's a comment-sized explanation: a compiler is divided into a lexer that tokenizes the source code, a parser that builds abstract syntax trees (ASTs) from the tokens, an optional type checker and optimizer that operate on ASTs, and a code generator to convert those ASTs from some internal representation into bytecode. See en.wikipedia.org/wiki/Compiler for an overview of how a compiler works. – Berkley

Answer 2

The main reason is because it would be potentially ambiguous otherwise....

For example, how could the compiler tell whether arguments are varargs or separate named arguments in a long list of arguments with multple varargs?

Imagine a method signature like:

printNames(String... girls, String... boys);

If you do printNames("Lucy", "Jo", "Paul") is Jo a boy or a girl?

As another example of ambiguity, having varargs earlier in the argument list could cause problems when there are overloaded methods. For example:

printFruit(String... apples, String orange);
printFruit(String... apples, String grapefruit, String orange);

How can the compiler tell whether the second-to-last argument is a grapefruit or an additional apple?

Note that this isn't unique to Java, most languages that support varargs only allow then to be at the end of the argument list for the same reason.

Mesomorphic

"multiple varargs" is completely a different issue from "varargs always last". – Kersey

@Ignacio Vazquez-Abrams Other languages don't allows multiple varargs also? – Flush

They are closely related.... I'd argue that the constraint of varargs only being the last argument is what causes multiple varargs to be impossible. – Mesomorphic

@Mesomorphic I having accepted the your comment(yoy say:"They are closely related") but in last sample,compiler can distinguish three parameter,two last parameter are grapefruit and orang,and others are apples. – Flush

It's also possible for the compiler to just outright reject all variants which may cause ambiguities, rather than just putting it in the spec. – Kersey

This can't be achieved by resolving the arguements backwards ? Anyways the runtime will know how many arguements are passed if there are 20 total then the last two are grapefruit and orange and the rest in apples. – Nightingale

I don't understand why ain't your answer is accepted as the Correct Answer? – With