Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
helft mir bitte auf die Sprünge. Jede Instanz einer Klasse hält ihrerseits eine Referenz auf eine Liste. Hab also bei N Instanzen meiner Klasse insgesamt N Referenzen auf Listen (in jeder Instanz eine Referenz).
Ist es möglich, mit einer dieser Referenzen auf die Instanz meiner Klasse zu schließen?
public class MyClass {
private List<SomeClass> some = new ArrayList<>();
public void addSome (SomeClass sc) {
some.add(sc);
}
/* other stuff */
public List<SomeClass> getSome() {
return some;
}
}
Code:
public static void main(String[] args) {
MyClass myClass = new MyClass();
List<SomeClass> listSome = myClass.getSome();
?? hat listSome noch einen Bezug auf seine Instanz von MyClass ??
}
Der getter liefert eine Referenz auf die Liste, die von einer Instanz der Klasse MyClass gehalten wird. Im Beispiel hat listSome diese Referenz. Die Frage ist, ob listSome noch einen Bezug zu der Instanz hat, die diese Liste hält?!
Aber mittlerweile bin ich der Überzeugung, daß das eine blöde bzw. unsinnige Frage ist. Ich werde wohl die Liste einer Instanz durch einen wrapper halten müssen, der auch die Referenz zur Instanz der Klasse MyClass speichert.
Ich bekomme ohne jeden Kontext die Referenz auf eine Liste, die ihrerseits in einer der bestehenden Instanzen der Klasse MyClass vorkommt. Die Frage ist, ob ich alleine aus dieser Referenz auf diese Liste einen Bezug auf die Instanz der Klasse MyClass herstellen kann, die diese Liste hält.
Ich sehe auch keine Sinnhaftigkeit warum man das machen will aber die Lösung mit der Map ist die eleganteste, wollte ich auch vorschlagen.
Aber trotzdem die Frage: wozu willst du das machen? Wenn du dir die Liste aus der Instanz holst weißt du doch natürlich (da du die Referenz ja hattest um die Liste zu holen) zu welcher Referenz die gehört. Was genau willst du damit implementieren?
EDIT: Ok nach deinem obigen Posting ist diese Lösung daher nicht geeignet. Erläutere einmal dein Design, dann kann man sich was vorstellen. Wenn du irgendwoher deine Liste herbekommst ist es vermutlich am besten global eine Map mit der Liste als key und der korrespondierenden Instanz als value zu verwalten. Mir fällt allerdings keine sinnvolle Anwendung ein wo du dies benötigen würdest, ich tippe eher auf einen Fehler im Design.
Eine andere Möglichkeit wäre noch in der MyClass Klasse eine Methode zu implementieren, ob die Liste enthalten ist und dann durch alle Objekte zu iterieren und zu prüfen ob dies die richtige Instanz ist. Hat halt ein schlechteres Laufzeitverhalten, dafür eine geringere Speicherkomplexität.
Ich merke gerade, daß ich Schwierigkeiten habe, zu Beschreiben, wozu ich das so wie geschildert brauche. Wahrscheinlich habe ich einen Knoten im Hirn und sollte mal eine Pause machen. Wahrscheinlich ist meine derzeitige 'Designvorstellung' nicht sehr klug...
Stellt Euch bitte vor, daß die gezeigte Klasse MyClass nicht nur eine Liste vom Typ SomeClass hält, sondern mehrere Listen mit jeweils eigenen Typen. Diese Listen haben jeweils unterschiedlich viele Einträge.
Das Ganze soll jetzt in einem Baum dargestellt werden. Jede Instanz der Klasse MyClass entspricht einem Eintrag in dem Baum (alles Kinder von der Wurzel). Jedes dieser Kinder hat seinerseits Kinder. Diese Kinder sind die unterschiedlichen Listen, die eine Instanz von MyClass hält. Diese haben jeweils so viele Kinder, wie die entsprechende Liste Einträge hat.
Mein eigentlich erstes Problem ist, daß die Knoten des Baums jeder einen anderen Typ hat. Wie ich das gelöst bekomme, weiß ich auch noch nicht.
In meiner derzeitigen Vorstellung bekomme ich eine Referenz auf eine der Listen, wenn ich eine der Listen im Baum anklicke. Von da an brauche ich aber noch die Instanz, die diese Liste hält.
Vielleicht denke ich auch einfach zu kompliziert und habs einfach noch nicht vollständig, gedanklich durchdrungen
Wenn man anhand der Liste das Objekt finden will, dass die Referenz auf die Liste hält, ist es aber sinnvoller, die Map anders herum zu organisieren, so wie @flopalko es in Post #8 vorgeschlagen hat. Dann kann man sich das Iterieren sparen.
Du könntest für die Knoten vielleicht eine abstrakte Klasse oder ein Interface mit den Methoden getParent() und getChildren() erstellen. Die Klassen für die konkreten Knotentypen könnten dann die abstrakte Klasse erweitern bzw. das Interface implementieren.
Wenn das Design so ist, warum hast du nicht überhaupt eine Klasse TreeNode für die jeweiligen Knoten, die parent und children verwaltet und eine Referenz auf ein Object, dein Nutzobjekt, beinhaltet. So ist jeder Knoten ein TreeNode mit allen Operationen darauf und du hast deinen Nutzinhalt in einem Object das jeweils von irgendeiner Klasse sein kann.
Du könntest für die Knoten vielleicht eine abstrakte Klasse oder ein Interface mit den Methoden getParent() und getChildren() erstellen. Die Klassen für die konkreten Knotentypen könnten dann die abstrakte Klasse erweitern bzw. das Interface implementieren.
Ich danke Euch allen für Eure Gedanken! Map, abstrakte Klasse, Interface. Das sind alles gute Ideen. Danke! Das meinte ich oben mit wrapper, auch wenn's die falsche Formulierung war.
Die Map kann ich mir noch am besten durchdebken. Interfaces klingen auch gut, doch durchklicke ich das weniger.
Falls man den Typen wirklich benötigt, kann man den Knoten ja so programmieren, dass er ihn liefert. Ich bin aber noch nicht überzeugt, dass man ihn überhaupt benötigt. Das jeweilige individuelle Verhalten der unterschiedlichen Knotentypen wäre ja normalerweise bereits durch entsprechende Implementierung der konkreten Knotenklassen abgedeckt.
So wie es aussieht, möchtest du in einem JTree Daten oder Objekte anzeigen, die "eigentlich" keine TreeNodes sind.
Wie sind denn die Eltern-Kindkno9ten-Beziehungen? Wenn du eine MyClass mit einer List<SomeClass> hast, ist dann die List der "Parent node" der SomeClass Instanzen oder die "umgebende" Instanz von MyClass?
ja, Du hast recht. Ein TreeView (JavaFX) soll meine Daten abbilden. Ich zeige Dir mal meine Daten:
Code:
public class Tauchgang {
private static int instanceCount = 0;
private int myCount;
private String kurzBeschreibung;
private List<ProfilPlan> profilPlan = new ArrayList<>();
private List<Umgebung> umgebung = new ArrayList<>();
private List<FlaschenGase> flaschenGase = new ArrayList<>();
private List<GasManagement> gasManagement = new ArrayList<>();
private List<Profil> profil = new ArrayList<>();
/* ... */
}
Der angesprochene Baum soll nun in der ersten Ebene für jede Instanz dieser Klasse einen Eintrag zeigen. Jedem Eintrag werden fünf Kinder angehängt. Diese repräsentieren die fünf List<...> ArrayList's. Darunter sind dann für jedes Element der jeweiligen Liste weitere Kinder angehängt. Für eine Interaktion mit der Maus muß es möglich sein, für "das Kind einer Liste einer Instanz" einen Bezug zur Datenbasis zu haben.
Soweit ich es weiß, können in einer TreeView<EineBestimmteKlasse> nur TreeItem's mit genau dergleichen Klasse 'EineBestimmteKlasse' angehängt werden. Das können meine Daten ja schon nicht so machen, denn es gibt das Objekt der Instanz meiner Klasse 'Tauchgang' und fünf Listen. Darum habe ich diese Referenzen in einer eigenen Klasse gekapselt und hänge Objekte dieser Klasse in den Baum. Das sieht momentan in etwa so aus:
Code:
public class TGTreeNode {
private String nodeName;
private Tauchgang tauchgang;
private List<?> list;
private Integer index;
@Override
public String toString() {
return nodeName;
}
/* ... */
}
Soll ein neuer Knoten in den Baum gehängt werden, so packe ich meine nötigen Referenzen in ein Objekt dieser Klasse und hänge das in den Baum. Ein Beispiel für einen neuen Tauchgang und einer Liste 'Profil' mit seinen Kindern sieht dann so aus (es werden immer alle fünf Listen angehängt, habe für das Beispiel hier nur die Liste 'Profil' dargestellt):
Code:
private final TreeItem<TGTreeNode> rootNode = new TreeItem<>(new TGTreeNode("Keine Tauchgänge!!!"));
/* ... */
TGTreeNode treeItem = new TGTreeNode(tauchgang);
TreeItem<TGTreeNode> newTG = new TreeItem<>(treeItem);
rootNode.getChildren().add(newTG);
rootNode.getValue().setNodeName("Tauchgang...");
rootNode.setExpanded(true);
TreeItem<TGTreeNode> newList;
treeItem = new TGTreeNode(tauchgang, tauchgang.getListProfil(), "Profile");
newList = new TreeItem<>(treeItem);
newTG.setExpanded(true);
newTG.getChildren().add(newList);
// für alle Kinder in List<Profil> Nodes anlegen
//
i = 0;
for (Profil p : tauchgang.getListProfil()) {
treeItem = new TGTreeNode(tauchgang, tauchgang.getListProfil(), i++, p.toString());
newChild = new TreeItem<>(treeItem);
newList.getChildren().add(newChild);
}
/* ... */
Es soll dann so werden, daß ich mit einem Klick auf ein Element des Baumes die Referenz auf eine Instanz des 'TGTreeNode' erhalte und darin die Informationen finde, wo in meinen Daten die "geklickte Position" ist. Das ist also der 'Tauchgang', eine Liste List<?> und evtl. ein Index.
Die Liste muß ich mir dann noch durch Vergleich der fünf Referenzen in dem jeweiligen Tauchgang heraussuchen, denn ich weiß ja jetzt nicht mehr, ob es die Liste für 'ProfilPlan', 'Umgebung', 'FlaschenGase', 'GasMangement' oder 'Profil' ist. Das ist zwar etwas schwerfällig gelöst, aber ich kenne momentan keine geschicktere Lösung
Danke!!!!
