Observer/Observable & Grundlagen

[Zenic]

Also ich habe eine Klasse (Observable) welche 3 Collections enthält. Die Collections werden in unterschiedlichen Komponenten dargestellt. Ist es nun besser bei jeder Änderung alle registrierten Observer zu informieren und die unnötigen Benachrichtigungen hin zu nehmen oder sollte für jede Collection eine eigene Liste ihrer Observer geführt werden?

Zusätzlich habe ich noch eine grundlegende Frage zum Aufbau einer Applikation. Zwei dieser Collections führen Attribute der Objekte der dritten Collection. Da das Ganze nicht so leicht zu verstehe ist bzw. ich mich wohl nicht gut genug ausdrücke, hier ein Beispiel um es zu verdeutlichen.

Collection<Fahrzeug> fahrzeuge {Attribute von Fahrzeug: farbe, anzReifen, ...}
Collection<Color> farben
Collection<Integer> anzReifen

Die Farben bzw. Reifenanzahl werden später in JComboBoxen dargestellt, um nach ihnen zu filtern, löschen, etc. . Ist dieses Vorgehen richtig oder sollte man die Collections zur Laufzeit erstellen, also zum Beispiel: new JComboBox(fahrzeuge.getColors())? Wie verhält es sich hier mit Collections die auf jeden Fall benutzt werden (wie hier für ComboBox) und mit Collections die nur in speziellen Fällen benutzt werden?

danke
Zenic

 

[Foermchen82]

Zu deiner ersten Frage: Es kommt darauf an!
Wenn die Collections zusammen hängen würde ich nur einen Listener machen.

Jedoch musst du dir überlegen, ob die 3 Collections geschickt sind, oder ob du eine ContainerKlasse machst mit der dann deine Listener aberbeiten können.

Zu deiner zweiten Frage: hier verstehe ich denn Sinn nicht ganz. Was genau hast du vor? Wie dynamisch sind deine Daten?

 

[Zenic]

Ich versuche mal den Punkt 2 noch besser zu erklären.

Hier nochmal die Struktur:

Collection<Fahrzeug> fahrzeuge {Attribute von Fahrzeug: farbe, anzReifen, ...}
Collection<Color> farben
Collection<Integer> anzReifen

Da ich mich mit Datenbanken noch nicht beschäftigt habe, arbeite ich mit CSV-Files und Collections. Die Collection "fahrzeuge" enthält alle eingelesen Fahrzeuge und die Collections "farben" und "anzReifen" enthalten alle schon vorhandenen Farben/Reifenanzahl (nur 1 mal). Beim Hinzufügen eines Fahrzeugs über die GUI wird dem User eine ComboBox mit allen schon vorhanden Farben (Collection: farben) angezeigt (selbes gilt für anzReifen). Wenn der User keine passende Farbe bzw. Reifenanzahl findet kann er eine neue hinzufügen.

Aktuell werden die Collections "farben" und "anzReifen" immer benötigt wenn die ComboBox dargestellt wird. Bei jedem hinzufügen in die Collection werden die Comboboxen (Observer) aktualisiert. Nun nochmal die Frage, machen diese Collections Sinn oder ist es nicht weniger effizient wenn ich eine Methode getColors() [das war in meinem 1. Posting falsch] schreibe. In diesem Fall muss bei jeder Combobox die komplette Fahrzeugcollection durchlaufen werden, je nach Größe kann das natürlich dauern.

Bsp.: für getColors()

public Collection<Color> getColors(){
	List<Color> list = new ArrayList<Color>();
	
	for(Fahrzeug f : fahrzeuge){
		if(!list.contains(f.getColor())){
			list.add(f.getColor());
		}
	}
	
	return list;
}

Edit: Zu Punkt 1 noch:
Ja die Collections hängen zusammen und ob sie geschickt sind wird sich wohl bei Frage 2 klären. Aber wie ist das mit der Containerklasse zu verstehen? Die Collections sind ja alle in einer Klasse und diese ist Observable, somit benachrichtige ich mit "notifyObservers()" aktuell alle Observer auf einmal.

 

[Michael...]

Grundsätzlich kann man, um die bereitsverwendeten Farben zu ermitteln über die vorhandenen Listenobjekte iterieren. Das sollte auch noch bei einer grösseren Anzahl an Objekten relativ flüssig laufen.
Schöner wäre es eventuell diese Farbliste dauerhaft zu halten und nur anzupassen, wenn Objekte aus der Liste entfernt, oder neue hinzugefügt werden.

Zum Thema benachrichtigung der Observer:
Grundsätzlich finde ich es nicht verkehrt, wenn alle Observer über Änderungen informiert werden, da eigentlich nur diese Wissen können welche Informationen für sie relevant sind.
Verwendest Du die Klassen aus java.util oder verwendest Du da ein eigenes Interface?
Bei ersterem könntest Du ja die notifyMethoden überschreiben und beim Aufruf der

update(Observable o, Object arg)

an den Observern ein entsprechendes Objekt mitgeben, das Aufschlüsse über die Art der Änderung zu lässt.
Bei letzterem (wäre meine bevorzugte Variante) könntest Du ja das Interface entsprechend anpassen und ein eigenens Event definieren, anhand dessen die Observer entscheiden können, ob sie die Änderungen interessieren oder nicht.

 

[Zenic]

Ich benutze Observable/Observer aus java.util. Hat diese Variante neben der fehlenden Möglichkeit des Ableitens, noch einen Nachteil gegenüber einem eigenen Interface?

Danke schonmal.

 

[Michael...]

Hat diese Variante neben der fehlenden Möglichkeit des Ableitens, noch einen Nachteil gegenüber einem eigenen Interface?

Man kann doch von Observable erben? Oder hab ich das falsch verstanden?

Ansonsten kann dazu - mangels Erfahrung - nicht viel dazu sagen. Ich mache mir bei sowas immer eigene Interfaces, da ich lieber implementiere anstatt von Observable zu erben.

 

[Zenic]

Ich mache mir bei sowas immer eigene Interfaces, da ich lieber implementiere anstatt von Observable zu erben.

Genau das meinte ich mit "der fehlenden Möglichkeit des Ableitens", dass man von Observable ableiten muss und somit das Erben von einer anderen Klasse entfällt.