 GeeksforGeeks App
Open App Browser
Continue

## Related Articles

Here we will be discussing the varargs / variable arity method and how we can overload this type of method. So let us first understand what a variable arity method is and its syntax. A variable arity method also called as varargs method, can take a number of variables of the specified type.

Note: Until version 1.4 there is no varargs method. It was introduced in version 1.5 and exists onwards.

Syntax:

`methodName(dataType...variableName)`

” … ” means the method can take any number of arguments of the specified data type, even zero. Internally varargs method is implemented using a single dimension(1D) array concept.

Example 1:

## Java

 `// Java Program to Illustrate Variable arity Method` `// Importing required classes``import` `java.io.*;` `// Main class``class` `GFG {` `    ``// Method 1``    ``// Main driver method``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Calling varargs sum method with no parameter``        ``sum();` `        ``// Calling varargs sum method with two int type``        ``// parameters``        ``sum(``10``, ``10``);` `        ``// Calling varargs sum method with three int type``        ``// parameters``        ``sum(``15``, ``15``, ``20``);``    ``}` `    ``// Method 2``    ``// varargs method expects zero or``    ``// more int type parameters``    ``public` `static` `void` `sum(``int``... x)``    ``{``        ``int` `total = ``0``;` `        ``// Takes parameters passed to sum, one at a time``        ``// later summing it up``        ``for` `(``int` `y : x) {``            ``total += y;``        ``}` `        ``// Print the sum on console``        ``System.out.println(``"Sum : "` `+ total);``    ``}``}`

Output

```Sum : 0
Sum : 20
Sum : 50```

Now let us have a look at few important facts about the varargs method and the acceptable order of parameters. The following points will help to improve the understanding of the varargs method which are as follows:

1.1 Varargs parameters can be mixed with normal parameters.

`methodName(int x, String...y)`

1.2 During mixing, varargs parameter should be last

1.3 There can only be one vararg parameter

1.4 In general, varargs method will get the last priority means if no other method is matched then only varargs method will be called. The following example will sail across this concept.

Example:

## Java

 `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``sum(``9``);``        ``// Since we are passing two int type arguments and``        ``// we have defined a function which expects two int``        ``// type parameters so that particular method (normal``        ``// sum method ) will be called and not varargs``        ``// method.``        ``sum(``10``, ``20``);``    ``}` `    ``// normal method which expects two int type parameters``    ``public` `static` `void` `sum(``int` `x, ``int` `y)``    ``{``        ``System.out.println(``"normal method"``);``        ``System.out.println(``"Sum : "` `+ (x + y));``    ``}` `    ``// varargs method which expects zero or more int type``    ``// parameters``    ``public` `static` `void` `sum(``int``... x)``    ``{``        ``System.out.println(``"varargs method"``);``        ``int` `total = ``0``;``        ``for` `(``int` `y : x) {``            ``total += y;``        ``}``        ``System.out.println(``"Sum : "` `+ total);``    ``}``}`

Output

```varargs method
Sum : 9
normal method
Sum : 30```

1.5 Using arrays to pass the variable number of arguments is an old approach to varargs, which is not suitable.

So let us do discuss the overloading varargs method. We know that if a class has multiple methods having the same name but different parameters, it is known as Method Overloading. The same is valid for varargs method also. Let us implement the same

Implementation: Here ‘vaTest’ is overloaded as each occurrence of vaTest expects a different argument list. Which occurrence of vaTest will be called to execute the operations on the parameters depends on the type of each parameter.

Example:

## Java

 `// Java Program to illustrate Overloading in Variable``// arity` `// Importing input output classes``import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``vaTest(``1``, ``2``, ``3``, ``4``, ``5``);``        ``vaTest(``true``, ``true``, ``false``, ``true``);``        ``vaTest(``"Message"``, ``10``, ``20``);``    ``}` `    ``// Method 1``    ``// varargs method which expects zero or``    ``// more int type parameters``    ``public` `static` `void` `vaTest(``int``... x)``    ``{` `        ``// Print statement on console``        ``System.out.println(``            ``"varargs method with int type arguments"``);` `        ``for` `(``int` `y : x) {``            ``System.out.print(``" "` `+ y);``        ``}``        ``System.out.println();``    ``}` `    ``// Method 3``    ``// varargs method which expects zero or``    ``// more boolean type parameters``    ``public` `static` `void` `vaTest(``boolean``... x)``    ``{` `        ``// Print statement on console``        ``System.out.println(``            ``"varargs method with boolean type arguments"``);` `        ``for` `(``boolean` `y : x) {``            ``System.out.print(``" "` `+ y);``        ``}``        ``System.out.println();``    ``}` `    ``// Method 3``    ``// varargs() method which expects first parameter to be``    ``// of String type and then zero or more int type``    ``// parameters.``    ``public` `static` `void` `vaTest(String msg, ``int``... x)``    ``{` `        ``// Print statement on console``        ``System.out.print(msg);` `        ``for` `(``int` `y : x) {``            ``System.out.print(``" "` `+ y);``        ``}` `        ``// New line``        ``System.out.println();``    ``}``}`

Output

```varargs method with int type arguments
1 2 3 4 5
varargs method with boolean type arguments
true true false true
Message 10 20```

Note: A vararg method can also be overloaded by the non-varargs method. vaTest(boolean x) is valid to  overload vaTest. This vaTest(boolean x) will be invoked only if one boolean argument is passed, otherwise (boolean…x).

Ambiguities: There also do occurs some ambiguities as listed:

• Call to vaTest is ambiguous because varargs can be empty and hence this call can be equally translated to either vaTest(int…x) or vaTest(boolean…x).
• Let us suppose we have two methods , vaTest(int…x) and vaTest(int a, int…x) . Now , if we call vaTest(1) , both formats are valid. Therefore ambiguity,

My Personal Notes arrow_drop_up
Related Tutorials