La surcharge en Java et plusieurs d'expédition

Ce que vous voulez, c'est le double ou plus général la répartition multiple, quelque chose qui est réellement mis en œuvre dans d'autres langues (common lisp vient à l'esprit)

Sans doute la raison principale de java ne l'a pas, c'est parce qu'il arrive à un rendement de pénalité parce que la résolution de surcharge doit être fait au moment de l'exécution et pas le temps de compilation. La manière habituelle, c'est la modèle visiteur - assez laid, mais c'est comment il est.

Vieille question mais pas de réponse apporte une solution concrète en Java pour résoudre le problème de façon propre.

En effet, pas facile, mais très intéressante question. Voici ma contribution.

Ok la méthode à appeler est décidé au moment de la compilation. Est-il
solution de contournement pour éviter d'utiliser l'opérateur instanceof?

Comme dit dans l'excellent @DaveFar réponse, Java ne supporte que la seule méthode dispatch.

Dans cette expédition de mode, le compilateur les limites de la méthode à invoquer dès que la compilation en s'appuyant sur la déclaration de types de paramètres et de ne pas leur exécution types.

J'ai une collection (de liste ou de tableau ou de liste) dans lequel je veux mettre
les deux valeurs de Chaîne et double des valeurs.

Pour résoudre la réponse de manière propre et l'utilisation d'un double envoi, il nous faut faire abstraction de la manipuler des données.

Pourquoi ?

Ici un naïf visiteur approche pour illustrer le problème :

public class DisplayVisitor {

    void visit(Object o) {
        System.out.println("object"));
    }

    void visit(Integer i) {
        System.out.println("integer");
    }

    void visit(String s) {
        System.out.println("string"));
    }

}

Maintenant, la question : comment visité les classes peuvent invoquer la visit() méthode ?

La deuxième expédition de la double envoi de la mise en œuvre s'appuie sur le" contexte de la classe qui accepte d'être visité.

Donc nous avons besoin d'un accept() méthode dans Integer, String et Object classes pour effectuer cette deuxième expédition :

public void accept(DisplayVisitor visitor){
    visitor.visit(this);
}

Mais impossible ! Visité les classes sont intégrés dans les classes : String, Integer, Object.

Donc nous n'avons aucun moyen d'ajouter cette méthode.

Et de toute façon, nous ne voulons pas ajouter que.

Afin de mettre en œuvre la double expédition, nous devons être en mesure de modifier les classes que nous voulons faire passer comme paramètre dans la deuxième expédition.

Ainsi, au lieu de manipuler Object et List<Object> comme type déclaré, nous allons manipuler Foo et List<Foo> où la Foo classe est un wrapper de la tenue de la valeur pour l'utilisateur.

Ici est la Foo interface :

public interface Foo {
    void accept(DisplayVisitor v);
    Object getValue();
}

getValue() renvoie la valeur pour l'utilisateur.

Il spécifie Object comme type de retour, mais Java prend en charge la covariance des rendements (depuis la version 1.5), de sorte que nous pourrions définir de façon plus spécifique de type pour chaque sous-classe d'éviter downcasts.

ObjectFoo

public class ObjectFoo implements Foo {

    private Object value;

    public ObjectFoo(Object value) {
        this.value = value;
    }

    @Override
    public void accept(DisplayVisitor v) {
        v.visit(this);
    }

    @Override
    public Object getValue() {
        return value;
    }

}

StringFoo

public class StringFoo implements Foo {

    private String value;

    public StringFoo(String string) {
        this.value = string;
    }

    @Override
    public void accept(DisplayVisitor v) {
        v.visit(this);
    }

    @Override
    public String getValue() {
        return value;
    }

}

IntegerFoo

public class IntegerFoo implements Foo {

    private Integer value;

    public IntegerFoo(Integer integer) {
        this.value = integer;
    }

    @Override
    public void accept(DisplayVisitor v) {
        v.visit(this);
    }

    @Override
    public Integer getValue() {
        return value;
    }

}

