Vorbei Superklasse als parameter der Methode erwartet, die sub-Klasse

Habe ich ein Objekt-Baum, der in etwa so aussieht wie

           Ball
          /    \
  LegalBall    IllegalBall

Und ich habe 2 Methoden:

class o {
AddBall(LegalBall l)
AddBall(IllegalBall i)
}

in einer anderen Klasse möchte ich Folgendes tun:

o.AddBall(myBall);

wo myBall ist vom Typ Ball.
Und es zum Aufruf der richtigen Methode abhängig vom Subtyp.
Anscheinend kann ich nicht tun... die Argumente sind nicht zutreffend.

Weiß jemand, wie ich erreichen kann, was ich will? Oder, wenn es eine gute Arbeit rund um

Dank

EDIT : die Anwendung, die ich versuche zu bauen, ist ein Cricket scorecard-Typ-Sache. So kann je nach Art der Kugel, die rollte verschiedenen anderen Elementen ändern sollte.

meine ursprüngliche Absicht war, zu können, geben Sie den ball geben und läuft erzielte aus irgendeiner form von UI und erstellen Sie dann eine geeignete Art ball von einem BallFactory und dann wenn ich zum Beispiel sende eine keine Kugel zum team-score wird der Wert auf den team-Punktestand, sondern auch hinzufügen, den Wert für den keine Kugeln Zähler. Aber wenn ich den gleichen ball, um die Batsmens Analyse befassen sich mit sollte es nur score-Wert 1 batsmens total..

Ich hoffe das ist nicht allzu schlimm, eine Erklärung meiner ursprünglichen Absicht.

InformationsquelleAutor Rocco | 2008-12-26

Könnten Sie die Besucher-Muster.

class Basket {
    void AddBall(LegalBall l) {
        System.out.println("LegalBall added to basket");
    }

    void AddBall(IllegalBall i) {
        System.out.println("IllegalBall added to basket");
    }
}

interface Ball {
    void AddBall(Basket b);
}

class LegalBall implements Ball {
    void AddBall(Basket b) {
        b.AddBall(this);
    }
}

class IllegalBall implements Ball {
    void AddBall(Basket b) {
        b.AddBall(this);
    }
}

oder, um es allgemeiner:

interface BallVisitor {
    void visit(LegalBall l);
    void visit(IllegalBall i);
}

interface Ball {
    void accept(BallVisitor v);
}

class LegalBall implements Ball {
    void accept(BallVisitor v) {
        v.visit(this);
    }
}

class IllegalBall implements Ball {
    void accept(BallVisitor v) {
        v.visit(this);
    }
}

class Basket implements BallVisitor {
    void visit(LegalBall l) {
        System.out.println("LegalBall added to basket");
    }

    void visit(IllegalBall i) {
        System.out.println("IllegalBall added to basket");
    }
}

Ich muss AddBall mehr als nur Korb, obwohl eine Reihe von anderen Objekten. Brauche ich, um eine Methode zu implementieren, die für jede Art möchte ich hinzufügen-ball auf?
Aktualisiert mit Allgemeinen Fall.
Es wäre ziemlich seltsam hinzufügen "besuchen" und "akzeptieren" - Methoden zu einem ansonsten normalen interface.

InformationsquelleAutor dalle

3

Sollten Sie versuchen, zu implementieren, nur eine Methode:
```
class o {
AddBall(Ball b)
}
```
und versuchen Sie verlassen sich auf einen Polymorphismus für das unterschiedliche Verhalten in Bezug auf verschiedene Klassen. Natürlich sind die details hängen von der Implementierung der Ball Hierarchie.

InformationsquelleAutor Federico A. Ramponi
0

Du vielleicht (oder auch nicht) wollen, (Teil -) das Besucher-Muster.

Fügen Sie eine Methode zu Ball:
```
public abstract void addTo(o o);
```
Implementat in LegalBall und IllegalBall als
```
public void addTo(o o) {
    o.add(this);
}
```
InformationsquelleAutor Tom Hawtin - tackline
0

