[erledigt] Observable/Observer Beobachter entfernen

[hellcoder]

Hallo,

Ich beschäftige mich gerade mit dem Observer-Pattern und stelle mir folgende Frage. Wie entferne ich einen Beobachter am besten von der Liste des Subjekts.

Methode1: KonkreterBeobachter.removeObserver();
Methode 2: konkretesSubjekt.deleteObserver(KonkreterBeobachter);

public class testObservable {
	public static void main(String[] args) {
		
		Autohaus autohausMueller = new Autohaus();
		Beobachter0 b0 = new Beobachter0(autohausMueller);
		Beobachter1 b1 = new Beobachter1(autohausMueller);

		autohausMueller.setAngebot("Fiat","Punto", 1000);
		autohausMueller.setAngebot("Fiat","Cinquecento", 1300);

		/*Entfernen des Beobachters b1*/
		//autohausMueller.deleteObserver(b1);	//fuktioniert
		b1.removeObserver();					//funktioniert auch
		
		autohausMueller.setAngebot("Fiat","Punto", 1000);
		autohausMueller.setAngebot("Fiat","Cinquecento", 1300);
	}

}

//autohausMueller.deleteObserver(b1); //fuktioniert
b1.removeObserver(); //funktioniert auch

public class Beobachter1 implements Observer,AnzeigeElement{

	Observable observable;
	private double preis;
	private String modell;
	
	public Beobachter1(Observable obs) {
		this.observable = obs;
		obs.addObserver(this);
	}
	
	@Override
	public void update(Observable o, Object arg) {
		if (o instanceof Autohaus){
			Autohaus autohaus = (Autohaus) o;
			this.modell = autohaus.getModell();
			this.preis = autohaus.getPreis();
			anzeigen();
		}
		
	}

	@Override
	public void anzeigen() {
		System.out.println("Beobachter-1: " + modell + " preis: " + preis);
		
	}
	
	public void removeObserver(){
		observable.deleteObserver(this);
	}

	public void addObserver(){
		observable.addObserver(this);
	}

}

public void removeObserver(){
observable.deleteObserver(this);
}

public void addObserver(){
observable.addObserver(this);
}


Sollten solle Methoden in den Beobachtern implementiert werden ?
Wenn ja, warum gibt das Interface Observer eine Methode update() vor, nicht aber eine Methode remove(), add()

public class Autohaus extends Observable{

	private double preis;
	private String marke;
	private String modell;
	
	public Autohaus() {	}
	
	
	public void angebotGeändert(){
		setChanged();	//Anzeigen das sich zustand geändert hat. Immer nötig vor notifyObservers()
		notifyObservers(); //Herausziehen-Modell für aktualisierung
	}
	
	/**Neues Angebot veröffentlichen*/
	public void setAngebot(String marke, String modell,double preis){
		this.preis = preis;
		this.marke = marke;
		this.modell = modell;
		angebotGeändert();
	}

	public double getPreis(){
		return this.preis;
	}
	
	public String getModell(){
		return this.modell;
	}
	
	public String getMarke(){
		return this.marke;
	}
	
}

Viele Grüße,

Hellcoder

 

[SlaterB]

Achtug, blahblah:


zu den Interfaces:

ein Observable muss als solches nach außen erkennbar und bearbeitbar sein,
es ist eindeutig, was genau es ist, welche Observer es hat usw.
add und remove sind essentiell und eindeutig definiert

die einzelnen Observer können da ganz anders ticken,
sie brauchen auf jeden Fall die update-Operation, um vom Observable informiert zu werden, ansonsten muss nicht nach außen bekannt gemacht werden,

während Observable ohne Steuerung von außen keinen Sinn macht,
kann ein Obserser durchaus selbstständig und transparent arbeiten,
niemand muss von außen sagen, auf wen der Observer zu hören oder nicht mehr zu hören hat,
es muss von außen auch nicht sichtbar sein, ob ein Observer vielleicht mehrere Observable abhört,
das Interface ist deshalb ganz leer, nur die update()-Operation ist unumgänglich


--------

zum Vorgehen:

> autohausMueller.deleteObserver(b1);
ist klar, so muss es sein, in beiden Fällen


wer den Aufruf ausführt ist egal,
entweder du hast eine Liste aller Observer und kappst deren Verbingung ohne das die das ahnen,
oder sagst jedem dieser Observer, dass sie ihre Verbindung zum Autohaus kappen sollen,

beides scheint mir seine Berechtigung zu haben, in bestimmten Situationen mehr oder weniger hilfreich zu sein,
musst du mit deinen Observern ausmachen

im Zweifel finde ich
b1.removeObserver();
also b1.meldeDichVonDeinemObservableAb();
schicker, aber auch aufwendiger,
und wie gesagt kann ein Observer auch auf mehrere Observable hören

 

[hellcoder]

ok, nun ist das klar

vielen Dank. SlaterB



Gruß, hellcoder