36 votes

Pourquoi devrais-je jamais surcharger les méthodes?

J'ai trouvé deux exemples dans mon livre de la surcharge des méthodes, mais il n'explique pas clairement pourquoi il est utile:

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

C'est assez simple, mais honnêtement, il semble assez inutile de surcharge de la méthode ici, et il semble le faire juste pour le plaisir de le faire.

L'exemple suivant dans le livre ne surcharge de la méthode qui semble un peu plus utile, parce que ce programme calcule les pieds de centimètres, et il y a une méthode où vous pouvez mettre en pieds et en pouces, et une méthode où vous pouvez mettre des pouces. Cependant, il semble encore tout aussi facile de faire deux méthodes pour cela.

Cela étant dit, il y a de véritables avantages à faire cela? (J'ai lu cela, mais je ne suis pas vraiment satisfait. Il semble tout aussi facile de faire de nouvelles méthodes.)

63voto

Raman Sahasi Points 14959

Je pense que si vous parlez des avantages de la fonction/surcharge de la méthode, quelque chose sans laquelle vous ne pourrez pas obtenir votre chemin autour, alors comme vous l'avez indiqué dans votre question, vous ne trouverez pas.

Mais comment est-il utile? Prenons l'exemple.

Supposons que je suis en train de faire une application qui trouve une personne par son nom et j'ai déclarer et définir une méthode

public Person[] findPerson(String name)

Maintenant, nous obtenons une condition où nous avons trouver une personne par sa Date de Naissance, afin d'introduire une nouvelle méthode

public Person[] findPerson_byDOB(Date date)

Supposons que cela continue et que nous avons cela de nombreuses méthodes dans mon application.

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)

C'est juste une partie; cela peut mener lorsque l'on nous demande d'introduire plusieurs paramètres, comme

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)

et beaucoup, beaucoup plus...

Tandis que ceci peut sembler un peu exagéré, faites-moi confiance, lors de la prise réelle de l'industrie au niveau de l'application, nous pouvons venir dans une situation lorsque nous recevons des centaines et des centaines de méthodes de ce genre, et, finalement, nous allons avoir besoin d'un catalogue de l'ensemble de ces méthodes ce qu'ils font réellement.

Il est en fait un cauchemar quand nous aurons à trouver le nom de toutes ces méthodes lorsque nous aurait à l'utiliser.

Toutefois, lorsque tous les paramètres sont différents, on peut donner le même nom à la fonction et il devient vraiment très facile à retenir.

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)

Maintenant, comme David l'a souligné dans sa réponse, nous savons tous comment obtenir de l' String de la valeur de l'entier; probablement que nous avons lu quelque part.

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

Mais savez-vous combien d'autres méthodes sont là que sont surchargés avec le même nom?

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)

Les avantages sont que vous n'avez pas à mémoriser tous. Vous n'avez même pas à deviner parce que c'est le même nom dans tous les sens.


MODIFIER comme par Namnodorel conseils

Envisager cette méthode surchargée d' PrintStream classe.

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)

Il suffit de penser à la lisibilité si nous avons dû écrire:

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)

22voto

dasblinkenlight Points 264350

La surcharge est utile lorsque vous effectuez des méthodes qui font la même chose avec des valeurs de type différent.

Math classe fournit un parfait exemple - il a les groupes de la fonction de surcharge par type - quatre abs, quatre min, quatre max, et ainsi de suite:

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

Une alternative sans surcharge serait vous obliger à "coder" le type dans le nom de votre méthode, par exemple, Math.intMax(a, b) ce qui serait préjudiciable à la lisibilité d'un code d'utilisateur.

2voto

davidh Points 107

Pour être simple et concis: La surcharge est juste une possibilité prévue par Java (mais plus moderne et flexible d'utilisation des langues c') (et d'autres langages tels que C++ ou C#) pour permettre aux développeurs de créer pour une même méthode nom de la fonction/, plusieurs de il.

Pourquoi ?
Parce que la méthode de nommage est important et la méthode de nommage doit exprimer le comportement d'elle. Ainsi, si deux méthodes ont le même comportement (la Conversion d'une Chaîne de caractères par exemple) mais que l'on utilise une longue entrée et que l'autre utilise un int en entrée, pourquoi avoir un autre nom de la méthode ?

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


L'intention et le but sont les mêmes, juste à l'entrée de changement de paramètres.

Lorsque la surcharge est significatif, vous devez l'utiliser au lieu de créer une variante maladroit noms.

1voto

Jeeter Points 3140

La surcharge de méthode est utile dans le scénario suivant:

Considérez que vous avez une classe qui conserve la trace d'une liste de noms. Vous avez le style de code ci-dessus, où chaque méthode a ses propres opérations sur cette liste de noms.

Soudain, la représentation interne de la liste des changements (peut-être à partir d'un array d'un ArrayList, il n'a pas vraiment d'importance). Voulez-vous être le seul responsable pour la refactorisation de tous. unique. méthode?

La surcharge de méthode est utile parce que vous pouvez acheminer toutes les opérations à travers une seule méthode générique. Cela signifie que chaque fois qu'une représentation interne des modifications, vous n'avez qu'à changer que la méthode générique, et tous vos autres méthodes spécialisées fonctionnent toujours le même.


Aussi, pensez à votre exemple fourni. Qu'advient-il si vous voulez changer la façon dont le programme imprime le message? Vous aurez à modifier les deux méthodes pour imprimer le même type de message, un cauchemar. Bien sûr, il semble petit maintenant, mais pensez quand votre projet se développe, et vous commencez à avoir beaucoup plus de méthodes s'appuyant sur ce (fixés de façon efficace) format de message.

1voto

upma Points 517

Je suis un objet et j'ai une capacité, la capacité est fixe, mais peut accepter des paramètres différents.

Si la capacité peut accepter de 1000 types de paramètres, voulez-vous casser la tête à réfléchir à 1000 capacité de noms?

Prendre d'autres post comme une bonne pratique de la surcharge et de prendre ce qui JNIEnv faire comme une mauvaise pratique de la cause C ne supporte pas la surcharge.

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 à la JNI pour de plus amples struct définition

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X