Java Passing Typ als Parameter in Funktion erwartet Subtyp

Question

Ich bin neu in Java und ich versuche, einige wirklich einfache Java-Anwendungen zu machen. Bei meinen Versuchen bin ich auf generalisierende Probleme gestoßen. Ich habe eine Liste von Person Objekte. Person kann Vater oder Mutter sein.

Dann habe ich paar Methoden mit dem gleichen Namen essen (...) aber sie unterscheiden sich in den Eingabeparametern. Diese Methoden sind nicht Teil von Person Klasse. Eine dieser Methoden akzeptiert Mutter als Parameter und die andere akzeptiert Vater.

Die Frage ist, wie dynamisch entscheiden, welche Methode auf der Liste der Person aufgerufen werden soll. wenn ich versuche, durch die Liste iterieren und ruft o.eat (Iterator) es mit Compiler-Fehler aufgefordert, weil Iterator vom Typ Person aber meine essen Methoden wollen Mutter oder Vater als Parameter. Compiler tut weiß, dass ich haben Verfahren für jede Art von Person

Bisher habe ich mein Problem mit wenn Erklärung, in der ich den Klassentyp von GetType() Methode sowohl mit Mutter vergleichen gelöst und Vater und wenn es gleich ist, kann ich Person in geeigneten Typ.

-Code sieht wie folgt aus:

if (person.getClass().equals(Father.class)) { 
      theView.eat((Father) person); 
     } 


    if (person.getClass().equals(Mother.class)) { 
      theView.eat((Mother) person); 
     } 

Essen Methode wie folgt aussieht:

public void eat(Mother m){ 
    textArea.append(m.breakfast); 
    textArea.append(m.lunch); 
    textArea.append(m.dinner); 
} 

Mittagessen Abendessen und Frühstück sind nur einige Zeichenfolge, die angibt, was die Person

Person tut, ist die Code ist ein Iterator durch die Liste der Personenobjekte

Ist t hier eine bessere Lösung, die den Prozess automatisieren wird?

Danke im Voraus.

Answer 1

Dann, ich habe einige Methoden mit dem gleichen Namen essen (...), aber sie unterscheiden sich in Eingabeparameter

Was passiert, wenn Ihre Klasse mit unterschiedlichen eat Methoden implementiert ist wie folgt:

public class TheView<T extends Person> { 
    public void eat(T t) { 
     textArea.append(t.getMeals()); 
    } 
} 

Und jetzt können Sie Ihre Iterieren Verfahren wie folgt umgesetzt werden:

public <T> void yourMethod(List<? extends Person> personList) { 
    for (Person p : personList) { 
     theView.eat(p); 
    } 
} 

Ihre Liste kann eine beliebige Anzahl von Father oder Mother Objekte enthalten sie implementieren vorgesehen/verlängern Person Klasse, wie

public abstract class Person { 
    private String breakfast; 
    private String lunch; 
    // ... other fields 

    public abstract void getMeals(); 

    public String getBreakfast() { return breakfast; } 
    // ... other getters 
} 

public class Father extends Person { 
    @Override 
    public void getMeals() { 
     // implement Father-specific code here 
    } 
} 

public class Mother extends Person { 

    @Override 
    public String getMeals() { 
     StrngBuilder sb = new StringBuilder() ; 

     sb.append(getBreakfast()); 
     sb.append(getLunch()); 
     sb.append(getDinner()); 

     return sb.toString(); 
    } 
} 

Answer 2

Verwendung Polymorphismus:

public interface Person{ 
    void eat(); 
} 

public class Mother implements Person{ 

    @Override 
    public void eat() 
    { 
     //the code inside eat(Mother) goes here 
    } 

} 

public class Father implements Person{ 

    @Override 
    public void eat() 
    { 
     //the code inside eat(Father) goes here 
    } 

} 

dann, nur die Methode essen rufen an jedem Objekt Ihrer Person in die Liste:

for(final Person person: personList){ 
    person.eat(); 
} 

Answer 3

Ich glaube, Sie das Besuchermuster benötigen, wegen dem, was du gesagt hast hier

Die Frage ist, wie dynamisch entscheiden, welche Methode auf Liste der Person aufrufen.

https://sourcemaking.com/design_patterns/visitor/java/2

Dies hilft Ihnen entscheiden, welche Route

aus Wikipedia dynamisch zur Laufzeit nehmen: https://en.wikipedia.org/wiki/Double_dispatch

Doppel-Ausgabe eine spezielle Form von mehreren Dispatch ist, und ein Mechanismus, der einen Funktionsaufruf an verschiedene konkrete Funktionen abhängig von den Laufzeittypen zweier an 0 beteiligten Objekte versendetder Anruf.