¿Por qué debería sobrecargar los métodos?

La sobrecarga es útil cuando crea métodos que hacen lo mismo con valores de tipo diferente.

Math la clase proporciona un ejemplo perfecto-tiene grupos de sobrecarga de funciones por tipo-cuatro abs, cuatro min, cuatro max, y así sucesivamente:

int max(int a, int b) {...}
float max(float a, float b) {...}
long max(long a, long b) {...}
double max(double a, double b) {...}

Una alternativa sin sobrecarga le obligaría a "codificar" el tipo en el nombre de su método, por ejemplo, Math.intMax(a, b) lo que sería perjudicial para la legibilidad del código del usuario.

Ser simple y conciso: La sobrecarga es solo una posibilidad proporcionada por Java (pero la mayoría de los lenguajes modernos y flexibles la usan) (y otros lenguajes como C++ o C#) para permitir a los desarrolladores crear para un mismo nombre de método/función, varios de ellos.

¿Por qué ?
Porque la nomenclatura de métodos es importante y la nomenclatura de métodos debe transmitir el comportamiento de la misma. Por lo tanto, si dos métodos tienen el mismo comportamiento (Convertir a una cadena, por ejemplo) pero que uno utiliza un largo como entrada y que el otro utiliza un int como entrada, ¿por qué tener un nombre de método diferente ?

    String myString = String.valueOf(new Integer(1));
    String myOtherString = String.valueOf(new Long(2));

La intención y el objetivo son los mismos, solo los parámetros de entrada cambian.

Cuando la sobrecarga es significativa, debe usarla en lugar de crear algunas variantes de nombres torpes.

La sobrecarga del método es útil en el siguiente escenario:

Considere que tiene una clase que realiza un seguimiento de una lista de nombres. Tiene el estilo de código anterior, donde cada método tiene su propia opinión sobre la realización de operaciones en esta lista de nombres.

De repente, la representación interna de la lista cambia (tal vez de un array a un ArrayList, realmente no importa). Quieres ser el responsable de refactorizar cada. single . método?

Método la sobrecarga es útil porque entonces puede enrutar todas las operaciones a través de un único método genérico. Esto significa que cada vez que una representación interna cambia, solo tiene que cambiar ese método genérico, y todos sus otros métodos especializados siguen funcionando igual.

También, considere su ejemplo proporcionado. ¿Qué sucede si desea cambiar la forma en que el programa imprime el mensaje? Tendrás que modificar ambos métodos para imprimir el mismo tipo de mensaje, una pesadilla de mantenimiento. Asegúrese, parece pequeño ahora, pero piensa en cuando tu proyecto crezca, y empiezas a tener muchos más métodos que dependen de este formato de mensaje (efectivamente fijo).

Soy un objeto y tengo una capacidad, la capacidad es fija, pero puede aceptar varios parámetros.

Si la capacidad puede aceptar 1000 tipos de parámetros, ¿quieres romper tu cerebro para pensar en 1000 nombres de capacidad?

Tomar otros post como una buena práctica de sobrecarga y tomar lo que JNIEnv hacer como una mala práctica causa C no soporta la sobrecarga.

CallStaticObjectMethod,
CallStaticObjectMethodV,
CallStaticObjectMethodA,
CallStaticBooleanMethod,
CallStaticBooleanMethodV,
CallStaticBooleanMethodA,
CallStaticByteMethod,
CallStaticByteMethodV,
CallStaticByteMethodA,
CallStaticCharMethod,
CallStaticCharMethodV,
CallStaticCharMethodA,
CallStaticShortMethod,
CallStaticShortMethodV,
CallStaticShortMethodA,
CallStaticIntMethod,
CallStaticIntMethodV,
CallStaticIntMethodA,
CallStaticLongMethod,
CallStaticLongMethodV,
CallStaticLongMethodA,
CallStaticFloatMethod,
CallStaticFloatMethodV,
CallStaticFloatMethodA,
CallStaticDoubleMethod,
CallStaticDoubleMethodV,
CallStaticDoubleMethodA,
CallStaticVoidMethod,
CallStaticVoidMethodV,
CallStaticVoidMethodA,

Reger to JNI for more detailed struct definition

Otra razón para sobrecargar es proporcionar uno o más argumentos predeterminados.

Considere lo siguiente:

class Something {
    // Imagine that this is a real class, that does real work.

    public void doSomething(boolean b, char c, double d, int i) {
        // Imagine that this is one of the main components of class Something.
        System.out.println("Hi. You passed: " + b + ", " + c + ", " + d + ", and " + i + ".");
    }

    public void doSomething(boolean b, char c, double d) {
        doSomething(b, c, d, 42);
    }

    public void doSomething(boolean b, char c) {
        doSomething(b, c, 1.3579);
    }

    public void doSomething(boolean b) {
        doSomething(b, 'q');
    }

    public void doSomething() {
        doSomething(true);
    }
}

En este ejemplo, cada sobrecarga proporciona un valor predeterminado para uno de los parámetros, encadenándolos juntos hasta obtener una llamada completa a la versión de doSomething() que realmente hace el trabajo.

Something s = new Something();
Something t = new Something();
Something u = new Something();

// ...

s.doSomething(true, 'c', 2.9);
t.doSomething(false, 'z');
u.doSomething();

Ver aquí para un ejemplo.