Moin,
ich bastle gerade an einer Demo und habe Schwierigkeiten mit Generics und Vererbung.
Ich habe ein baumartiges Datenmodel, das später in einem JTree abgebildet werden soll.
Ein stark vereinfachtes KSBK soll das verdeutlichen:
Ich habe einen Schrank, der Schubladen hat. In den Schubladen sind Boxen mit Fotos.
Ziel des Ganzen ist es in einer Box nicht nur Fotos zu sammeln, sondern auch weitere Boxen, in denen wiederum Fotos liegen können. Das heißt: eine Box kann nicht nur Fotos enthalten, sondern selbst auch Boxen (mit Fotos). Wie bildet man das in Klassen ab? Wäre toll, wenn mir da jemand weiterhelfen könnte.
Hier noch, was ich bisher habe:
Der Schrank:
/**
* Cabinet repräsentiert einen Schrank o.ä. der Schubladen und Kartons mit Fotos enthält.
* Cabinet hat eine baumartige Struktur, die in einem TreeModel abgebildet werden kann.
*/
public class Cabinet extends Element<Drawer> {
public Cabinet() {
this("Neue Sammlung");
}
public Cabinet(String name) {
super(name);
elementList = new ArrayList<>();
}
}
Die Schublade:
/**
* Drawer repräsentiert eine Schublade in einer Box/Schrank.
*/
public class Drawer extends Element<Box> {
public Drawer() {
this(null, null);
}
public Drawer(Cabinet parent, String name) {
super(parent, name);
elementList = new ArrayList<>();
}
}
Die Box:
import java.util.ArrayList;
/**
* Box repräsentiert eine/n Schachtel/Karton, die/der Fotos enthält.
*/
public class Box extends Element<Photo> {
public Box() {
}
public Box(Drawer parent, String name) {
super(parent, name);
elementList = new ArrayList<>();
}
}
Das Foto:
/**
* Photo repräsentiert ein Foto.
*/
public class Photo {
private String name;
private Box parent;
private String imagePath;
public Photo() {
this(null, null);
}
public Photo(Box parent, String name) {
this(parent, name, null);
}
public Photo(Box parent, String name, String imagePath) {
this.parent = parent;
this.name = name;
this.imagePath = imagePath;
}
/**
* Gibt die String-Repräsentation des Pfades des Fotos zurück.
*
* @return der Pfad zum Foto
*/
public String getImagePath() {
return imagePath;
}
/**
* Setzt den Pfad zum zum eingebetteten Foto.
*
* @param imagePath der Pfad zum Foto.
*/
public void setImagePath(String imagePath) {
this.imagePath = imagePath;
}
@Override
public String toString() {
return name;
}
}
Die Basisklasse:
/**
*
* <code>
* Schrank
* +-Schublade_1
* | +-Karton_1
* | | +-Foto_1
* | | +-Foto_2
* | | +-Karton_1
* | | | +-Foto_1
* | | | +-Foto_2
* | | | +-Foto_3
* | | | +-[...]
* | | +-Foto_3
* | | +-[...]
* | +-Karton_2
* | +-[...]
* +-Schublade_2
* +-[...]
* </code>
*
*/
public class Element<T> {
protected List<T> elementList; //Liste von enthaltenen Elementen
private Element parent; //das Eltern-Objekt
private String name; //die Bezeichnung dieses Elements
/**
* Erzeugt ein neues Element.
*/
public Element() {
this(null);
}
/**
* Erzeugt ein neues Element mit der angegebenen Bezeichnung.
*
* @param name die Bezeichnung des Elements
*/
public Element(String name) {
this(null, name);
}
/**
* Erzeugt ein neues Element mit einem Verweis auf sein Eltern-Element
* und der angegebenen Bezeichnung.
*
* @param parent das Eltern-Element
* @param name die Bezeichnung des Elements
*/
public Element(Element parent, String name) {
this.parent = parent;
this.name = name;
}
/**
* Gibt das Eltern-Element zurück.
*
* @return das Eltern-Element
*/
public Element getParent() {
return parent;
}
/**
* Gibt eine Liste der im Element gespeicherten Elemente zurück.
*
* @return Liste der im Element gespeicherten Elemente
*/
public List<T> getElementList() {
return elementList;
}
/**
* Fügt ein neues Element diesem Element hinzu.
*
* @param t Das Element, das diesem Element hinzugefügt werden soll.
*/
public void addElement(T t) {
elementList.add(t);
}
/**
* @see java.lang.Object#toString()
* @return Ein String mit Name oder Zustandsdaten des Elements.
*/
@Override
public String toString() {
return name;
}
}
Eine Klasse zum Testen:
import java.util.Random;
public class Test {
public Test() {
Cabinet cabinet = createCabinet();
System.out.println(showCabinetTree(cabinet));
}
private Cabinet createCabinet() {
Cabinet cabinet = new Cabinet("Fotos");
for(int i = 0, j = random(4); i < j; i++) {
cabinet.addElement(createDrawer(cabinet));
}
return cabinet;
}
private Drawer createDrawer(Cabinet parent) {
Drawer drawer = new Drawer(parent, "Drawer_" + (parent.getElementList().size()+1));
for(int i = 0, j = random(6); i < j; i++) {
drawer.addElement(createBox(drawer));
}
return drawer;
}
private Box createBox(Drawer drawer) {
Box box = new Box(drawer, "Box_" + (drawer.getElementList().size()+1));
for(int i = 0, j = random(8); i < j; i++) {
box.addElement(createPhoto(box)); //Fotos hinzufügen
}
return box;
}
private Photo createPhoto(Box parent) {
Photo photo = new Photo(parent, "Foto_" + (parent.getElementList().size()+1));
return photo;
}
private int random(int number) {
Random r = new Random();
int n = r.nextInt(number);
if(n < 2) {
return 2;
}
return n;
}
private String showCabinetTree(Cabinet cabinet) {
StringBuilder sb = new StringBuilder();
sb.append(cabinet).append("\n\r");
for (Drawer drawer : cabinet.getElementList()) {
sb.append(" +-").append(drawer).append("\n\r");
for (Box box : drawer.getElementList()) {
sb.append(" +-").append(box).append("\n\r");
for (Photo photo : box.getElementList()) {
sb.append(" +-").append(photo).append("\n\r");
}
}
}
return sb.toString();
}
public static void main(String[] args) {
new Test();
}
}
aber im Moment erschließt sich mir nicht ganz, welche Rolle oder welchen Zweck die Generics da erfüllen (sollen).
Allerdings hat mit die Idee, die ArrayList zu beerben gefallen.