La surcharge de fonction Java avec une Liste<> paramètre

J'ai 2 classes

public class Customer{
  ...
  public String getCustomerNumber();
  ...
}

public class Applicant{
   ....
   private Customer c;
   public Customer getCustomer(){ return c; }
   ...
}

Lorsqu'ils sont présentés avec une liste de clients ou candidats je veux une fonction qui parcourt la liste et fait quelque chose avec le CustomerNumber.

J'ai essayé de surcharger la fonction

public void processCustomerNumbers(List<Customer> custList)
...

public void processCustomerNumbers(List<Applicant> appList)
...

mais ceux-ci sont considérés comme la duplication des méthodes... est-il une bonne façon de le faire plutôt que d'avoir 2 nommé différemment fonctions?

OriginalL'auteur MadMurf | 2010-02-11

  1. 17

    Si vous faites deux classes implémentent une interface commune,

    interface CustomerNumber {
    String getCustomerNumber();
}

public class Customer implements CustomerNumber {
  ...
  public String getCustomerNumber();
  ...
}

public class Applicant implements CustomerNumber {
   ....
   private Customer c;
   public Customer getCustomer() { return c; }
   public String getCustomerNumber() { return getCustomer().getCustomerNumber(); }
   ...
}

    alors vous pourriez être en mesure de faire ce que vous voulez, avec une seule méthode:

    public void processCustomerNumbers(List<? extends CustomerNumber> appList) {
    for (Customer c: appList) {
        processCustomerNumber(c.getCustomerNumber());
    }
}
    Bonne suggestion.

    OriginalL'auteur finnw

  2. 13

    La chose au sujet des génériques en Java, c'est que les types génériques sont effacés au moment de l'exécution, de sorte que ces deux méthodes de compilation de la même signature. Vous aurez besoin d'avoir séparé les noms de méthode, ou de vérifier le type des éléments de la liste au moment de l'exécution.

    Java n'a pas toujours eu génériques; quand ils ont été ajoutés, le bytecode n'a pas été modifié.
    Oui, c'est la raison pour utiliser le type de l'effacement - pour éviter de casser la compatibilité ascendante avec les pré-génériques de code.
    Le type sont effacés au moment de l'exécution. Surcharge de la méthode de sélection est effectué au moment de la compilation. Donc, il y a assez d'informations pour que le compilateur de décider, même avec l'effacement. Cependant, il y a représentation binaire et les problèmes de compatibilité si ce changement de langue qui allait arriver.

    OriginalL'auteur danben

  3. 6

    Génériques avoir ce qui est connu comme type d'effacement - List<Customer> et List<Applicant> sont du même type, le compilateur seulement des lieux au moment de la compilation des restrictions sur ce que vous pouvez faire avec eux.

    Vous pouvez vérifier le type de l'objet premier de la liste et appeler un (autrement nommé) méthode interne sur cette base.

    Ouais, c'était quelque chose que j'ai commencé à regarder, la vérification de la classe et de la modification de comportement. Vint DONC en espérant y a une solution plus élégante, si rien ne vient, je vais continuer dans cette voie.
    Comme d'autres question, remplacer la sélection se fait au moment de la compilation si l'effacement n'est pas à la règle.
    À mon avis, ce genre de code qui pourrait être classé comme "code spaghetti". Je préfère stackoverflow.com/a/2241584/4149078 parce que vous forcer à mettre en œuvre le code orienté objet.

    OriginalL'auteur Anon.

  4. 5

    Une façon de contourner ce problème serait de définir des types de liste comme ceci:

    class CustomerList extends ArrayList<Customer> {
    ...
}

class ApplicantList extends ArrayList<Applicant> {
    ...
}

    Puis la suite de la surcharge serait légal:

    public void processCustomerNumbers(CustomerList custList)

public void processCustomerNumbers(ApplicantList appList)

    Cependant, je ne pense pas que ce serait une bonne idée. Pour commencer, il câblez particulier la mise en œuvre des classes dans votre application Api.

    Une meilleure approche est de définir une interface commune pour le Client et le Candidat qui vous permet de les traiter avec un processCustomerNumbers méthode. (Comme il est décrit plus amplement dans d'autres réponses.)

    OriginalL'auteur Stephen C

  5. 0

    Utilisation de la matrice de la place.

    public void processCustomerNumbers(Customer[] custList)
...

public void processCustomerNumbers(Applicant[] appList)
...

    Lorsque vous essayez d'appeler ces méthodes avec une liste, de convertir la liste de tableau:

    List<Customer> customers;
List<Applicant> applicants;
...
processCustomerNumbers(customers.toArray(new Customer[]{});
processCustomerNumbers(applicants.toArray(new Applicant[]{});

    OriginalL'auteur Jacob

  6. -1

    Avant de venir dans les noms de méthode , la hiérarchie de classe est un peu déroutant...

    public class Customer{          
  ...          
  public String getCustomerNumber();          
  ...          
}          

public class Applicant{          
   ....          
   private Customer c;          
   public Customer getCustomer(){ return c; }          
   ...          
}

    Pourquoi devrais-candidat et Client
    objets différents ? Pouvez-vous dire à la
    la relation entre ces objets ?

    OriginalL'auteur Sreejesh