java - para - manual de programacion android pdf

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

Question

Encontré dos ejemplos en mi libro de métodos de sobrecarga, pero no explica claramente por qué es útil:

package keepo;
public class Main{
    public static void main(String [] args)
    {
        int newScore = calculateScore("Tim", 500);
        System.out.println("New Score is" + newScore);
        calculateScore(75);

    }
    public static int calculateScore(String playerName, int score){
        System.out.println("Player" + playerName +"Has score" + score);
        return score * 1000;
    }
    public static int calculateScore(int score){
        System.out.println("Unnamed player scored" + score + "points");
        return score * 1000;
    }
}

Esto es bastante sencillo, pero honestamente parece bastante inútil sobrecargar el método aquí, y parece que solo lo hace por el simple hecho de hacerlo.

El siguiente ejemplo en el libro sobrecarga el método, que parece un poco más útil, porque ese programa calcula pies a centímetros, y hay un método donde puedes poner pies y pulgadas, y un método donde puedes poner pulgadas. Sin embargo, parece igual de fácil hacer dos métodos separados para esto.

Dicho esto, ¿hay algún beneficio real al hacer esto? (Lo leí, pero no estoy realmente satisfecho. Parece tan fácil hacer nuevos métodos).

Answer 1

Creo que si hablas de los beneficios reales de la sobrecarga de función / método, algo sin lo cual no te saldrá bien, entonces, como has señalado en tu pregunta, no encontrarás ninguno.

Pero, ¿cómo es útil? Consideremos este ejemplo.

Supongamos que estoy haciendo una aplicación que encuentra a una persona por su nombre y declaro y defino un método

public Person[] findPerson(String name)

Ahora tenemos un requisito en el que tenemos que encontrar a una persona en su fecha de nacimiento, así que introduce un nuevo método

public Person[] findPerson_byDOB(Date date)

Supongamos que esto continúa y tenemos muchos métodos en mi aplicación.

public Person[] findPerson(String name)
public Person[] findPerson_byDOB(Date date)
public Person[] findPerson_byAddress(Address address)
public Person[] findPerson_bySSN(SSN ssn)
public Person[] findPerson_byDepartment(Department department)
public Person[] findPerson_byMobile(Mobile mobile)

Es solo una parte; esto puede continuar cuando se nos pide que introduzcamos varios parámetros, como

public Person[] findPerson_byMobileAndAddress(Mobile mobile, Address address)
public Person[] findPerson_byAddressAndDepartment(Address address, Department department)
public Person[] findPerson_byDOBAndDepartment(DOB dob, Department, department)
public Person[] findPerson_byAddressAndDOB(Address address, DOB dob)

y muchos muchos mas...

Si bien esto puede parecer un poco exagerado, confíe en mí, al hacer una aplicación real a nivel industrial, podemos encontrarnos con una situación en la que obtenemos cientos y cientos de métodos como este, y en última instancia necesitaremos un catálogo de todos estos métodos de lo que realmente hacen

En realidad, es una pesadilla cuando tendremos que encontrar el nombre de todos estos métodos cuando deberíamos usarlo.

Sin embargo, cuando todos los parámetros son diferentes, podemos darle el mismo nombre a la función y realmente es muy fácil de recordar.

public Person[] findPerson(String name)
public Person[] findPerson(Date date)
public Person[] findPerson(Address address)
public Person[] findPerson(SSN ssn)
public Person[] findPerson(Department department)
public Person[] findPerson(Mobile mobile)
public Person[] findPerson(Mobile mobile, Address address)
public Person[] findPerson(Address address, Department department)
public Person[] findPerson(DOB dob, Department, department)
public Person[] findPerson(Address address, DOB dob)

Ahora, como David señaló en su respuesta , todos sabemos cómo obtener String valor entero de la String ; probablemente lo hayamos leído en alguna parte.

static String.valueOf(new Integer(1));

¿Pero sabes cuántos más métodos hay sobrecargados con el mismo nombre?

static String.valueOf(boolean b)
static String.valueOf(char c)
static String.valueOf(char[] data)
static String.valueOf(double d)
static String.valueOf(float f)
static String.valueOf(int i)
static String.valueOf(long l)
static String.valueOf(Object obj)

Los beneficios son que no tiene que memorizarlos todos. Ni siquiera tiene que adivinar porque es el mismo nombre en todo momento.

EDITAR según el consejo de Namnodorel

Considere este método sobrecargado de la clase PrintStream .

void println()
void println(boolean x)
void println(char x)
void println(char[] x)
void println(double x)
void println(float x)
void println(int x)
void println(long x)
void println(Object x)
void println(String x)

Solo piense en la legibilidad si tuviéramos que escribir:

void println_emptyLine()
void println_boolean(boolean x)
void println_character(char x)
void println_characterArray(char[] x)
void println_double(double x)
void println_float(float x)
void println_integer(int x)
void println_long(long x)
void println_object(Object x)
void println_string(String x)

Answer 2

La sobrecarga de métodos es útil en el siguiente escenario:

Considere que tiene una clase que realiza un seguimiento de una lista de nombres. Tiene el estilo del código anterior, donde cada método tiene su propia función para realizar operaciones en esta lista de nombres.

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

La sobrecarga de métodos es útil porque luego 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.

Además, considere su ejemplo proporcionado. ¿Qué sucede si quiere cambiar la forma en que el programa imprime el mensaje? Tendrá que modificar ambos métodos para imprimir el mismo tipo de mensaje, una pesadilla de mantenimiento. Claro, ahora parece pequeño, pero piense cuando su proyecto crezca, y empiece a tener muchos más métodos confiando en este formato de mensaje (efectivamente corregido).

Answer 3

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

Math clase de Math 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 te obligaría a "codificar" el tipo en el nombre de tu método, por ejemplo, Math.intMax(a, b) que sería perjudicial para la legibilidad del código del usuario.

Answer 4

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

Considera 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 entre sí 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();

Vea here para un ejemplo.

Answer 5

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

Por qué ?
Debido a que la denominación del método es importante y el nombre del método debe transmitir el comportamiento de la misma. Entonces, si dos métodos tienen el mismo comportamiento (Converting to a String por ejemplo) pero uno usa una entrada larga como entrada y el otro usa 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 cambian los parámetros de entrada.

Cuando la sobrecarga es significativa, debe usarla en lugar de crear algunos nombres torpes variados.

Answer 6

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, ¿desea ampliar sus cerebros para pensar en 1000 nombres de capacidades?

Considere a los demás como una buena práctica de sobrecarga y tome lo que JNIEnv hace como una mala práctica porque C no admite 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 a JNI para una definición de estructura más detallada