Frage zum Design der Datenstruktur

[stefan.]

Hallo,

meine Datenstruktur sieht in etwa so aus:

Nachricht
-->Element1
-->Element1
-->Element1
-->...

--> Element2
---->Element1
---->Element1
------> Element2
-------->Element1
-------->Element1
-------->...
----->...

--> Element3
----> Element2
------->Element1
------->Element1
------->Element1
------->Element1
------->Element3
--------->Element1
--------->Element1
--------->...
------->...

Also eine Nachricht hat beliebig viele Objekte vom Typ Element 1,2 oder 3. Jedes Element kann wiederrum beliebig viele Elemente 1,2 oder 3 haben, also beliebig Schachtelbar.

Meine erste Idee ist:

public class Nachricht {
	Vector<Elementtyp> elemente;
}

public class Elementtyp {
	Element1 element1;
	Element2 element2;
	Element3 element3;
}

public class Element1{
	Vector<Elementtyp> elemente;
}

public class Element2{
	Vector<Elementtyp> elemente;
}

public class Element3{
	Vector<Elementtyp> elemente;
}

Ich würde quasi in der Klasse Elementtyp alle 3 Elemente kapseln und immer nur den jeweiligen Typ (1,2,3) setzen. Mein Gedanke dabei war, nicht immer Objekte casten zu müssen wenn ich in der Nachrichten Klasse bspw. Vector<Object> statt Vector<Elementtyp> nehmen würde.

Letztendlich muss es doch aber eine viel elegantere Methode geben ? Danke für jeden Tipp

 

[maki]

Vector solltest du nicht nehmen, lieber eine "moderne" Collection wie zB. List.

Was du suchst ist das Entwurfsmuster bzw. Pattern Namens "Composite" bzw. "Kompositium", einfach mal Googlen.

Bei konkreteren Fragen kannst du diese ja stellen.

 

[ARadauer]

import java.util.ArrayList;

public class Element {	
	ArrayList<Element> elments = new ArrayList<Element>();
}
------------
import java.util.ArrayList;

public class Nachricht {	
	ArrayList<Element> elments = new ArrayList<Element>();
}
-------
public class Nachricht1 extends Nachricht{

}
public class Nachricht2 extends Nachricht{

}
public class Nachricht3 extends Nachricht{

}

 

[ARadauer]

lol genau verkehrt ;-=

hab jetzt Element und Nachricht verdreht, aber ich hoffe man sieht was ich meine.
deine Nachricht hat einfach eine Liste mit Elementen, ob das jetzt 1,2,3 ist ist der Nachricht egal

 

[bygones]

warum 3 Klassen fuer die Elemente ? unterscheiden die sich so dermassen ?

ansonsten wie Maki schon erwaehnt scheint das der idealfall fuers Composite pattern zu sein

 

[maki]

... und zusätzlich noch das Besucher/Visitor Pattern, falls nötig mit dem sog. Double Dispatch, dann spart man sich das casten

 

[bygones]

... und zusätzlich noch das Besucher/Visitor Pattern, falls nötig mit dem sog. Double Dispatch, dann spart man sich das casten

oh yeah :smoke:
:lol:

 

[maki]

Ok, viellecht etwas abstrakt die "Beschreibung"..

 

[stefan.]

Also das Composite Pattern klingt interessant.

public class Nachricht {
	ArrayList<AbtsractElement> elements=new ArrayList<AbstractElement>;
}

public abstract class AbstractElement {
	ArrayList<AbstractElement> elements=new ArrayList<AbstractElement>;
	String name;
	boolean required;

	public void add(AbstractElement element){}
	public void remove(AbstractElement element){}
}

public class Element extends AbstractElement {
	public void add(AbstractElement e) {
		elements.add(e);
	}
	
	public void remove(AbstractElement e) {
		elements.remove(e);
	}
}

//entspricht Element1
public class Feld extends AbstractElement {
	int tag;
	String type;
	String value;
	int selection;
}

//entspricht Element2
public class Gruppe extends AbstractElement {
	Element element=new Element;
}

//entspricht Element3
public class Komponente extends AbstractElement {
	Element element=new Element;
}

Für eine Struktur wie

Nachricht
->Feld
->Feld
-->Gruppe
---->Feld
---->Feld
---->Komponente
------>Gruppe
-------->Feld
-------->Feld
-------->Feld
-------->...

(Eine Gruppe oder Komponente kann Felder, Gruppen oder Kompoenten enthalten, Felder enthalten jedoch keine Gruppen oder Komponenten)

