Sobrecarga de métodos no válidos en Java

Los métodos sobrecargados son aquellos que pertenecen a la misma clase, tienen el mismo nombre pero diferentes argumentos. El concepto de sobrecarga de métodos proviene del polimorfismo . Literalmente, «poli» significa muchos y «morfismo» significa forma. 

Considere un ejemplo de la vida real del agua como polimórfica porque puede tomar muchas formas (sólido, líquido y gaseoso). De manera similar, en Java, podemos crear múltiples métodos con el mismo nombre en la misma clase. Aquí discutiremos la sobrecarga de métodos no válidos en Java, pero antes de eso, revisemos brevemente la sobrecarga de métodos.

Condiciones para la sobrecarga de métodos

• Podemos crear múltiples métodos del mismo nombre en la misma clase.
• El número de argumentos, la secuencia de argumentos y los tipos de argumentos deben diferir.

Ilustración: sobrecarga del método 

// Java Program to Illustrate Method Overloading
 
// Main class
class GFG {
 
    // Method 1
    void show()
    {
        // Print statement
        System.out.println("Method to be overloaded.");
    }
 
    // Method 2
    // Overloading Method 1
    // by changing arguments
    void show(int x)
    {
        // Print statement
        System.out.println("Overloaded method:: 1");
    }
 
    // Method 3
    // Overloading show method by changing arguments
    void show(String a, int x)
    {
        System.out.println("Overloaded method:: " + x);
    }
 
    // Method 4
    // Overloading show method
    // by changing arguments
    void show(String a, int b, boolean c)
    {
        System.out.println("Overloaded method:: " + b);
    }
 
    // Method 5
    // Overloading Method 1 by
    // changing arguments as well as return type
    String show(String s)
    {
        // Print statement
        return "Overloaded method:: 5";
    }
 
    // Method 6
    // Main driver method
    public static void main(String[] args)
    {
        // Creating object of class inside main()
        GFG obj = new GFG();
 
        // Calling all methods as defined above
        // to seek overloading concepts
        obj.show();
        obj.show(1);
        obj.show("String", 2);
        obj.show("String", 3, true);
        System.out.println(obj.show("String"));
        obj.show('a');
    }
}

Producción-

Method to be overloaded.
Overloaded method:: 1
Overloaded method:: 2
Overloaded method:: 3
Overloaded method:: 5
Overloaded method:: 1

¿Cuándo surgen los casos de sobrecarga de métodos no válidos?

Los casos de sobrecarga de métodos no válidos surgen debido a la siguiente razón:

1. Si intentamos llamar a más de un método con el mismo nombre y lista de argumentos. Esto se puede justificar a partir del bloque de código 1.
2. Cuando tratamos de sobrecargar el método cambiando solo el tipo de retorno. Esto se puede justificar a partir del bloque de código 2.

Implementación:

Considere el ejemplo dado a continuación. Cuando intentemos llamar al método » add(1,2) «, el compilador se confundirá ya que no existe tal instrucción para preferir int sobre double y viceversa, como resultado, mostrará un error de compilación.

int add(int a, int b)
double add(int a, int b)

Ejemplo 1-A

// Demo class
class Demo {
    // Programmer defined "mymethod"
    public int myMethod(int num1, int num2)
    {
        System.out.println("First myMethod of class Demo");
        return num1 + num2;
    }
    // Trying to overload "mymethod"
    public int myMethod(int num3, int num4)
    {
        System.out.println("Second myMethod of class Demo");
        return num4 - num3;
    }
}
// Driver class
class GFG {
    // main method
    public static void main(String args[])
    {
        Demo obj1 = new Demo();
        obj1.myMethod(1, 2);
        obj1.myMethod(3, 4);
    }
}

Producción:

prog.java:7: error: method myMethod(int,int) is already defined in class Demo
    public int myMethod(int num3, int num4)
               ^
1 error

Ejemplo 1-B

// Java Program to Illustrate No Roleplay of Returntype
// Even changed in Method Overloading
 
// Main class
class GFG {
 
    int a, b;
 
    // Declared method
    void add(int x, int y)
    {
        // This refers to current instance itself
        this.a = x;
        this.b = y;
 
        // Printing the sum
        System.out.println("SUM:: " + (a + b));
    }
 
    // Method 2
    // To add numbers
    // Overloading the above declared method by
    // changing the return type only
    double add(int x, int y)
    {
        this.a = x;
        this.b = y;
        return a + b;
    }
 
    // Method 3
    // Main method method
    public static void main(String[] args)
    {
        // Creating object of class inside main()
        GFG obj = new GFG();
 
        // Calling add() method by passing
        // custom inputs as parameters
        obj.add(5, 2);
 
        // Trying printing the sum
        System.out.println("Sum:: " + obj.add(3, 4));
    }
}

Producción:

prog.java:8: error: method add(int,int) is already defined in class GFG
  double add(int x,int y){
         ^
prog.java:17: error: 'void' type not allowed here
      System.out.println("Sum:: "+obj.add(3,4));
                                         ^
2 errors

Conclusión:  No podemos llamar a más de un método con el mismo nombre y lista de argumentos. El tipo de retorno del método no desempeñará ningún papel en la sobrecarga del método, en Java no es posible lograr la sobrecarga cambiando solo el tipo de retorno del método.