Vererbung: Methoden die eigene Klasse zurückgeben

[GouShou]

Da meine erste Frage hier so super schnell beantwortet werden konnte hoffe ich, dass die hier genauso einfach ist. 🙂 (Wobei ich befürchte, dass mein Vorhaben gar nicht möglich ist.)

Ich habe eine Klasse B, welche von der Klasse A abgeleitet ist. A hat Methoden, die Objekte vom Typ A zurückgeben.
Solche Methoden rufe ich jetzt in B auf. Allerdings geben diese Methoden jetzt nicht Objekte von Typ A, sondern vom Typ B zurück (der ja A ist). Kann das nervige casten von A nach B jetzt irgendwie umgangen werden?

Praktisch so, dass jedes Vorkommen von A in B als B interpretiert wird?

Kurzes Code Beispiel:

class A
{
      private A item;
   
      public A give_item()
      {
          return item;
      }

      public void set_item(A item)
      {
          this.item = item;
      }
}

class B extends A
{
     public void DoSomething()
     {   
          set_item(new B());
          ((B) give_item()).DoSomethingElse();  //<- Kann ich mir das irgendwie sparen??
     }    

     public void DoSomethingElse();
     {
         //...   
     }
}

Edit:

Die Sache ist nämlich, dass mich das öfters davon abhällt Vererbung zu nutzen. Wenn ich zum Beispiel einen binären, rekursiven Suchbaum programmiere, würde ich den gerne von einer Klasse 'Binärbaum' ableiten. Da der linke und rechte Unterbaum aber hier auch wieder Binärbume sind, müsste ich beim Programmieren des Suchbaumes ständig casten. Da ist es einfacher, wenn ich die Methoden des Binärbaumes anpasse und direkt in Suchbaum schreibe...

 

[Roar]

so vielleicht: http://www.java-forum.org/de/viewtopic.php?t=40849 !?

 

[Wildcard]

Du könntes Generics verwenden oder passende Interfaces verwenden.
Versuch mal den echten Anwendungsfall zu beschreiben.

 

[GouShou]

Hehe, ja hatte ich mir auch überlegt. Allerdings würde das im meinem (editierten) Beispiel nicht funktionieren, da die Typisierung eigentlich schon festlegt, welche Objekte der Binärbaum enthält. Allerdings könnte ich das über Vererbung lösen und die Geschichte dann über Typisierung... Möglich wäre es - gibt es keinen anderen Weg?
Oder kann ich quasi 2mal typisieren?

IRgendwie sowas: class Test<T1,T2>? Aber das wird es nicht geben und wenn wäre es sehr unschön...

 

[Wildcard]

Ich glaube du brauchst Interfaces. In welchen Fällen musst du casten?

 

[SlaterB]

gehts hier nicht einfach um den Fall einer ArrayList?

ArrayList<MyClass> m = ..;
MyClass c = m.get(i);

ist folgende Vererbung erlaubt? ;) (ich kannst grad nicht ausprobieren)


public class MyClass extends ArrayList<MyClass> {


    MyClass c = get(i);

}

 

[GouShou]

SlaterB, ich kann dir gerade überhaupt nicht folgen. Wäre schön, wenn du das erläutern könntest.

Also ich habe zum Beispiel diesen Binärbaum programmiert: (Hab nur die Methodenrümpfe stehen gelassen, da das sonst so lang wäre.)

public class BinTree<T> 
{
    private T rootItem = null;
    private BinTree leftTree = null;
    private BinTree rightTree = null;
    
    public BinTree() {}
    
    public BinTree (T pObject){}
    
    public BinTree (T pObject, BinTree pLeftTree, BinTree pRightTree){}
    
    public boolean isEmpty(){}
    
    public void clear(){}
    
    public void setRootItem (T pObject){}
  
    public T getRootItem(){}
    
    public void addTreeLeft (BinTree pTree){}
    
    public void addTreeRight (BinTree pTree){}

    public BinTree getLeftTree(){}
    
    public BinTree getRightTree(){}
}

Wie ihr seht, geben getLeftTree und getRightTree beide Objekte vom Typ BinTree zurück.

Jetzt will ich die Klasse "SearchTree" programmieren. Habe mal eine Beispielmethode geschrieben:

public class SearchTree extends BinTree
{
    //So sieht sie aus, wenn ich die Klasse von BinTree ableite:
    public void getSortedList(List list) 
    {
        if (((SearchTree)getLeftTree()) != null) ((SearchTree)getLeftTree()).getSortedList(list);
        if (getRootItem()  != null) list.add(getRootItem());
        if (((SearchTree)getRightTree()) != null) ((SearchTree)getRightTree()).getSortedList(list);                
    }
}

public class SearchTree
{
   //So würde sie aussehen, wenn ich nicht ableitete und die Methoden neu schriebe:
      public void getSortedList(List list) 
      {
        if (getLeftTree() != null) getLeftTree().getSortedList(list);
        if (getRootItem() != null) list.add(getRootItem());
        if (getRightTree() != null) getRightTree().getSortedList(list);                
     }  
}

Natürlich ist der Unterschied hier relativ gering, aber bei anderen Methoden könnte das schon entscheiden, ob Vererbung sinnvoll ist oder sie das ganze nur unübersichtlich macht, anstatt wirklich Vorteile zu bringen.

 

[SlaterB]

jo und ich meinte dann

public class BinTree<T, MyTree extends BinTree>
{

    private MyTree rightTree = null; 

    public void addTreeRight (MyTree pTree){}
 
    public MyTree getRightTree(){} 
}

public class SearchTree extends BinTree<SearchTree>

sofern möglich,

oder auch

public class SearchTree<T> extends BinTree<T, SearchTree>

was aber noch kranker aussieht 😉

 

[GouShou]

Hey, das funktioniert! Vielen Dank!
Java überrascht mich immer wieder. 🙂