PhilKa: Die Seite wurde neu angelegt: „= Observer-Entwurfsmuster (Observer Pattern) = Das '''Observer-Entwurfsmuster''' (deutsch: '''Beobachter-Muster''') ist ein '''Verhaltensmuster''', das verwendet wird, um eine '''eins-zu-viele-Abhängigkeit''' zwischen Objekten zu definieren. Wenn sich der Zustand eines Objekts (des '''Subjects''') ändert, werden automatisch alle abhängigen Objekte (die '''Observer''') benachrichtigt und aktualisiert. Das Muster wird häufig für '''Ereignisbenachri…“

2025-10-30T11:41:42Z

Die Seite wurde neu angelegt: „= Observer-Entwurfsmuster (Observer Pattern) = Das '''Observer-Entwurfsmuster''' (deutsch: '''Beobachter-Muster''') ist ein '''Verhaltensmuster''', das verwendet wird, um eine '''eins-zu-viele-Abhängigkeit''' zwischen Objekten zu definieren. Wenn sich der Zustand eines Objekts (des '''Subjects''') ändert, werden automatisch alle abhängigen Objekte (die '''Observer''') benachrichtigt und aktualisiert. Das Muster wird häufig für '''Ereignisbenachri…“

Neue Seite

= Observer-Entwurfsmuster (Observer Pattern) =

Das '''Observer-Entwurfsmuster''' (deutsch: '''Beobachter-Muster''') ist ein '''Verhaltensmuster''', das verwendet wird, um eine '''eins-zu-viele-Abhängigkeit''' zwischen Objekten zu definieren.
Wenn sich der Zustand eines Objekts (des '''Subjects''') ändert, werden automatisch alle abhängigen Objekte (die '''Observer''') benachrichtigt und aktualisiert.

Das Muster wird häufig für '''Ereignisbenachrichtigungen''', '''GUI-Updates''' oder '''Echtzeitkommunikation''' eingesetzt.

== Grundidee ==

Ein Objekt („Subject“) verwaltet eine Liste von Beobachtern („Observer“) und informiert sie, sobald sich sein Zustand ändert.
Dadurch wird eine lose Kopplung zwischen Sender und Empfänger erreicht – das Subject kennt seine Observer nicht im Detail.

<pre>
+-------------------+ +-------------------+
| Subject |<------>| Observer |
|-------------------| |-------------------|
| + attach() | | + update() |
| + detach() | | |
| + notify() | +-------------------+
+-------------------+
</pre>

== Struktur ==
{| class="wikitable"
! Komponente !! Beschreibung
|-
| '''Subject''' || Verwaltet eine Liste von Observern und benachrichtigt sie bei Zustandsänderungen.
|-
| '''Observer''' || Definiert ein Interface zur Aktualisierung bei Benachrichtigung.
|-
| '''ConcreteSubject''' || Konkrete Implementierung des Subjects; speichert den Zustand.
|-
| '''ConcreteObserver''' || Beobachtet ein Subject und reagiert auf Benachrichtigungen.
|}

== Beispiel (C++) ==
Ein einfaches Beispiel für das Observer-Muster in C++:

<syntaxhighlight lang="cpp">
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

class Observer {
public:
virtual void update(const std::string& message) = 0;
virtual ~Observer() = default;
};

class Subject {
std::vector<Observer*> observers;
public:
void attach(Observer* obs) {
observers.push_back(obs);
}

void detach(Observer* obs) {
observers.erase(std::remove(observers.begin(), observers.end(), obs), observers.end());
}

void notify(const std::string& message) {
for (auto* obs : observers)
obs->update(message);
}
};

class ConcreteObserver : public Observer {
std::string name;
public:
explicit ConcreteObserver(std::string n) : name(std::move(n)) {}
void update(const std::string& message) override {
std::cout << name << " erhielt Nachricht: " << message << std::endl;
}
};

int main() {
Subject newsStation;

ConcreteObserver alice("Alice");
ConcreteObserver bob("Bob");

newsStation.attach(&alice);
newsStation.attach(&bob);

newsStation.notify("Neue Nachricht: Design Patterns erklärt!");

newsStation.detach(&bob);
newsStation.notify("Zweite Nachricht: Nur Alice wird benachrichtigt.");
}
</syntaxhighlight>

== Erklärung ==
In diesem Beispiel:
* Das <code>Subject</code> (NewsStation) hält eine Liste von Beobachtern.
* Bei einer Änderung ruft es <code>notify()</code> auf.
* Jeder <code>Observer</code> wird mit <code>update()</code> benachrichtigt.

So bleibt das System flexibel: Neue Beobachter können leicht hinzugefügt oder entfernt werden, ohne das Subject zu verändern.

== Vorteile ==
* Lose Kopplung zwischen Sender (Subject) und Empfänger (Observer)
* Beliebig viele Empfänger möglich
* Dynamisches An- und Abmelden der Beobachter

== Nachteile ==
* Mögliche Performanceprobleme bei vielen Beobachtern
* Reihenfolge und Zeitpunkte der Benachrichtigungen sind nicht garantiert
* Kann zu unerwarteten Nebenwirkungen führen, wenn Beobachter ihrerseits wieder Benachrichtigungen auslösen

== Typische Anwendungsfälle ==
* GUI-Systeme (z. B. Button → Listener)
* Event-Systeme (z. B. Message Bus, Signals/Slots)
* Datenbindung in MVVM-Architekturen
* Echtzeitbenachrichtigung (z. B. Wetterstation, Börsenticker)

== Varianten ==
* '''Push-Modell''': Das Subject sendet alle relevanten Daten mit der Benachrichtigung.
* '''Pull-Modell''': Der Observer ruft die benötigten Daten beim Subject selbst ab.

== Vergleich mit ähnlichen Mustern ==
{| class="wikitable"
! Muster !! Vergleich
|-
| [[Mediator-Entwurfsmuster]] || Koordiniert mehrere Objekte zentral, anstatt direkte Benachrichtigungen zu senden.
|-
| [[Publisher-Subscriber-Muster]] || Ähnlich, aber häufig über einen Message-Bus oder Event-Queue realisiert.
|-
| [[Reactor-Entwurfsmuster]] || Ereignisgesteuert, aber auf System-Ebene (z. B. Socket-Ereignisse) statt auf Objektebene.
|}

== Siehe auch ==
* [[Publisher-Subscriber-Muster]]
* [[Mediator-Entwurfsmuster]]
* [[Reactor-Entwurfsmuster]]
* [[Event-Driven Architecture]]
* [[Entwurfsmuster (Softwareentwicklung)]]

== Quellen ==
* Erich Gamma et al.: *Design Patterns – Elements of Reusable Object-Oriented Software* (GoF, 1994)
* [https://en.wikipedia.org/wiki/Observer_pattern Wikipedia: Observer Pattern]
* [https://refactoring.guru/design-patterns/observer Refactoring.Guru: Observer Pattern]

Observer-Entwurfsmuster (Observer Pattern) - Versionsgeschichte