# ObservableList



## qpid (4. Apr 2006)

Hallo Forumuser,

ich habe irgendwo mal etwas von einer ObservableList gelesen. Wie es dann immer so ist, findet man es nicht wieder wenn man es braucht.

Im Grunde möchte ich ein ArrayList oder Vector Observable machen. Die Vorteile, liegen meiner Ansicht nach darin, dass ich dann eine Liste mit Daten, die ich an mehreren Stellen anzeige, automatisch aktuallisieren lassen kann oder auch einen eventuellen Status des Speicherzustands per "Event" ändern kann.

Mir ist die Problematik bewusst, dass es nur eine einfach Vererbung gibt und ich "List" und Observable nicht unter einen Hut bekomme ohne zumindest eine der beiden Klassen zu kopieren um beide im vollen Umfang nutzen zu können. Wobei ich gerade nicht sagen kann warum ich die Observable Klasse im vollem Umfang also unter den Aspekten der Polymorphie brauche. Ist wohl mehr ein Gefühl von Freiheit

Aber eventuell kennt ja jemand diese Problematik und hat dafür ein kleines Workaraound parat oder eine Standard Lösung.

Danke im Voraus.

mfg qpid


----------



## Andre_ (4. Apr 2006)

naja du kannst doch einfach einen Vektor ableiten und dann die Methoden überschreiben bei denen du eine Rückmeldung haben willst ... in dem du einfach super aufrufst und danach noch alle registrierten Listener benachrichtigst ... die Listener verwaltest du einfach in einem Vektor .. das ist wirklich kein grosser Aufwand und du bist sehr flexible was die Funktionalität angeht ..

Gruß André


----------



## Guest (5. Apr 2006)

```
public class ObservableList<E> extends Observable implements List<E>
{
  private static final long serialVersionUID = ...L;
  private List<E> list;

  public ObservableList()
  {
    super();
    list = new ArrayList<E>();
  }

  public ObservableList(int capacity)
  {
    super();
    list = new ArrayList<E>(capacity);
  }

  public boolean add(E o)
  {
    boolean result = list.add(o);
    setChanged();
    notifyObservers();
    return result;
  }

  // und ähnlich alle anderen Methoden aus java.util.List
  // implementieren (an 'list' delegieren)
}
```


----------



## qpid (5. Apr 2006)

Also an Ansätzen hat es mir nicht gemagelt, die Variante Observable zu erweitern und List zu implementieren und dann einfach alle methoden von einer Liste durchzureichen war en mir auch schon in den Sinn gekommen. Mir stellte sich jetzt vielmehr die Frage ob es da eventuell ein gewisses standard Verfahren gibt.

Dabei ist mir noch eingefallen wenn ich die Elemente in der Liste ändere sollten diese der Liste die Änderung weitergeben. Somit sollte die ObservableList gleichzeit Observer sein und die Elemente wiederum Observable usw... Sollte auch bei dem was ich vorhabe nocht recht Performant sein.

Andre_: Bei deiner Lösung ist mir nicht ganz ersichtlich woher ich das Observable bekommen soll.

mfg qpid


----------



## bygones (5. Apr 2006)

wieso musst du das ganze nochmals speichern, wenn deine Daten die zu aktualisieren sind sich bei einem Oberserver anmelden musst du dich um eine weitere logische Speicherung nicht kümmern.... sobald der Observer ein update schickt, werden alle angemeldeten Observables angesprochen


----------



## qpid (5. Apr 2006)

deathbyaclown hat gesagt.:
			
		

> wieso musst du das ganze nochmals speichern, wenn deine Daten die zu aktualisieren sind sich bei einem Oberserver anmelden musst du dich um eine weitere logische Speicherung nicht kümmern.... sobald der Observer ein update schickt, werden alle angemeldeten Observables angesprochen



Wenn ich ein in der Liste befindliches Bean per setMethode ändere dann hat die liste nichts davon mitbekommen und kann somit auch nicht seine zuhörer informieren.

mfg qpid


----------



## Andre_ (5. Apr 2006)

Also da du jetzt die Objekte in der Liste noch als Observable haben willst würde ich an deiner Stelle die Liste/Vector-Classe überschreiben und diese bei all seinen Elementen registrieren und dann einfach noch einen eigenen Listener bauen bei dem sich die zu benachrichtigenden Kassen bei dem neuen Vector anmelden können.


Eigener Listener ... 
void addListener(EigenesInterface o)
void/EigenesInterface deleteListener()

EigenesInterface 
obserableChange(Observable,Objecte); <-- da steckst du dann die werte von dem untergeordnen Element im Vector rein..


Das eigenen ListenerInterface ist insgesamt recht klein vielleicht 30 Zeilen ... aber List/Vector zu überschreiben so das man bei jedem hinzugefügten oder gelöschten Element den Vector bei den Observern zu registrieren ist ein bisschen Aufwand.

Also besseres fällt mir momentan auch nicht ein, aber so kannst du dir die Klasse sehr flexible halten .. also du könntest bei obserableChange auch den Vector noch mitliefern wenn du magst...

Vielleicht hilft dir die Idee ja ein bisschen weiter.

Gruß Andre


----------



## qpid (6. Apr 2006)

Danke Andre_,

so in etwa bin ich das ganze jetzt auch angegangen.

mfg qpid


----------

