Überladen in Java und multiple dispatch

Was Sie wollen, ist ein Doppel-oder allgemeiner multiple dispatch, etwas, das tatsächlich in die Praxis umgesetzt, die in anderen Sprachen (common lisp in den Sinn kommt)

Vermutlich der Hauptgrund, warum java nicht haben, denn es kommt zu Leistungseinbußen, da überlast Auflösung getan werden muss, zur Laufzeit und nicht kompilieren. Der übliche Weg, um dieses ist die Besucher-Muster - ziemlich hässlich, aber das ist, wie es ist.

Alte Frage, aber keine Antwort bietet eine konkrete Lösung in Java zu lösen das Problem auf saubere Art und Weise.

In der Tat, nicht leicht, aber sehr interessante Frage. Hier ist mein Beitrag.

Ok, die Methode, die aufgerufen werden, ist beschlossen, zur compile-Zeit. Gibt es eine
Problemumgehung vermeiden Sie die Verwendung der instanceof-operator?

Wie gesagt, in den ausgezeichneten @DaveFar Antwort, Java unterstützt nur single-dispatch-Methode.

In dieser Versand-Modus, der compiler Grenzen der Methode aufrufen, sobald der Zusammenstellung, indem man sich auf die deklarierten Typen der Parameter und nicht Ihre runtime-Typen.

Ich habe eine collection (oder eine Liste oder ein array-Liste), die ich setzen möchte
die beiden String-Werte und double-Werte.

Zu lösen, die Antwort in eine saubere Art und Weise und mit einem doppelten Versand, die wir haben, um Abstraktion, die für die manipulierten Daten.

Warum ?

Hier eine naive Besucher Ansatz zur Verdeutlichung des Problems :

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

}

Nun die Frage : wie kann ich besuchte Klassen kann sich auf die visit() Methode ?

Der zweite Versand der double-dispatch-Umsetzung basiert auf der "this" - Kontext von der Klasse akzeptiert zu werden, besucht werden.

Also müssen wir eine accept() Methode in Integer, String und Object Klassen zum ausführen dieser zweite Versand :

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

Aber unmöglich ! Besuchten Klassen sind integrierte Klassen : String, Integer, Object.

So haben wir keine Möglichkeit, diese Methode hinzuzufügen.

Und sowieso, wir wollen nicht hinzufügen, dass.

So zu implementieren, die double dispatch zu werden, müssen wir in der Lage, ändern Sie die Klassen, die wir wollen, übergeben Sie als parameter in der zweiten Versand.

Also anstatt zu manipulieren Object und List<Object> als deklarierten Typ, wir manipulieren Foo und List<Foo> wo die Foo Klasse ist eine wrapper-hält der Benutzer den Wert.

Hier ist die Foo Schnittstelle :

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

getValue() gibt der Benutzer den Wert.

Es gibt Object als Rückgabetyp, aber Java unterstützt die Kovarianz gibt (seit der version 1.5), so könnten wir definieren einen spezifischen Typ für jede Unterklasse zu vermeiden 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;
    }

}

Hier ist die DisplayVisitor Klasse besuchen Foo Unterklassen :

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

}

Und hier ist ein Beispiel-code zum testen der Implementierung :

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

Ausgabe :

string=String

string=eine andere Zeichenfolge

integer=1

object=100

Verbesserung der Umsetzung

Erfordert die tatsächliche Durchführung der Einführung einer speziellen wrapper-Klasse für jede buit-in der Art, die wir zusammenfassen möchten.
Wie besprochen, haben wir nicht die Wahl das betreiben eines Doppel-Versand.

Aber beachten Sie, dass die wiederholte code in Foo Unterklassen vermieden werden könnten :

private Integer value; //or String or Object

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

Könnten wir in der Tat die Einführung eines abstrakten generischen Klasse, der hält, was der Benutzer Wert und bietet einen accessor zu :

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

}

Nun Foo sublasses sind leichter zu erklären :

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

}

Und die test() Methode geändert werden sollte, zu erklären, ein Platzhalter-Typ (?) für die Foo geben Sie in der List<Foo> Erklärung.

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

}

In der Tat, wenn Sie Sie wirklich benötigen, könnten wir vereinfachen die weitere Foo Unterklassen durch die Einführung von java-code-Generierung.

Deklarieren diese Unterklasse :

public class StringFoo extends Foo<String> {

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

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

}

könnte so einfach wie das deklarieren einer Klasse und hinzufügen einer Anmerkung auf:

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

Wo Foo ist eine benutzerdefinierte Anmerkung zur Verarbeitung an die compile-Zeit.

Alles in Java ist ein Object/Objekt (außer primitiven Datentypen). Sie speichern strings und Ganzzahlen als Objekte, und wenn Sie dann rufen Sie die prove - Methode, Sie werden immer noch als "Objekte" bezeichnet. Sie sollten einen Blick auf die instanceof Schlüsselwort. Überprüfen Sie diesen link

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