Vererbung bei Klassen mit Objekt der Klasse im Konstruktor

[Alice]

Hallo liebe Mitglieder,

ich habe hier mein persönliches Henne-Ei Problem und wär euch für alle hilfreichen Beiträge dankbar
Ich möchte mit der Klasse Node Eltern-Kind-Beziehungen in einer Baumstruktur ausgeben.
Dafür habe ich die Klasse myNode von Node abgeleitet und um die Methode hasParent() erweitert. In der Main lege ich nun meine Nodes mit ihren Abhängigkeiten an und will sie mir ausgeben lassen. Ich kann allerdings nicht auf hasParent() zugreifen. Ich Versteh auch warum ... ich müsste den Parameter beim Anlegen der Note-Objekte mit myNode anstatt mit Node deklarieren. Aber das dann blubbert ja wieder der Konstruktor von myNote

Kann mir jemand sagen was ich im Code ändern muss damit die auskommentierte

//if(node.hasParent())

Methode aufrufbar wird.
Ach ja - noch was: Ich will unbedingt mit der abgeleiteten Klasse arbeiten und die Basisklasse nicht verändern. Muss doch irgendwie gehen oder?

Hier mein Code

import java.util.ArrayList;

public class Node {
    private String name;   
    private ArrayList<Node> parents;
   
    public Node(String name, ArrayList<Node> elements){
        this.name = name;       
        this.parents = elements;
    }       
    public String getName(){
        return name;
    }   
    public ArrayList<Node> getParents(){
        return parents;
    }
}

import java.util.ArrayList;

public class MyNode extends Node{
    public MyNode(String name, ArrayList<Node> elements) {
        super(name, elements);       
    }
    @Override
    public String toString(){
        return String.format("Element.name:[%s]", getName());
    }
    public boolean hasParent(){
        if(getParents() == null) return false;
        else return true;
    }
}

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
                       
        Node a = new MyNode("A", null);
        Node b = new MyNode("B", new ArrayList<Node>(){{add(a);}});
        Node c = new MyNode("C", new ArrayList<Node>(){{add(a);add(b);}});
        Node d = new MyNode("D", new ArrayList<Node>(){{add(a);add(c);}});
       
        ArrayList<Node> allNotes = new ArrayList<Node>();
        //allNotes.add(a);
        allNotes.add(b);
        allNotes.add(c);
        allNotes.add(d);       
       
               
        for(Node node : allNotes){
            System.out.println(node);       
            //if(node.hasParent()) {
                for(Node parent : node.getParents()){
                    System.out.println("  parent of" + node + " is "+parent);
                }   
            //}
        }       
    }
}

Und hier die Ausgabe:

Element.name:[B]
  parent ofElement.name:[B] is Element.name:[A]
Element.name:[C]
  parent ofElement.name:[C] is Element.name:[A]
  parent ofElement.name:[C] is Element.name:[B]
Element.name:[D]
  parent ofElement.name:[D] is Element.name:[A]
  parent ofElement.name:[D] is Element.name:[C]

Vielen Dank euch schonmal

 

[mrBrown]

Das geht nur, wenn die castest oder deine Liste als List<MyNode> deklarierst.

Du kannst dir aber das if sparen, wenn du parents immer initialisierst und null vermeidest, die übergebenen parents fügst du dann einfach hinzu. Wenn keine übergeben werden ist die Liste einfach leer

 

[Alice]

So?

MyNode b = new MyNode("B", new ArrayList<MyNode>(){{add(a);}});

Das hab ich auch versucht aber da bekam ich ja auch immer eine Meckermeldung dass der Konstruktor von MyNode beim Parameter nur Node und nicht MyNode verwenden darf. Casten lässt lasst er sich auch nicht.

Ja - Ich sehe schon dass man die die hasParent() auch umgehen kann. Aber ich will ja das Grundproblem verstehen. In den Lehrbüchern finde ich kein Beispiel einer Ableitung von Klassen die sich selbst verwenden.

Kann man hier evt. gar nicht mit abgeleiteten Klassen arbeiten? Oder gibt es bei casten etwas zu beachten?

Danke Dir

 

[Alice]

Ah juhu @mrBrown du bist ein Genie ... gelöst ... aber noch nicht so recht kapiert warum casten nur dort möglich ist ...
So geht es ...

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
                       
        Node a = new MyNode("A", null);
        Node b = new MyNode("B", new ArrayList<Node>(){{add(a);}});
        Node c = new MyNode("C", new ArrayList<Node>(){{add(a);add(b);}});
        Node d = new MyNode("D", new ArrayList<Node>(){{add(a);add(c);}});
       
        ArrayList<MyNode> allNotes = new ArrayList<MyNode>();
        allNotes.add((MyNode)a);
        allNotes.add((MyNode)b);
        allNotes.add((MyNode)c);
        allNotes.add((MyNode)d);       
       
               
        for(MyNode node : allNotes){
            System.out.println(node);       
            if(node.hasParent()) {
                for(Node parent : node.getParents()){
                    System.out.println("  parent of" + node + " is "+parent);
                }   
            }
        }       
    }
}

 

[mrBrown]

Casten solltest du lieber in der Schleife, da ein if mit instanceof und dann der Cast