Habe ich das Pattern richtig verstanden ? Wieso der Umweg über die Abstrakte Klasse ?

PS: Wusste garnicht das Vector veraltet ist. Ist denn eine ArrayList soviel Performanter ?

 

[maki]

Habe ich das Pattern richtig verstanden ? Wieso der Umweg über die Abstrakte Klasse ?

Man könnte auch ein Interface nehmen, hauptsache es gibt eine gemeinsame Schnittstelle die alle konkreten Implementierungen teilen (Feld, Gruppe, etc. pp.), so spart man sich das casten bzw. auf den Typ zu prüfen, man kann sie alle gleich behandeln, die UNterschiede sind nur noch intern, nicht mehr in der Schnittstelle.
Deswegen ist es auch besser, Methoden aller Element typen im Interface zu haben, als diese nur in bestimmten Elementen zu definieren.

Jetzt musst du dein Composite auch noch traversieren können, dazu eignet sich das Visitor Muster hervorragend.

PS: Wusste garnicht das Vector veraltet ist. Ist denn eine ArrayList soviel Performanter ?

Es geht nicht wirklich um Performance, sondernd arum dass Vector & Hashtable altlasten sind, sieh dir mal das Collection Framework an: Trail: Collections (The Java™ Tutorials)

ArrayList ist übrigens wieder eine implementierung, List ist das Interface, welches übrgigens auch von LinkedList implemnetiert wird

 

[stefan.]

Hallo maki, ich habe die Klassen nochmals modifziert:

public abstract class Element implements Serializable, Visitable {

	protected List<Element> elements=new ArrayList<Element>();
	protected String name;
	protected boolean required;

	public void add(Element element){
		elements.add(element);
   }
}

public class Field extends Element {
	private int tag;
	private String type;

@Override
	public void accept(Visitor visitor) {
		visitor.visitField(this);		
	}
}

public class Group extends Element {

@Override
	public void accept(Visitor visitor) {
		if(visitor.visitGroup(this)==true){
			for (Element element : elements) {
				element.accept(visitor);
			}
		}
		visitor.leaveGroup(this);
	}
} //Component Klasse analog wie Group

public class Message extends Element {
	private String type;
	private String category;

@Override
	public void accept(Visitor visitor) {
		if(visitor.visitMessage(this) ==true){
			for (Element element : elements) {
				element.accept(visitor);
			}	
		}
	}
}

Dazu noch ein paar Fragen:

Was ist besser ? In der abstrakten Klasse (Element) bei Methoden wie add(), remove() ein default-Verhalten zu implementieren oder eine Exception zu werfen und die Methoden in den anderen Klassen (Field, Group, Component, Message,..) zu überschreiben ?

In der abstrakten Klasse habe ich eine Liste mit Elementen (List<Element>). Ein Feld (Field) benötigt so eine Liste aber nicht, wäre es nun besser diese Liste nicht in der abstrakten Klasse, sondern nur in den benötigten Klassen (Group, Component, Message) zu erstellen ?

Zusätzlich habe ich das visitor-Pattern implementiert (mit deiner Vorlage aus einem anderen Thread maki :

interface Visitor: 

public interface Visitor {
	public boolean visitField(Field field);
	public boolean visitGroup(Group group);
	public boolean leaveGroup(Group group);
	public boolean visitComponent(Component component);
	public boolean leaveComponent(Component component);
	
	public boolean visitMessage(Message message);
}

interface Visitable:

public interface Visitable {
	public void accept(Visitor visitor);
}

Dazu eine Klasse PrintVisitor:

public class PrintVisitor implements Visitor {
	@Override
	public boolean visitField(Field field) {
		System.out.println("Field "+field);
	}
	//weitere Methoden des Interfaces ...
}

Nun möchte ich 2 Messages vergleichen (eine Liste von gleichen/ungleichen Feldern als Resultat).

D.h. Wenn ich das visitor Pattern richtig verstanden habe, implementiere ich einen Compare Visitor:

public class ComparatorVisitor implements Visitor {
	Message message;
	public ComparatorVisitor(Message m){
		this.message=m;
	}

	@Override
	public boolean visitField(Field field) {
		// hier alle felder der (globalen) message durchsuchen und prüfen ob field enthalten ist ?
		return false;
	}

	//weitere Methoden ..
}

Oder gibt es eine bessere (schnellere) Möglichkeit 2 Messages zu vergleichen, also nicht in jeder Methode des interfaces visitor die Message nach dem jeweiligen Element zu durchsuchen?

Danke für die Hilfe !!