Using varargs in methods
Varargs (variable-length arguments) in the Java programming language allow Java programmers to pass multiple declared parameter argument values to user-defined function methods without overloading the function method in the current program or creating multiple program variable parameter lists. Varargs arguments are used in a specific order in Java programs when the number of declared arguments is not already specified in the created program.
How Varargs Arguments Work in Java Functions.
When Java developers use varargs arguments in a function program, the declared parameter arguments are treated as an array in the program, while the Java programmer does not need to explicitly create or pass an array when calling the declared function method in the program. In this process, Java can automatically manage or handle these declared parameter arguments.
Varargs syntax in Java.
In a Java function program, you can declare or define a Varargs method by using three dots (…) before the parameter name in the signature.
<return_type> <method_name>(<parameter_type>… <parameter _name>) {
// Java function method argument body
}
Remember, in a Java function program, declared Varargs function arguments must always be defined as the last parameter in the method parameter list. In a varargs program, only one varargs parameter can be declared per method.
Example of Java Parameter Varargs.
So, let’s create a program in which the user declares a function program method, inputs individual numeric integer values, and finally adds these values and displays them.
Example of adding numbers to a method with Varargs in a Java function.
public class main
{
// here we implement varargs Method to total a number of given integers
public static int totalInteger(int… integers) {
int total = 0;
for (int integer : integers) {
total += integer; // here it Add each integer value to the total variable
}
return total;
}
public static void main(String[] args) {
// here it Calling the totalInteger method with different numbers of arguments
System.out.println(“\n Here the total of 7, 10, 4 integers – ” + totalInteger(7, 10, 4)); // Output is – 21
System.out.println(“\n Here the total of 5, 6, 11, 33 integers – ” + totalInteger(5, 6, 11, 33)); // Output is – 55
System.out.println(“\nHere the total of integers – ” + totalInteger()); // Output is – 0
}
}
Explaining varargs in a Java function.
- In this program, the varargs totalInteger(int… integers) function method takes multiple individual integer values as input.
- In the function method body, the integers value is treated as an array (of type int[]), and can be looped through in the program using a more efficient for loop.
- In the function’s main method, the programmer calls the user-defined varargs function method totalInteger() with multiple integer arguments.
Some facts about the Java Varargs function method.
Varargs must be last – Remember, if the Java programmer has other non-varargs parameter elements, the varargs parameter must be defined last in the function method signature.
public static void testMethod(int p, String… strings) {
// here it is a valid varargs method
}
// here This will cause a program compilation error
// public static void testMethod(String… strings, int p) {
// invalid declaration define, here the varargs function argument must be the last function parameter element
// }
Varargs is considered an array – Here, inside a user-defined function method, the varargs function parameter is treated as a Java program array. This means that Java users can define simple array manipulation operations such as indexing and for loop iteration using the varargs element.
Multiple Varargs calls – If no argument value is passed in a Java user program, then the varargs function parameter is treated as an empty array (new int[0]). Hence, calling a function method without arguments for a varargs function parameter is valid.
Varargs and Method Overloading – In Java function programs, Varargs arguments are used in function method overloading, but be careful while performing this operation. If a user-defined function method has a varargs parameter as a variable, and another function method has a parameter defined that can properly match the varargs arguments (e.g., an array or a specific number of parameters), then this can create confusion in the varargs argument.
Example of Java varargs arguments with other data types.
Java programmers can also use varargs arguments with other data types, such as String, double, char, etc., in their programs using varargs function parameter arguments.
Varargs parameter arguments are an example of the Strings data type in Java programming.
public class Main
{
// Here we use the displayStrings method to print multiple individual strings.
public static void displayStrings(String… strings) {
for (String strng : strings) {
System.out.println(strng);
}
}
public static void main(String[] args) {
displayStrings(“\n Vcanhelpsu”, “Java”, “Python”, “Function method”, “Varargs parameter”); // Here we define multiple individual strings.
displayStrings(“\n Simple string display”); // here it displays Single string text information
displayStrings(); // here No strings method call like (empty string method call)
}
}
Varargs function parameter example with doubles data type.
public class main
{
// here we use countAverage Method to calculate the average of multiple double integers number values
public static double countAverage(double… integers) {
if (integers.length == 0) {
return 0.0; // here No integers values passed, and it returns 0 values
}
double total = 0;
for (double integer : integers) {
total += integer;
}
return total / integers.length;
}
public static void main(String[] args) {
System.out.println(“\n Here the Average of integer 7.3, 9.2, 3.8, 11.4 – ” + countAverage(7.3, 9.2, 3.8, 11.4)); // Output is – 7.9
System.out.println(“\n Here the Average of integer 25.9, 37.4, 17.5, 22.7 – ” + countAverage(25.9, 37.4, 17.5, 22.7)); //Output is – 25.87
System.out.println(“\n Here the Average of integer no integers – ” + countAverage()); // Output is – 0.0
}
}