Nun, es ist das Besucher-Muster, wie oben erwähnt. Wenn Sie nicht können oder nicht wollen, zu ändern, Ball, LegalBall, oder IllegalBall, dann könnten Sie versuchen, mit einer einzigen Methode branch basierend auf die Art von ball. Beachten Sie, dass wenn Sie später hinzufügen eines QuasiLegalBall, diesen code zu brechen. Der Allgemeine Fall, den Sie erwähnen, ist schwierig, weil die Existenz von LegalBall und IllegalBall nicht verhindern, dass Kugeln, die nicht passen in die zwei Typen, die Sie beschrieben (aus der Sprache der Perspektive zumindest).
```
class o {
    public void AddBall(Ball b) 
    { 
        if (b instanceof LegalBall) {AddLegalBall(b); }
        else if (b instanceof IllegalBall) {AddIllegalBall(b); }
        else { /*error, new type of ball created*/ }
    }
    private void AddLegalBall(LegalBall b) { }
    private void AddIllegalBall(IllegalBall b) { }
    }
 }
```
InformationsquelleAutor Yuliy
0

Verwenden Sie das Besucher-Muster. Tun es, ohne umständlich ist, und der Gegenstand war von dieser Frage: Umgehen der Java-statische Methode Versand ohne Double Dispatch/Besucher-Muster .

Jedoch, können Sie bitte Ihre ursprünglichen problem? Ich meine, warum müssen Sie haben, die zwei überladungen für die Add-Methode? Vielleicht kann man es lösen, in eine völlig andere Weise, die nicht angewiesen ist auf die dynamische dispatch-wie die Besucher-Muster?

InformationsquelleAutor Johannes Schaub - litb
-1

Wie Sie es erwarten zu wissen, was man nennen? Was unterscheidet die beiden Methoden auseinander, die Sie erwarten würden, es zu rufen und nicht die anderen?

InformationsquelleAutor Joel Coehoorn

-1

Stimme ich mit den Besucher-Auslastung.

Zusätzlich, wenn Sie keinen Zugriff auf den Ball Hierarchie ( source-code-Zugang ) oder einfach keine Lust, irgendetwas zu verändern; Sie könnte, ändern Sie Ihre client-Klasse und entscheiden von dort.

Die schlechte Sache ist natürlich, dass Sie mit vielen if/elseif-Anweisungen.

Müssen Sie die generische Methode ( add( Ball ) ) und von dort aus rufen die anderen. Dies ist schnell, einfach und schmutzig.

🙂

public class Test {
    public static void main( String [] args ) { 
        Ball ball = new IllegalBall();
        Test test = new Test();
        test.add( ball );
        test.add( new IllegalBall() );
        test.add( new LegalBall() );
    }
    private void add( Ball ball ){
        System.out.println("Generic method: I'll have someone handling this : "  + ball );
        if( ball instanceof IllegalBall ) {
            add( ( IllegalBall ) ball );
        } else if( ball instanceof LegalBall ) {
            add( ( LegalBall ) ball );
        }
    }
    private void add( IllegalBall ball ){
        System.out.println("illega-ball: I won't do anything about it! " + ball );
    }
    private void add( LegalBall ball ) { 
        System.out.println("legal-ball: Hey this is legal I'll do my best!! " + ball );
    }
}

class Ball {}
class IllegalBall extends Ball {}
class LegalBall extends Ball {}

BTW, wenn Sie nicht die Referenz direkt durch den compiler schicken Sie es an die korrekte Methode, wie in den letzten 2 Anrufe.

Wie Sie sehen können, Sie müssen nur fügen Sie den folgenden code:

private void add( Ball ball ){
    System.out.println("Generic method: I'll have someone handling this : "  + ball );
    if( ball instanceof IllegalBall ) {
        add( ( IllegalBall ) ball );
    } else if( ball instanceof LegalBall ) {
        add( ( LegalBall ) ball );
    }
}

Schrecklich. Dies ist ein lehrbuch Beispiel dafür, wie "instanceof" und die Methode überladen sind code smells für ein schlechtes design. Sie missbrauchen das Typ-system.

InformationsquelleAutor OscarRyz

-1

Die Besucher Muster und ähnliche Lösungen Rückrufe verwenden, in diesem Fall scheinen nur zu versuchen, es zu verbiegen, Ihren code in einer Weise zu, dass der compiler akzeptieren, Ihre fehlerhafte Klassenhierarchie.

Ich würde immer Art Ball, und machen legal/illegal eine Eigenschaft dieses Typs. Sie würde nur o haben.add(Ball), in dem Sie prüfen, ob legal/illegal, basiert auf bestimmten Eigenschaften oder durch eine Methode, isLegal() zum Beispiel.

Wenn die obigen Ansatz scheint nicht sinnvoll, dann ist es nicht sinnvoll, eine einzige Methode zum hinzufügen von zwei (sehr) unterschiedliche Typen, und die subtypisierung Beziehung, die Sie vorgeschlagen, wäre nicht der Weg zu gehen.

InformationsquelleAutor eljenso

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.