Sobrecarga del método de aridad variable en Java

Aquí discutiremos el método varargs/variable arity y cómo podemos sobrecargar este tipo de método. Entonces, primero comprendamos qué es un método de aridad variable y su sintaxis. Un método de aridad variable, también llamado método varargs, puede tomar una cantidad de variables del tipo especificado.

Nota: Hasta la versión 1.4 no existe el método varargs. Se introdujo en la versión 1.5 y existe en adelante.

Sintaxis:

methodName(dataType...variableName)

«…» significa que el método puede tomar cualquier cantidad de argumentos del tipo de datos especificado, incluso cero. El método varargs interno se implementa utilizando un concepto de array de una sola dimensión (1D).

Ejemplo 1:

// 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);
    }
}

Sum : 0
Sum : 20
Sum : 50

Ahora echemos un vistazo a algunos hechos importantes sobre el método varargs y el orden aceptable de los parámetros. Los siguientes puntos ayudarán a mejorar la comprensión del método varargs, que son los siguientes:

1.1 Los parámetros Varargs se pueden mezclar con parámetros normales.

methodName(int x, String...y)

1.2 Durante la mezcla, el parámetro varargs debe ser el último

1.3 Solo puede haber un parámetro vararg

1.4 En general, el método varargs obtendrá la última prioridad, lo que significa que si no hay coincidencia con ningún otro método, solo se llamará al método varargs. El siguiente ejemplo navegará a través de este concepto.

Ejemplo:

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);
    }
}

varargs method
Sum : 9
normal method
Sum : 30

1.5 El uso de arrays para pasar el número variable de argumentos es un enfoque antiguo para varargs, que no es adecuado.

Entonces, analicemos el método de sobrecarga de varargs. Sabemos que si una clase tiene varios métodos con el mismo nombre pero diferentes parámetros, se conoce como sobrecarga de métodos. Lo mismo es válido para el método varargs también. Implementemos lo mismo

Implementación: aquí ‘vaTest’ está sobrecargado ya que cada aparición de vaTest espera una lista de argumentos diferente. La instancia de vaTest que se llamará para ejecutar las operaciones en los parámetros depende del tipo de cada parámetro.

Ejemplo:

// 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();
    }
}

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

Nota: Un método vararg también puede ser sobrecargado por el método no varargs. vaTest(boolean x) es válido para sobrecargar vaTest. Este vaTest(booleano x) se invocará solo si se pasa un argumento booleano, de lo contrario (booleano…x).

Ambigüedades: También ocurren algunas ambigüedades como se enumeran:

• La llamada a vaTest es ambigua porque los varargs pueden estar vacíos y, por lo tanto, esta llamada se puede traducir por igual a vaTest(int…x) o vaTest(int…y).
• Supongamos que tenemos dos métodos, vaTest(int…x) y vaTest(int a, int…x) . Ahora, si llamamos a vaTest(1), ambos formatos son válidos. Por lo tanto, la ambigüedad,