Ici est la DisplayVisitor classe de visiter Foo sous-classes :

public class DisplayVisitor {

    void visit(ObjectFoo f) {
        System.out.println("object=" + f.getValue());
    }

    void visit(IntegerFoo f) {
        System.out.println("integer=" + f.getValue());
    }

    void visit(StringFoo f) {
        System.out.println("string=" + f.getValue());
    }

}

Et voici un exemple de code pour tester la mise en œuvre :

public class OOP {

    void test() {

        List<Foo> foos = Arrays.asList(new StringFoo("a String"),
                                       new StringFoo("another String"),
                                       new IntegerFoo(1),
                                       new ObjectFoo(new AtomicInteger(100)));

        DisplayVisitor visitor = new DisplayVisitor();
        for (Foo foo : foos) {
            foo.accept(visitor);
        }

    }

    public static void main(String[] args) {
        OOP oop = new OOP();
        oop.test();
    }
}

De sortie :

string=une Chaîne

string=une autre Chaîne

integer=1

objet=100

---

L'amélioration de la mise en œuvre

La mise en œuvre effective nécessite l'introduction d'un wrapper de la classe pour chaque buit-dans le type que nous voulons pour l'envelopper.
Tel que discuté, nous n'avons pas le choix à opérer un double envoi.

Mais notez que le code à répétition dans Foo sous-classes pourraient être évités :

private Integer value; //or String or Object

@Override
public Object getValue() {
    return value;
}

On pourrait en effet présenter un résumé de classe générique qui contient la valeur pour l'utilisateur et fournit un accesseur pour :

public abstract class Foo<T> {

    private T value;

    public Foo(T value) {
        this.value = value;
    }

    public abstract void accept(DisplayVisitor v);

    public T getValue() {
        return value;
    }

}

Maintenant Foo sublasses sont plus légers à déclarer :

public class IntegerFoo extends Foo<Integer> {

    public IntegerFoo(Integer integer) {
        super(integer);
    }

    @Override
    public void accept(DisplayVisitor v) {
        v.visit(this);
    }

}

public class StringFoo extends Foo<String> {

    public StringFoo(String string) {
        super(string);
    }

    @Override
    public void accept(DisplayVisitor v) {
        v.visit(this);
    }

}

public class ObjectFoo extends Foo<Object> {

    public ObjectFoo(Object value) {
        super(value);
    }

    @Override
    public void accept(DisplayVisitor v) {
        v.visit(this);
    }

}

Et la test() méthode devrait être modifié pour déclarer un type générique (?) pour la Foo type dans le List<Foo> déclaration.

void test() {

    List<Foo<?>> foos = Arrays.asList(new StringFoo("a String object"),
                                      new StringFoo("anoter String object"),
                                      new IntegerFoo(1),
                                      new ObjectFoo(new AtomicInteger(100)));

    DisplayVisitor visitor = new DisplayVisitor();
    for (Foo<?> foo : foos) {
        foo.accept(visitor);
    }

}

En fait, si vraiment nécessaire, nous pourrions simplifier encore plus Foo sous-classes en introduisant la génération de code java.

De déclarer cette sous-classe :

public class StringFoo extends Foo<String> {

    public StringFoo(String string) {
        super(string);
    }

    @Override
    public void accept(DisplayVisitor v) {
        v.visit(this);
    }

}

pourrait aussi simple que la déclaration d'une classe et l'ajout d'une annotation sur:

@Foo(String.class)
public class StringFoo { }

Où Foo est une coutume annotation traitées au moment de la compilation.

Tout en Java est un Object/objet (sauf les types primitifs). Vous stocker des chaînes et des nombres entiers comme des objets, et puis comme vous l'appelez le prove méthode qu'ils sont encore considérés comme des objets. Vous devriez jeter un oeil à la instanceof mot-clé. Suivez ce lien

void prove(Object o){
   if (o instanceof String)
    System.out.println("String");
   ....
}