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.
Grundsätzlich spricht da nix gegen.
Aber was spricht gegen java.util.Observable ?!
Du kannst ja verschiedene Objekte übergeben wenn es sein muss und reagierst unterschiedlich oder du baust dir zwei unterschiedliche Listener für die Beobachter und entscheidest im Observer, wer dieses Event erhalten soll. Dadurch ersparst du dir die doppelten Registrierungen ...
Java:
public void update(Observable o, Object arg )
{
System.out.println( "Ereignis von " + o + " erhalten! mit folgendem Wert + " + arg.toString());
}
Aber wie kann ich dann das eine Observerable von dem anderen unterscheiden?
ich rufe notifyObservers(Object args) auf und dann muss ich ja das irgendwie
unterscheiden können, sonst werden observer informiert die mit der information
überhaupt nix anfangen können.
Schon, genauer gesagt ist es aber ein Interface (wie dir die Endung -able verrät). D.h. du brauchst die Klasse nicht zu erweitern, sondern nur implementieren, wodurch Mehrfachvererbung in Java ermöglicht wird.
Aber wie kann ich dann das eine Observerable von dem anderen unterscheiden?
ich rufe notifyObservers(Object args) auf und dann muss ich ja das irgendwie
unterscheiden können, sonst werden observer informiert die mit der information
überhaupt nix anfangen können.
Schon, genauer gesagt ist es aber ein Interface (wie dir die Endung -able verrät). D.h. du brauchst die Klasse nicht zu erweitern, sondern nur implementieren, wodurch Mehrfachvererbung in Java ermöglicht wird.
public interface Observerable {
public void registerObserver(Observer observer, int identifier);
public void removeObserver(Observer observer, int identifier);
public void notifyObservers(String message, int identifier);
}
Java:
public interface Observer {
public void update(Observerable observerable, String string);
public Observerable getObserverable();
public void setObserverable(Observerable observerable);
}
Der Observer muss also einen identifier angeben wenn er sich regestriert oder
abmelden möchte. ich führe dann einfach verschiedene Listen.
Da kommt dann einfach ein if/else rein wo ich in die verschiedenen Listen
verzweige. Müsste klappen.
Bei deiner Angabe kann ichs nur rein proforma sagen, bitte sag mir doch was für Daten du überwachen musst bzw wie sie aufgebaut sind.
Dann kann ich dir ne bessere Antwort geben!
Hier mal ein Beispiel wie du in einem Objekt zwei Werte überwachen lassen kannst:
Das Obeservable Objekt
Java:
import java.util.Observable;
/**
* Die Klasse die beobachtet werden soll.
*
* Sie bildet einen einfachen Zahlenspeicher ab.
* Dieser wird durch ein int und ein String abgebildet.
* Beide Attribute sind Objekte (Damit sie beobachtet werden könnnen)
*
* @version 2012-06-13
* @author Polak Rene
*/
public class BaseClass extends Observable {
//Attribute; Müssen Objekte sein. Primitive Datentypen kann der Observer nicht unterscheiden, bzw nur umständlich.
private Integer zahl;
private String zahlStr;
/*******************************/
/******** Konstruktoren ********/
/*******************************/
public BaseClass() {
this(0,"Null");
}
/**
* Hauptkonstruktor
*
* @param zahl int; zahl die gespeichert wird.
* @param zahlStr String; Das zugehörige Wort für die Zahl
*/
public BaseClass(int zahl,String zahlStr) {
super();
this.zahl = zahl;
this.zahlStr = zahlStr;
}
/*******************************/
/****** Setter und Getter ******/
/*******************************/
public Integer getZahl() {
return this.zahl;
}
public void setZahl(Integer zahl) {
if( !(this.zahl.equals( zahl ) ) ) {
this.zahl = zahl;
super.setChanged();
super.notifyObservers(zahl);
}
}
public String getZahlStr() {
return this.zahlStr;
}
public void setZahlStr(String zahlStr) {
if( !(this.zahlStr.toLowerCase().equals( zahlStr.toLowerCase() ) ) ) {
this.zahlStr = zahlStr;
super.setChanged();
super.notifyObservers(zahlStr);
}
}
}
Der Observer
Java:
import java.util.Observable;
import java.util.Observer;
/**
* Die eigentliche Observerklasse.
*
* Sie beobachtet die BaseKlasse und gibt je nach dem welches Objekt geändert wurde,
* soll eine entsprechende Meldung ausgegeben werden.
*
* @version 2012-06-13
* @author Polak Rene
*/
public class ObserverClass implements Observer {
@Override
public void update(Observable o, Object arg) {
// überprüft ob das Objekt ein Integer ist.
if(arg instanceof Integer) {
System.out.println("Der Integer hat sich geändert! Neuer Wert: " +( (Integer) arg ).intValue());
}
// überprüft ob das Objekt ein String ist.
if(arg instanceof String) {
System.out.println("Der String-Wert hat sich geändert! Neuer String: " + ((String) arg));
}
}
}
Die MainKlasse.
(Beinhaltet die main Methode
Java:
package Observer;
/**
* Main Klasse.
* Beinhaltet die main-Methode zum starten des Programkms
*
* @version 2012-06-13
* @author Polak Rene
*/
public class MainClass {
public static void main(String... args) {
ObserverClass aufpasser = new ObserverClass();
BaseClass daten = new BaseClass();
daten.addObserver(aufpasser);
//Schnell mal die default Werte ausgeben.
System.out.println("Zahl: " + daten.getZahl().toString() + "\nZahlenwort: " + daten.getZahlStr());
daten.setZahl(3);
daten.setZahlStr("Drei");
daten.setZahlStr("Zehn");
daten.setZahlStr("Zehn");
daten.setZahl(10);
System.out.println("\nProgramm Fertig");
}
}
Schon, genauer gesagt ist es aber ein Interface (wie dir die Endung -able verrät). D.h. du brauchst die Klasse nicht zu erweitern, sondern nur implementieren, wodurch Mehrfachvererbung in Java ermöglicht wird.
