Sobrecarga en Java

La sobrecarga permite que diferentes métodos tengan el mismo nombre, pero diferentes firmas donde la firma puede diferir por el número de parámetros de entrada o el tipo de parámetros de entrada o ambos. La sobrecarga está relacionada con el polimorfismo en tiempo de compilación (o estático).

// Java program to demonstrate working of method
// overloading in Java.
  
public class Sum {
  
    // Overloaded sum(). This sum takes two int parameters
    public int sum(int x, int y)
    {
        return (x + y);
    }
  
    // Overloaded sum(). This sum takes three int parameters
    public int sum(int x, int y, int z)
    {
        return (x + y + z);
    }
  
    // Overloaded sum(). This sum takes two double parameters
    public double sum(double x, double y)
    {
        return (x + y);
    }
  
    // Driver code
    public static void main(String args[])
    {
        Sum s = new Sum();
        System.out.println(s.sum(10, 20));
        System.out.println(s.sum(10, 20, 30));
        System.out.println(s.sum(10.5, 20.5));
    }
}

Producción :

30
60
31.0

Surge la pregunta:
P. ¿Qué sucede si el prototipo exacto no coincide con los argumentos?
Respuesta
En cuanto a la prioridad, el compilador sigue estos pasos:

1. Conversión de tipo pero a tipo superior (en términos de rango) en la misma familia.
2. Escriba la conversión a la siguiente familia superior (suponga que si no hay un tipo de datos largo disponible para un tipo de datos int, entonces buscará el tipo de datos flotante).

Tomemos un ejemplo para aclarar el concepto: –

class Demo {
    public void show(int x)
    {
        System.out.println("In int" + x);
    }
    public void show(String s)
    {
        System.out.println("In String" + s);
    }
    public void show(byte b)
    {
        System.out.println("In byte" + b);
    }
}
class UseDemo {
    public static void main(String[] args)
    {
        byte a = 25;
        Demo obj = new Demo();
        obj.show(a); // it will go to
        // byte argument
        obj.show("hello"); // String
        obj.show(250); // Int
        obj.show('A'); // Since char is
        // not available, so the datatype
        // higher than char in terms of
        // range is int.
        obj.show("A"); // String
        obj.show(7.5); // since float datatype
// is not available and so it's higher
// datatype, so at this step their
// will be an error.
}
}

¿Cuál es la ventaja?
No tenemos que crear y recordar diferentes nombres para funciones que hacen lo mismo. Por ejemplo, en nuestro código, si Java no admitiera la sobrecarga, tendríamos que crear nombres de métodos como sum1, sum2, … o sum2Int, sum3Int, … etc.

¿Podemos sobrecargar los métodos en el tipo de retorno?
No podemos sobrecargar por tipo de devolución. Este comportamiento es el mismo en C++. Consulte esto para más detalles

public class Main {
    public int foo() { return 10; }
  
    // compiler error: foo() is already defined
    public char foo() { return 'a'; }
  
    public static void main(String args[])
    {
    }
}

Sin embargo, los métodos de sobrecarga en el tipo de devolución son posibles en los casos en que el tipo de datos de la función que se llama se especifica explícitamente. Mira los ejemplos a continuación:

// Java program to demonstrate the working of method
// overloading in static methods
public class Main {
  
    public static int foo(int a) { return 10; }
    public static char foo(int a, int b) { return 'a'; }
  
    public static void main(String args[])
    {
        System.out.println(foo(1));
        System.out.println(foo(1, 2));
    }
}

Producción:

10
a

// Java program to demonstrate working of method
// overloading in  methods
class A {
    public int foo(int a) { return 10; }
  
    public char foo(int a, int b) { return 'a'; }
}
  
public class Main {
  
    public static void main(String args[])
    {
        A a = new A();
        System.out.println(a.foo(1));
        System.out.println(a.foo(1, 2));
    }
}

Producción:

10
a

¿Podemos sobrecargar los métodos estáticos?
La respuesta es ‘ Sí ‘. Podemos tener dos o más métodos estáticos con el mismo nombre, pero con diferencias en los parámetros de entrada. Por ejemplo, considere el siguiente programa Java. Consulte esto para más detalles.

¿Podemos sobrecargar métodos que difieren solo por palabra clave estática?
No podemos sobrecargar dos métodos en Java si difieren solo por una palabra clave estática (la cantidad de parámetros y los tipos de parámetros son los mismos). Consulte el siguiente programa Java, por ejemplo. Consulte esto para más detalles.

¿Podemos sobrecargar main() en Java?
Al igual que otros métodos estáticos, podemos sobrecargar main() en Java . Consulte sobrecarga de main() en Java para obtener más detalles.

// A Java program with overloaded main()
import java.io.*;
  
public class Test {
  
    // Normal main()
    public static void main(String[] args)
    {
        System.out.println("Hi Geek (from main)");
        Test.main("Geek");
    }
  
    // Overloaded main methods
    public static void main(String arg1)
    {
        System.out.println("Hi, " + arg1);
        Test.main("Dear Geek", "My Geek");
    }
    public static void main(String arg1, String arg2)
    {
        System.out.println("Hi, " + arg1 + ", " + arg2);
    }
}

Producción :

Hi Geek (from main)
Hi, Geek
Hi, Dear Geek, My Geek

¿Java admite la sobrecarga de operadores?
A diferencia de C++, Java no permite operadores sobrecargados definidos por el usuario. Internamente, Java sobrecarga los operadores, por ejemplo, + está sobrecargado para la concatenación.

¿Cuál es la diferencia entre Overloading y Overriding ?

• La sobrecarga se trata de que la misma función tenga diferentes firmas. La anulación se trata de la misma función, la misma firma pero diferentes clases conectadas a través de la herencia.
  
• La sobrecarga es un ejemplo de polimorfismo en tiempo de compilación y la anulación es un ejemplo de polimorfismo en tiempo de ejecución.

Artículos relacionados:

• Diferentes formas de sobrecarga de métodos en Java
• Sobrecarga de método y error nulo en Java
• ¿Podemos sobrecargar o anular métodos estáticos en Java?

Este artículo es una contribución de Shubham Agrawal . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.