Observer Pattern

Stay updated automatically - when one object changes, all observers get notified!

By Vishnu Darshan Sanku · Updated September 25, 2026

Observer Pattern: Keeping Everyone in the Loop

Now let’s dive into the Observer Pattern - one of the most commonly used behavioral design patterns.

Why Observer Pattern?

Imagine you’re subscribed to a YouTube channel. When the creator uploads a new video, you automatically get notified - you don’t have to keep checking! The Observer Pattern works the same way!

The Observer Pattern lets objects notify multiple other objects (observers) about state changes automatically. When the subject (the thing being watched) changes, all observers are notified without the subject needing to know who’s watching.

What’s the Use of Observer Pattern?

The Observer Pattern is useful when:

One object changes and multiple objects need to be notified
You want loose coupling - Subject doesn’t need to know about observers
You need dynamic relationships - Observers can be added/removed at runtime
You want to avoid polling - No need to constantly check for changes
You need one-to-many dependency - One subject, many observers

What Happens If We Don’t Use Observer Pattern?

Without the Observer Pattern, you might:

Tightly couple objects - Subject needs to know all observers
Use polling - Constantly checking for changes (inefficient)
Scatter notification logic - Update code spread everywhere
Make it hard to add/remove observers - Need to modify subject code
Violate Open/Closed Principle - Need to modify code to add observers

Simple Example: The Weather Station

Let’s start with a super simple example that anyone can understand!

The Problem

You’re building a weather monitoring system. When the temperature changes, you need to update multiple displays (phone app, website, billboard). Without Observer Pattern:

💡 Tip: Click dropdown to switch between languages

1
# ❌ Without Observer Pattern - Tight coupling
2

3
class WeatherStation:
4
    def __init__(self):
5
        self.temperature = 0
6
        # Problem: Subject knows about all observers!
7
        self.phone_app = None
8
        self.website = None
9
        self.billboard = None
10

11
    def set_temperature(self, temp: float):
12
        self.temperature = temp
13
        # Problem: Need to manually notify each observer
14
        if self.phone_app:
15
            self.phone_app.update(temp)
16
        if self.website:
17
            self.website.update(temp)
18
        if self.billboard:
19
            self.billboard.update(temp)
20
        # Every time you add a new display, you need to modify this!
21

22
class PhoneApp:
23
    def update(self, temperature: float):
24
        print(f"📱 Phone: Temperature is {temperature}°C")
25

26
class Website:
27
    def update(self, temperature: float):
28
        print(f"🌐 Website: Temperature is {temperature}°C")
29

30
class Billboard:
31
    def update(self, temperature: float):
32
        print(f"📺 Billboard: Temperature is {temperature}°C")
33

34
# Usage
35
station = WeatherStation()
36
station.phone_app = PhoneApp()
37
station.website = Website()
38
station.billboard = Billboard()
39

40
station.set_temperature(25.0)

1
// ❌ Without Observer Pattern - Tight coupling
2

3
public class WeatherStation {
4
    private double temperature = 0;
5
    // Problem: Subject knows about all observers!
6
    private PhoneApp phoneApp = null;
7
    private Website website = null;
8
    private Billboard billboard = null;
9

10
    public void setTemperature(double temp) {
11
        this.temperature = temp;
12
        // Problem: Need to manually notify each observer
13
        if (phoneApp != null) {
14
            phoneApp.update(temp);
15
        }
16
        if (website != null) {
17
            website.update(temp);
18
        }
19
        if (billboard != null) {
20
            billboard.update(temp);
21
        }
22
        // Every time you add a new display, you need to modify this!
23
    }
24

25
    // Getters and setters
26
    public void setPhoneApp(PhoneApp phoneApp) {
27
        this.phoneApp = phoneApp;
28
    }
29

30
    public void setWebsite(Website website) {
31
        this.website = website;
32
    }
33

34
    public void setBillboard(Billboard billboard) {
35
        this.billboard = billboard;
36
    }
37
}
38

39
public class PhoneApp {
40
    public void update(double temperature) {
41
        System.out.println("📱 Phone: Temperature is " + temperature + "°C");
42
    }
43
}
44

45
public class Website {
46
    public void update(double temperature) {
47
        System.out.println("🌐 Website: Temperature is " + temperature + "°C");
48
    }
49
}
50

51
public class Billboard {
52
    public void update(double temperature) {
53
        System.out.println("📺 Billboard: Temperature is " + temperature + "°C");
54
    }
55
}
56

57
// Usage
58
public class Main {
59
    public static void main(String[] args) {
60
        WeatherStation station = new WeatherStation();
61
        station.setPhoneApp(new PhoneApp());
62
        station.setWebsite(new Website());
63
        station.setBillboard(new Billboard());
64

65
        station.setTemperature(25.0);
66
    }
67
}

1
// ❌ Without Observer Pattern - Tight coupling
2

3
class WeatherStation {
4
    private temperature: number = 0;
5
    // Problem: Subject knows about all observers!
6
    private phoneApp: PhoneApp | null = null;
7
    private website: Website | null = null;
8
    private billboard: Billboard | null = null;
9

10
    setTemperature(temp: number): void {
11
        this.temperature = temp;
12
        // Problem: Need to manually notify each observer
13
        if (this.phoneApp) {
14
            this.phoneApp.update(temp);
15
        }
16
        if (this.website) {
17
            this.website.update(temp);
18
        }
19
        if (this.billboard) {
20
            this.billboard.update(temp);
21
        }
22
        // Every time you add a new display, you need to modify this!
23
    }
24

25
    setPhoneApp(phoneApp: PhoneApp): void {
26
        this.phoneApp = phoneApp;
27
    }
28

29
    setWebsite(website: Website): void {
30
        this.website = website;
31
    }
32

33
    setBillboard(billboard: Billboard): void {
34
        this.billboard = billboard;
35
    }
36
}
37

38
class PhoneApp {
39
    update(temperature: number): void {
40
        console.log(`📱 Phone: Temperature is ${temperature}°C`);
41
    }
42
}
43

44
class Website {
45
    update(temperature: number): void {
46
        console.log(`🌐 Website: Temperature is ${temperature}°C`);
47
    }
48
}
49

50
class Billboard {
51
    update(temperature: number): void {
52
        console.log(`📺 Billboard: Temperature is ${temperature}°C`);
53
    }
54
}
55

56
// Usage
57
const station = new WeatherStation();
58
station.setPhoneApp(new PhoneApp());
59
station.setWebsite(new Website());
60
station.setBillboard(new Billboard());
61

62
station.setTemperature(25.0);

1
// ❌ Without Observer Pattern - Tight coupling
2

3
#include <iostream>
4
#include <memory>
5

6
class PhoneApp {
7
public:
8
    void update(double temperature) {
9
        std::cout << "📱 Phone: Temperature is " << temperature << "°C" << std::endl;
10
    }
11
};
12

13
class Website {
14
public:
15
    void update(double temperature) {
16
        std::cout << "🌐 Website: Temperature is " << temperature << "°C" << std::endl;
17
    }
18
};
19

20
class Billboard {
21
public:
22
    void update(double temperature) {
23
        std::cout << "📺 Billboard: Temperature is " << temperature << "°C" << std::endl;
24
    }
25
};
26

27
class WeatherStation {
28
private:
29
    double temperature = 0;
30
    // Problem: Subject knows about all observers!
31
    PhoneApp* phoneApp = nullptr;
32
    Website* website = nullptr;
33
    Billboard* billboard = nullptr;
34

35
public:
36
    void setTemperature(double temp) {
37
        this->temperature = temp;
38
        // Problem: Need to manually notify each observer
39
        if (phoneApp) {
40
            phoneApp->update(temp);
41
        }
42
        if (website) {
43
            website->update(temp);
44
        }
45
        if (billboard) {
46
            billboard->update(temp);
47
        }
48
        // Every time you add a new display, you need to modify this!
49
    }
50

51
    void setPhoneApp(PhoneApp* app) {
52
        this->phoneApp = app;
53
    }
54

55
    void setWebsite(Website* site) {
56
        this->website = site;
57
    }
58

59
    void setBillboard(Billboard* board) {
60
        this->billboard = board;
61
    }
62
};
63

64
// Usage
65
int main() {
66
    WeatherStation station;
67
    PhoneApp phoneApp;
68
    Website website;
69
    Billboard billboard;
70

71
    station.setPhoneApp(&phoneApp);
72
    station.setWebsite(&website);
73
    station.setBillboard(&billboard);
74

75
    station.setTemperature(25.0);
76

77
    return 0;
78
}

1
// ❌ Without Observer Pattern - Tight coupling
2

3
using System;
4

5
public class WeatherStation
6
{
7
    private double temperature = 0;
8
    // Problem: Subject knows about all observers!
9
    private PhoneApp phoneApp = null;
10
    private Website website = null;
11
    private Billboard billboard = null;
12

13
    public void SetTemperature(double temp)
14
    {
15
        this.temperature = temp;
16
        // Problem: Need to manually notify each observer
17
        if (phoneApp != null)
18
        {
19
            phoneApp.Update(temp);
20
        }
21
        if (website != null)
22
        {
23
            website.Update(temp);
24
        }
25
        if (billboard != null)
26
        {
27
            billboard.Update(temp);
28
        }
29
        // Every time you add a new display, you need to modify this!
30
    }
31

32
    public void SetPhoneApp(PhoneApp phoneApp)
33
    {
34
        this.phoneApp = phoneApp;
35
    }
36

37
    public void SetWebsite(Website website)
38
    {
39
        this.website = website;
40
    }
41

42
    public void SetBillboard(Billboard billboard)
43
    {
44
        this.billboard = billboard;
45
    }
46
}
47

48
public class PhoneApp
49
{
50
    public void Update(double temperature)
51
    {
52
        Console.WriteLine($"📱 Phone: Temperature is {temperature}°C");
53
    }
54
}
55

56
public class Website
57
{
58
    public void Update(double temperature)
59
    {
60
        Console.WriteLine($"🌐 Website: Temperature is {temperature}°C");
61
    }
62
}
63

64
public class Billboard
65
{
66
    public void Update(double temperature)
67
    {
68
        Console.WriteLine($"📺 Billboard: Temperature is {temperature}°C");
69
    }
70
}
71

72
// Usage
73
class Program
74
{
75
    static void Main()
76
    {
77
        WeatherStation station = new WeatherStation();
78
        station.SetPhoneApp(new PhoneApp());
79
        station.SetWebsite(new Website());
80
        station.SetBillboard(new Billboard());
81

82
        station.SetTemperature(25.0);
83
    }
84
}

1
package main
2

3
import "fmt"
4

5
// ❌ Without Observer Pattern - Tight coupling
6

7
type PhoneApp struct{}
8
type Website struct{}
9
type Billboard struct{}
10

11
func (p *PhoneApp) Update(temp float64)   { fmt.Printf("📱 Phone: Temperature is %.1f°C\n", temp) }
12
func (w *Website) Update(temp float64)    { fmt.Printf("🌐 Website: Temperature is %.1f°C\n", temp) }
13
func (b *Billboard) Update(temp float64)  { fmt.Printf("📺 Billboard: Temperature is %.1f°C\n", temp) }
14

15
type WeatherStation struct {
16
  temperature float64
17
  phoneApp    *PhoneApp
18
  website     *Website
19
  billboard   *Billboard
20
}
21

22
func (ws *WeatherStation) SetTemperature(temp float64) {
23
  ws.temperature = temp
24
  // Problem: Need to manually notify each observer
25
  if ws.phoneApp != nil { ws.phoneApp.Update(temp) }
26
  if ws.website != nil { ws.website.Update(temp) }
27
  if ws.billboard != nil { ws.billboard.Update(temp) }
28
}
29

30
func main() {
31
  station := &WeatherStation{}
32
  station.phoneApp = &PhoneApp{}
33
  station.website = &Website{}
34
  station.billboard = &Billboard{}
35
  station.SetTemperature(25.0)
36
}

1
struct OrderService;
2

3
impl OrderService {
4
    fn place_order(&self, order_id: u32) {
5
        println!("Order {} placed", order_id);
6
        println!("Sending email");
7
        println!("Updating analytics");
8
        println!("Notifying warehouse");
9
    }
10
}

1
📱 Phone: Temperature is 25.0°C
2
🌐 Website: Temperature is 25.0°C
3
📺 Billboard: Temperature is 25.0°C

Problems:

WeatherStation knows about all display types (tight coupling)
Need to modify set_temperature() every time you add a new display
Hard to remove observers
Violates Open/Closed Principle

Problems:

WeatherStation knows about all display types (tight coupling)
Need to modify set_temperature() every time you add a new display
Hard to remove observers
Violates Open/Closed Principle

The Solution: Observer Pattern

Class Structure

Observer pattern class diagram: abstract Subject implemented by WeatherStation, which notifies PhoneApp, Website and Billboard observers

💡 Tip: Click dropdown to switch between languages

1
from abc import ABC, abstractmethod
2
from typing import List
3

4
# Step 1: Define the Observer interface
5
class Observer(ABC):
6
    """Interface for all observers"""
7

8
    @abstractmethod
9
    def update(self, temperature: float) -> None:
10
        """Called when subject's state changes"""
11
        pass
12

13
# Step 2: Define the Subject interface
14
class Subject(ABC):
15
    """Interface for subjects that can be observed"""
16

17
    @abstractmethod
18
    def attach(self, observer: Observer) -> None:
19
        """Attach an observer"""
20
        pass
21

22
    @abstractmethod
23
    def detach(self, observer: Observer) -> None:
24
        """Detach an observer"""
25
        pass
26

27
    @abstractmethod
28
    def notify(self) -> None:
29
        """Notify all observers"""
30
        pass
31

32
# Step 3: Create concrete Subject
33
class WeatherStation(Subject):
34
    """Weather station - the subject being observed"""
35

36
    def __init__(self):
37
        self._temperature = 0
38
        self._observers: List[Observer] = []  # List of observers
39

40
    def attach(self, observer: Observer) -> None:
41
        """Subscribe an observer"""
42
        if observer not in self._observers:
43
            self._observers.append(observer)
44
            print(f"✅ Observer attached: {observer.__class__.__name__}")
45

46
    def detach(self, observer: Observer) -> None:
47
        """Unsubscribe an observer"""
48
        if observer in self._observers:
49
            self._observers.remove(observer)
50
            print(f"❌ Observer detached: {observer.__class__.__name__}")
51

52
    def notify(self) -> None:
53
        """Notify all observers about temperature change"""
54
        for observer in self._observers:
55
            observer.update(self._temperature)
56

57
    def set_temperature(self, temperature: float) -> None:
58
        """Set temperature and notify all observers"""
59
        self._temperature = temperature
60
        print(f"\n🌡️  Temperature changed to {temperature}°C")
61
        self.notify()  # Notify all observers!
62

63
    def get_temperature(self) -> float:
64
        """Get current temperature"""
65
        return self._temperature
66

67
# Step 4: Create concrete Observers
68
class PhoneApp(Observer):
69
    """Phone app observer"""
70

71
    def update(self, temperature: float) -> None:
72
        print(f"📱 Phone App: Temperature is {temperature}°C")
73

74
class Website(Observer):
75
    """Website observer"""
76

77
    def update(self, temperature: float) -> None:
78
        print(f"🌐 Website: Temperature is {temperature}°C")
79

80
class Billboard(Observer):
81
    """Billboard observer"""
82

83
    def update(self, temperature: float) -> None:
84
        print(f"📺 Billboard: Temperature is {temperature}°C")
85

86
# Step 5: Use the pattern
87
def main():
88
    # Create subject
89
    weather_station = WeatherStation()
90

91
    # Create observers
92
    phone_app = PhoneApp()
93
    website = Website()
94
    billboard = Billboard()
95

96
    # Subscribe observers
97
    weather_station.attach(phone_app)
98
    weather_station.attach(website)
99
    weather_station.attach(billboard)
100

101
    # Change temperature - all observers get notified automatically!
102
    weather_station.set_temperature(25.0)
103

104
    # Unsubscribe one observer
105
    weather_station.detach(website)
106

107
    # Change temperature again - only subscribed observers get notified
108
    weather_station.set_temperature(30.0)
109

110
    # Add a new observer - no need to modify WeatherStation!
111
    class SmartWatch(Observer):
112
        def update(self, temperature: float) -> None:
113
            print(f"⌚ Smart Watch: Temperature is {temperature}°C")
114

115
    smart_watch = SmartWatch()
116
    weather_station.attach(smart_watch)
117
    weather_station.set_temperature(22.0)
118

119
if __name__ == "__main__":
120
    main()

1
import java.util.ArrayList;
2
import java.util.List;
3

4
// Step 1: Define the Observer interface
5
public interface Observer {
6
    /**
7
     * Called when subject's state changes
8
     */
9
    void update(double temperature);
10
}
11

12
// Step 2: Define the Subject interface
13
public interface Subject {
14
    /**
15
     * Attach an observer
16
     */
17
    void attach(Observer observer);
18

19
    /**
20
     * Detach an observer
21
     */
22
    void detach(Observer observer);
23

24
    /**
25
     * Notify all observers
26
     */
27
    void notifyObservers();
28
}
29

30
// Step 3: Create concrete Subject
31
public class WeatherStation implements Subject {
32
    private double temperature = 0;
33
    private List<Observer> observers = new ArrayList<>();  // List of observers
34

35
    @Override
36
    public void attach(Observer observer) {
37
        if (!observers.contains(observer)) {
38
            observers.add(observer);
39
            System.out.println("✅ Observer attached: " + observer.getClass().getSimpleName());
40
        }
41
    }
42

43
    @Override
44
    public void detach(Observer observer) {
45
        if (observers.remove(observer)) {
46
            System.out.println("❌ Observer detached: " + observer.getClass().getSimpleName());
47
        }
48
    }
49

50
    @Override
51
    public void notifyObservers() {
52
        for (Observer observer : observers) {
53
            observer.update(temperature);
54
        }
55
    }
56

57
    public void setTemperature(double temperature) {
58
        this.temperature = temperature;
59
        System.out.println("\n🌡️  Temperature changed to " + temperature + "°C");
60
        notifyObservers();  // Notify all observers!
61
    }
62

63
    public double getTemperature() {
64
        return temperature;
65
    }
66
}
67

68
// Step 4: Create concrete Observers
69
public class PhoneApp implements Observer {
70
    @Override
71
    public void update(double temperature) {
72
        System.out.println("📱 Phone App: Temperature is " + temperature + "°C");
73
    }
74
}
75

76
public class Website implements Observer {
77
    @Override
78
    public void update(double temperature) {
79
        System.out.println("🌐 Website: Temperature is " + temperature + "°C");
80
    }
81
}
82

83
public class Billboard implements Observer {
84
    @Override
85
    public void update(double temperature) {
86
        System.out.println("📺 Billboard: Temperature is " + temperature + "°C");
87
    }
88
}
89

90
// Step 5: Use the pattern
91
public class Main {
92
    public static void main(String[] args) {
93
        // Create subject
94
        WeatherStation weatherStation = new WeatherStation();
95

96
        // Create observers
97
        PhoneApp phoneApp = new PhoneApp();
98
        Website website = new Website();
99
        Billboard billboard = new Billboard();
100

101
        // Subscribe observers
102
        weatherStation.attach(phoneApp);
103
        weatherStation.attach(website);
104
        weatherStation.attach(billboard);
105

106
        // Change temperature - all observers get notified automatically!
107
        weatherStation.setTemperature(25.0);
108

109
        // Unsubscribe one observer
110
        weatherStation.detach(website);
111

112
        // Change temperature again - only subscribed observers get notified
113
        weatherStation.setTemperature(30.0);
114

115
        // Add a new observer - no need to modify WeatherStation!
116
        class SmartWatch implements Observer {
117
            @Override
118
            public void update(double temperature) {
119
                System.out.println("⌚ Smart Watch: Temperature is " + temperature + "°C");
120
            }
121
        }
122

123
        SmartWatch smartWatch = new SmartWatch();
124
        weatherStation.attach(smartWatch);
125
        weatherStation.setTemperature(22.0);
126
    }
127
}

1
// Step 1: Define the Observer interface
2
interface Observer {
3
    /** Called when subject's state changes */
4
    update(temperature: number): void;
5
}
6

7
// Step 2: Define the Subject interface
8
interface Subject {
9
    /** Attach an observer */
10
    attach(observer: Observer): void;
11
    /** Detach an observer */
12
    detach(observer: Observer): void;
13
    /** Notify all observers */
14
    notify(): void;
15
}
16

17
// Step 3: Create concrete Subject
18
class WeatherStation implements Subject {
19
    /** Weather station - the subject being observed */
20
    private temperature: number = 0;
21
    private observers: Observer[] = [];  // List of observers
22

23
    attach(observer: Observer): void {
24
        /** Subscribe an observer */
25
        if (!this.observers.includes(observer)) {
26
            this.observers.push(observer);
27
            console.log(`✅ Observer attached: ${observer.constructor.name}`);
28
        }
29
    }
30

31
    detach(observer: Observer): void {
32
        /** Unsubscribe an observer */
33
        const index = this.observers.indexOf(observer);
34
        if (index > -1) {
35
            this.observers.splice(index, 1);
36
            console.log(`❌ Observer detached: ${observer.constructor.name}`);
37
        }
38
    }
39

40
    notify(): void {
41
        /** Notify all observers about temperature change */
42
        for (const observer of this.observers) {
43
            observer.update(this.temperature);
44
        }
45
    }
46

47
    setTemperature(temperature: number): void {
48
        /** Set temperature and notify all observers */
49
        this.temperature = temperature;
50
        console.log(`\n🌡️  Temperature changed to ${temperature}°C`);
51
        this.notify();  // Notify all observers!
52
    }
53

54
    getTemperature(): number {
55
        /** Get current temperature */
56
        return this.temperature;
57
    }
58
}
59

60
// Step 4: Create concrete Observers
61
class PhoneApp implements Observer {
62
    /** Phone app observer */
63
    update(temperature: number): void {
64
        console.log(`📱 Phone App: Temperature is ${temperature}°C`);
65
    }
66
}
67

68
class Website implements Observer {
69
    /** Website observer */
70
    update(temperature: number): void {
71
        console.log(`🌐 Website: Temperature is ${temperature}°C`);
72
    }
73
}
74

75
class Billboard implements Observer {
76
    /** Billboard observer */
77
    update(temperature: number): void {
78
        console.log(`📺 Billboard: Temperature is ${temperature}°C`);
79
    }
80
}
81

82
// Step 5: Use the pattern
83
function main(): void {
84
    // Create subject
85
    const weatherStation = new WeatherStation();
86

87
    // Create observers
88
    const phoneApp = new PhoneApp();
89
    const website = new Website();
90
    const billboard = new Billboard();
91

92
    // Subscribe observers
93
    weatherStation.attach(phoneApp);
94
    weatherStation.attach(website);
95
    weatherStation.attach(billboard);
96

97
    // Change temperature - all observers get notified automatically!
98
    weatherStation.setTemperature(25.0);
99

100
    // Unsubscribe one observer
101
    weatherStation.detach(website);
102

103
    // Change temperature again - only subscribed observers get notified
104
    weatherStation.setTemperature(30.0);
105

106
    // Add a new observer - no need to modify WeatherStation!
107
    class SmartWatch implements Observer {
108
        update(temperature: number): void {
109
            console.log(`⌚ Smart Watch: Temperature is ${temperature}°C`);
110
        }
111
    }
112

113
    const smartWatch = new SmartWatch();
114
    weatherStation.attach(smartWatch);
115
    weatherStation.setTemperature(22.0);
116
}
117

118
main();

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4
#include <string>
5

6
// Step 1: Define the Observer interface
7
class Observer {
8
public:
9
    virtual ~Observer() = default;
10
    /** Called when subject's state changes */
11
    virtual void update(double temperature) = 0;
12
    virtual std::string getName() const = 0;
13
};
14

15
// Step 2: Define the Subject interface
16
class Subject {
17
public:
18
    virtual ~Subject() = default;
19
    /** Attach an observer */
20
    virtual void attach(Observer* observer) = 0;
21
    /** Detach an observer */
22
    virtual void detach(Observer* observer) = 0;
23
    /** Notify all observers */
24
    virtual void notify() = 0;
25
};
26

27
// Step 3: Create concrete Subject
28
class WeatherStation : public Subject {
29
private:
30
    double temperature = 0;
31
    std::vector<Observer*> observers;  // List of observers
32

33
public:
34
    void attach(Observer* observer) override {
35
        /** Subscribe an observer */
36
        if (std::find(observers.begin(), observers.end(), observer) == observers.end()) {
37
            observers.push_back(observer);
38
            std::cout << "✅ Observer attached: " << observer->getName() << std::endl;
39
        }
40
    }
41

42
    void detach(Observer* observer) override {
43
        /** Unsubscribe an observer */
44
        auto it = std::find(observers.begin(), observers.end(), observer);
45
        if (it != observers.end()) {
46
            observers.erase(it);
47
            std::cout << "❌ Observer detached: " << observer->getName() << std::endl;
48
        }
49
    }
50

51
    void notify() override {
52
        /** Notify all observers about temperature change */
53
        for (Observer* observer : observers) {
54
            observer->update(temperature);
55
        }
56
    }
57

58
    void setTemperature(double temp) {
59
        /** Set temperature and notify all observers */
60
        temperature = temp;
61
        std::cout << "\n🌡️  Temperature changed to " << temp << "°C" << std::endl;
62
        notify();  // Notify all observers!
63
    }
64

65
    double getTemperature() const {
66
        /** Get current temperature */
67
        return temperature;
68
    }
69
};
70

71
// Step 4: Create concrete Observers
72
class PhoneApp : public Observer {
73
public:
74
    void update(double temperature) override {
75
        std::cout << "📱 Phone App: Temperature is " << temperature << "°C" << std::endl;
76
    }
77

78
    std::string getName() const override {
79
        return "PhoneApp";
80
    }
81
};
82

83
class Website : public Observer {
84
public:
85
    void update(double temperature) override {
86
        std::cout << "🌐 Website: Temperature is " << temperature << "°C" << std::endl;
87
    }
88

89
    std::string getName() const override {
90
        return "Website";
91
    }
92
};
93

94
class Billboard : public Observer {
95
public:
96
    void update(double temperature) override {
97
        std::cout << "📺 Billboard: Temperature is " << temperature << "°C" << std::endl;
98
    }
99

100
    std::string getName() const override {
101
        return "Billboard";
102
    }
103
};
104

105
class SmartWatch : public Observer {
106
public:
107
    void update(double temperature) override {
108
        std::cout << "⌚ Smart Watch: Temperature is " << temperature << "°C" << std::endl;
109
    }
110

111
    std::string getName() const override {
112
        return "SmartWatch";
113
    }
114
};
115

116
// Step 5: Use the pattern
117
int main() {
118
    // Create subject
119
    WeatherStation weatherStation;
120

121
    // Create observers
122
    PhoneApp phoneApp;
123
    Website website;
124
    Billboard billboard;
125

126
    // Subscribe observers
127
    weatherStation.attach(&phoneApp);
128
    weatherStation.attach(&website);
129
    weatherStation.attach(&billboard);
130

131
    // Change temperature - all observers get notified automatically!
132
    weatherStation.setTemperature(25.0);
133

134
    // Unsubscribe one observer
135
    weatherStation.detach(&website);
136

137
    // Change temperature again - only subscribed observers get notified
138
    weatherStation.setTemperature(30.0);
139

140
    // Add a new observer - no need to modify WeatherStation!
141
    SmartWatch smartWatch;
142
    weatherStation.attach(&smartWatch);
143
    weatherStation.setTemperature(22.0);
144

145
    return 0;
146
}

1
using System;
2
using System.Collections.Generic;
3

4
// Step 1: Define the Observer interface
5
public interface IObserver
6
{
7
    /** Called when subject's state changes */
8
    void Update(double temperature);
9
}
10

11
// Step 2: Define the Subject interface
12
public interface ISubject
13
{
14
    /** Attach an observer */
15
    void Attach(IObserver observer);
16
    /** Detach an observer */
17
    void Detach(IObserver observer);
18
    /** Notify all observers */
19
    void Notify();
20
}
21

22
// Step 3: Create concrete Subject
23
public class WeatherStation : ISubject
24
{
25
    /** Weather station - the subject being observed */
26
    private double temperature = 0;
27
    private List<IObserver> observers = new List<IObserver>();  // List of observers
28

29
    public void Attach(IObserver observer)
30
    {
31
        /** Subscribe an observer */
32
        if (!observers.Contains(observer))
33
        {
34
            observers.Add(observer);
35
            Console.WriteLine($"✅ Observer attached: {observer.GetType().Name}");
36
        }
37
    }
38

39
    public void Detach(IObserver observer)
40
    {
41
        /** Unsubscribe an observer */
42
        if (observers.Remove(observer))
43
        {
44
            Console.WriteLine($"❌ Observer detached: {observer.GetType().Name}");
45
        }
46
    }
47

48
    public void Notify()
49
    {
50
        /** Notify all observers about temperature change */
51
        foreach (var observer in observers)
52
        {
53
            observer.Update(temperature);
54
        }
55
    }
56

57
    public void SetTemperature(double temp)
58
    {
59
        /** Set temperature and notify all observers */
60
        temperature = temp;
61
        Console.WriteLine($"\n🌡️  Temperature changed to {temp}°C");
62
        Notify();  // Notify all observers!
63
    }
64

65
    public double GetTemperature()
66
    {
67
        /** Get current temperature */
68
        return temperature;
69
    }
70
}
71

72
// Step 4: Create concrete Observers
73
public class PhoneApp : IObserver
74
{
75
    /** Phone app observer */
76
    public void Update(double temperature)
77
    {
78
        Console.WriteLine($"📱 Phone App: Temperature is {temperature}°C");
79
    }
80
}
81

82
public class Website : IObserver
83
{
84
    /** Website observer */
85
    public void Update(double temperature)
86
    {
87
        Console.WriteLine($"🌐 Website: Temperature is {temperature}°C");
88
    }
89
}
90

91
public class Billboard : IObserver
92
{
93
    /** Billboard observer */
94
    public void Update(double temperature)
95
    {
96
        Console.WriteLine($"📺 Billboard: Temperature is {temperature}°C");
97
    }
98
}
99

100
public class SmartWatch : IObserver
101
{
102
    public void Update(double temperature)
103
    {
104
        Console.WriteLine($"⌚ Smart Watch: Temperature is {temperature}°C");
105
    }
106
}
107

108
// Step 5: Use the pattern
109
class Program
110
{
111
    static void Main()
112
    {
113
        // Create subject
114
        WeatherStation weatherStation = new WeatherStation();
115

116
        // Create observers
117
        PhoneApp phoneApp = new PhoneApp();
118
        Website website = new Website();
119
        Billboard billboard = new Billboard();
120

121
        // Subscribe observers
122
        weatherStation.Attach(phoneApp);
123
        weatherStation.Attach(website);
124
        weatherStation.Attach(billboard);
125

126
        // Change temperature - all observers get notified automatically!
127
        weatherStation.SetTemperature(25.0);
128

129
        // Unsubscribe one observer
130
        weatherStation.Detach(website);
131

132
        // Change temperature again - only subscribed observers get notified
133
        weatherStation.SetTemperature(30.0);
134

135
        // Add a new observer - no need to modify WeatherStation!
136
        SmartWatch smartWatch = new SmartWatch();
137
        weatherStation.Attach(smartWatch);
138
        weatherStation.SetTemperature(22.0);
139
    }
140
}

1
package main
2

3
import "fmt"
4

5
// Step 1: Observer interface
6
type Observer interface {
7
  Update(temperature float64)
8
}
9

10
// Step 2: Subject interface
11
type Subject interface {
12
  Attach(Observer)
13
  Detach(Observer)
14
  Notify()
15
}
16

17
// Step 3: Concrete Subject
18
type WeatherStation struct {
19
  observers   []Observer
20
  temperature float64
21
}
22

23
func (ws *WeatherStation) Attach(o Observer) {
24
  ws.observers = append(ws.observers, o)
25
  fmt.Printf("✅ Observer attached\n")
26
}
27

28
func (ws *WeatherStation) Detach(o Observer) {
29
  for i, obs := range ws.observers {
30
    if obs == o {
31
      ws.observers = append(ws.observers[:i], ws.observers[i+1:]...)
32
      break
33
    }
34
  }
35
}
36

37
func (ws *WeatherStation) Notify() {
38
  for _, o := range ws.observers {
39
    o.Update(ws.temperature)
40
  }
41
}
42

43
func (ws *WeatherStation) SetTemperature(temp float64) {
44
  ws.temperature = temp
45
  fmt.Printf("\n🌡️  Temperature changed to %.1f°C\n", temp)
46
  ws.Notify()
47
}
48

49
// Step 4: Concrete Observers
50
type PhoneApp struct{}
51
type Website struct{}
52
type Billboard struct{}
53
type SmartWatch struct{}
54

55
func (p *PhoneApp) Update(t float64)   { fmt.Printf("📱 Phone App: Temperature is %.1f°C\n", t) }
56
func (w *Website) Update(t float64)    { fmt.Printf("🌐 Website: Temperature is %.1f°C\n", t) }
57
func (b *Billboard) Update(t float64)  { fmt.Printf("📺 Billboard: Temperature is %.1f°C\n", t) }
58
func (s *SmartWatch) Update(t float64) { fmt.Printf("⌚ Smart Watch: Temperature is %.1f°C\n", t) }
59

60
func main() {
61
  ws := &WeatherStation{}
62
  phoneApp := &PhoneApp{}
63
  website := &Website{}
64
  billboard := &Billboard{}
65

66
  ws.Attach(phoneApp)
67
  ws.Attach(website)
68
  ws.Attach(billboard)
69
  ws.SetTemperature(25.0)
70

71
  ws.Detach(website)
72
  ws.SetTemperature(30.0)
73

74
  ws.Attach(&SmartWatch{})
75
  ws.SetTemperature(22.0)
76
}

1
trait Observer {
2
    fn update(&self, event: &str);
3
}
4

5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15

16
impl Subject {
17
    fn attach(&mut self, observer: Box<dyn Observer>) {
18
        self.observers.push(observer);
19
    }
20
    fn notify(&self, event: &str) {
21
        for observer in &self.observers {
22
            observer.update(event);
23
        }
24
    }
25
}

1
✅ Observer attached
2
✅ Observer attached: Website
3
✅ Observer attached: Billboard
4

5
🌡️  Temperature changed to 25.0°C
6
📱 Phone App: Temperature is 25.0°C
7
🌐 Website: Temperature is 25.0°C
8
📺 Billboard: Temperature is 25.0°C
9
❌ Observer detached: Website
10

11
🌡️  Temperature changed to 30.0°C
12
📱 Phone App: Temperature is 30.0°C
13
📺 Billboard: Temperature is 30.0°C
14
✅ Observer attached: SmartWatch
15

16
🌡️  Temperature changed to 22.0°C
17
📱 Phone App: Temperature is 22.0°C
18
📺 Billboard: Temperature is 22.0°C
19
⌚ Smart Watch: Temperature is 22.0°C

Visual Representation

Observer pattern overview: WeatherStation subject notifies PhoneApp, Website and Billboard through a common Observer interface with update

Interaction Flow

Here’s how the Observer Pattern works in practice - showing the sequence of notifications:

Observer sequence diagram: PhoneApp, Website and Billboard attach to WeatherStation, then set_temperature triggers update(25.0) on each

Real-World Software Example: E-Commerce Order System

Now let’s see a realistic software example - an e-commerce system where multiple services need to be notified when an order is placed.

The Problem

You’re building an e-commerce system. When an order is placed, you need to:

Send confirmation email
Update inventory
Process payment
Send notification to warehouse
Update analytics

Without Observer Pattern:

💡 Tip: Click dropdown to switch between languages

1
# ❌ Without Observer Pattern
2

3
class Order:
4
    def __init__(self, order_id: str, items: list, total: float):
5
        self.order_id = order_id
6
        self.items = items
7
        self.total = total
8
        self.status = "pending"
9
        # Problem: Order knows about all services!
10
        self.email_service = None
11
        self.inventory_service = None
12
        self.payment_service = None
13
        self.warehouse_service = None
14
        self.analytics_service = None
15

16
    def place_order(self):
17
        """Place order and notify all services"""
18
        self.status = "placed"
19

20
        # Problem: Manual notification to each service
21
        if self.email_service:
22
            self.email_service.send_confirmation(self.order_id)
23

24
        if self.inventory_service:
25
            self.inventory_service.update_inventory(self.items)
26

27
        if self.payment_service:
28
            self.payment_service.process_payment(self.order_id, self.total)
29

30
        if self.warehouse_service:
31
            self.warehouse_service.notify_warehouse(self.order_id, self.items)
32

33
        if self.analytics_service:
34
            self.analytics_service.record_order(self.order_id, self.total)
35

36
        # Problems:
37
        # - Order class knows about all services
38
        # - Need to modify place_order() to add new services
39
        # - Hard to test - need to mock all services
40
        # - Violates Single Responsibility Principle
41

42
class EmailService:
43
    def send_confirmation(self, order_id: str):
44
        print(f"📧 Email sent: Order {order_id} confirmation")
45

46
class InventoryService:
47
    def update_inventory(self, items: list):
48
        print(f"📦 Inventory updated for {len(items)} items")
49

50
class PaymentService:
51
    def process_payment(self, order_id: str, amount: float):
52
        print(f"💳 Payment processed: ${amount} for order {order_id}")
53

54
class WarehouseService:
55
    def notify_warehouse(self, order_id: str, items: list):
56
        print(f"🏭 Warehouse notified: Order {order_id} with {len(items)} items")
57

58
class AnalyticsService:
59
    def record_order(self, order_id: str, amount: float):
60
        print(f"📊 Analytics: Order {order_id} recorded, amount: ${amount}")
61

62
# Usage
63
order = Order("ORD-123", ["item1", "item2"], 99.99)
64
order.email_service = EmailService()
65
order.inventory_service = InventoryService()
66
order.payment_service = PaymentService()
67
order.warehouse_service = WarehouseService()
68
order.analytics_service = AnalyticsService()
69

70
order.place_order()

1
import java.util.List;
2

3
// ❌ Without Observer Pattern
4

5
public class Order {
6
    private String orderId;
7
    private List<String> items;
8
    private double total;
9
    private String status = "pending";
10
    // Problem: Order knows about all services!
11
    private EmailService emailService = null;
12
    private InventoryService inventoryService = null;
13
    private PaymentService paymentService = null;
14
    private WarehouseService warehouseService = null;
15
    private AnalyticsService analyticsService = null;
16

17
    public Order(String orderId, List<String> items, double total) {
18
        this.orderId = orderId;
19
        this.items = items;
20
        this.total = total;
21
    }
22

23
    public void placeOrder() {
24
        // Place order and notify all services
25
        this.status = "placed";
26

27
        // Problem: Manual notification to each service
28
        if (emailService != null) {
29
            emailService.sendConfirmation(orderId);
30
        }
31

32
        if (inventoryService != null) {
33
            inventoryService.updateInventory(items);
34
        }
35

36
        if (paymentService != null) {
37
            paymentService.processPayment(orderId, total);
38
        }
39

40
        if (warehouseService != null) {
41
            warehouseService.notifyWarehouse(orderId, items);
42
        }
43

44
        if (analyticsService != null) {
45
            analyticsService.recordOrder(orderId, total);
46
        }
47

48
        // Problems:
49
        // - Order class knows about all services
50
        // - Need to modify placeOrder() to add new services
51
        // - Hard to test - need to mock all services
52
        // - Violates Single Responsibility Principle
53
    }
54

55
    // Setters
56
    public void setEmailService(EmailService emailService) {
57
        this.emailService = emailService;
58
    }
59

60
    public void setInventoryService(InventoryService inventoryService) {
61
        this.inventoryService = inventoryService;
62
    }
63

64
    public void setPaymentService(PaymentService paymentService) {
65
        this.paymentService = paymentService;
66
    }
67

68
    public void setWarehouseService(WarehouseService warehouseService) {
69
        this.warehouseService = warehouseService;
70
    }
71

72
    public void setAnalyticsService(AnalyticsService analyticsService) {
73
        this.analyticsService = analyticsService;
74
    }
75
}
76

77
public class EmailService {
78
    public void sendConfirmation(String orderId) {
79
        System.out.println("📧 Email sent: Order " + orderId + " confirmation");
80
    }
81
}
82

83
public class InventoryService {
84
    public void updateInventory(List<String> items) {
85
        System.out.println("📦 Inventory updated for " + items.size() + " items");
86
    }
87
}
88

89
public class PaymentService {
90
    public void processPayment(String orderId, double amount) {
91
        System.out.println("💳 Payment processed: $" + amount + " for order " + orderId);
92
    }
93
}
94

95
public class WarehouseService {
96
    public void notifyWarehouse(String orderId, List<String> items) {
97
        System.out.println("🏭 Warehouse notified: Order " + orderId + " with " + items.size() + " items");
98
    }
99
}
100

101
public class AnalyticsService {
102
    public void recordOrder(String orderId, double amount) {
103
        System.out.println("📊 Analytics: Order " + orderId + " recorded, amount: $" + amount);
104
    }
105
}
106

107
// Usage
108
public class Main {
109
    public static void main(String[] args) {
110
        Order order = new Order("ORD-123", List.of("item1", "item2"), 99.99);
111
        order.setEmailService(new EmailService());
112
        order.setInventoryService(new InventoryService());
113
        order.setPaymentService(new PaymentService());
114
        order.setWarehouseService(new WarehouseService());
115
        order.setAnalyticsService(new AnalyticsService());
116

117
        order.placeOrder();
118
    }
119
}

1
// ❌ Without Observer Pattern
2

3
class Order {
4
    private orderId: string;
5
    private items: string[];
6
    private total: number;
7
    private status: string = "pending";
8
    // Problem: Order knows about all services!
9
    private emailService: EmailService | null = null;
10
    private inventoryService: InventoryService | null = null;
11
    private paymentService: PaymentService | null = null;
12
    private warehouseService: WarehouseService | null = null;
13
    private analyticsService: AnalyticsService | null = null;
14

15
    constructor(orderId: string, items: string[], total: number) {
16
        this.orderId = orderId;
17
        this.items = items;
18
        this.total = total;
19
    }
20

21
    placeOrder(): void {
22
        /** Place order and notify all services */
23
        this.status = "placed";
24

25
        // Problem: Manual notification to each service
26
        if (this.emailService) {
27
            this.emailService.sendConfirmation(this.orderId);
28
        }
29

30
        if (this.inventoryService) {
31
            this.inventoryService.updateInventory(this.items);
32
        }
33

34
        if (this.paymentService) {
35
            this.paymentService.processPayment(this.orderId, this.total);
36
        }
37

38
        if (this.warehouseService) {
39
            this.warehouseService.notifyWarehouse(this.orderId, this.items);
40
        }
41

42
        if (this.analyticsService) {
43
            this.analyticsService.recordOrder(this.orderId, this.total);
44
        }
45
    }
46

47
    setEmailService(service: EmailService): void {
48
        this.emailService = service;
49
    }
50

51
    setInventoryService(service: InventoryService): void {
52
        this.inventoryService = service;
53
    }
54

55
    setPaymentService(service: PaymentService): void {
56
        this.paymentService = service;
57
    }
58

59
    setWarehouseService(service: WarehouseService): void {
60
        this.warehouseService = service;
61
    }
62

63
    setAnalyticsService(service: AnalyticsService): void {
64
        this.analyticsService = service;
65
    }
66
}
67

68
class EmailService {
69
    sendConfirmation(orderId: string): void {
70
        console.log(`📧 Email sent: Order ${orderId} confirmation`);
71
    }
72
}
73

74
class InventoryService {
75
    updateInventory(items: string[]): void {
76
        console.log(`📦 Inventory updated for ${items.length} items`);
77
    }
78
}
79

80
class PaymentService {
81
    processPayment(orderId: string, amount: number): void {
82
        console.log(`💳 Payment processed: $${amount} for order ${orderId}`);
83
    }
84
}
85

86
class WarehouseService {
87
    notifyWarehouse(orderId: string, items: string[]): void {
88
        console.log(`🏭 Warehouse notified: Order ${orderId} with ${items.length} items`);
89
    }
90
}
91

92
class AnalyticsService {
93
    recordOrder(orderId: string, amount: number): void {
94
        console.log(`📊 Analytics: Order ${orderId} recorded, amount: $${amount}`);
95
    }
96
}
97

98
// Usage
99
const order = new Order("ORD-123", ["item1", "item2"], 99.99);
100
order.setEmailService(new EmailService());
101
order.setInventoryService(new InventoryService());
102
order.setPaymentService(new PaymentService());
103
order.setWarehouseService(new WarehouseService());
104
order.setAnalyticsService(new AnalyticsService());
105

106
order.placeOrder();

1
// ❌ Without Observer Pattern
2

3
#include <iostream>
4
#include <string>
5
#include <vector>
6

7
class EmailService;
8
class InventoryService;
9
class PaymentService;
10
class WarehouseService;
11
class AnalyticsService;
12

13
class Order {
14
private:
15
    std::string orderId;
16
    std::vector<std::string> items;
17
    double total;
18
    std::string status = "pending";
19
    // Problem: Order knows about all services!
20
    EmailService* emailService = nullptr;
21
    InventoryService* inventoryService = nullptr;
22
    PaymentService* paymentService = nullptr;
23
    WarehouseService* warehouseService = nullptr;
24
    AnalyticsService* analyticsService = nullptr;
25

26
public:
27
    Order(const std::string& orderId, const std::vector<std::string>& items, double total)
28
        : orderId(orderId), items(items), total(total) {}
29

30
    void placeOrder();
31

32
    void setEmailService(EmailService* service) { emailService = service; }
33
    void setInventoryService(InventoryService* service) { inventoryService = service; }
34
    void setPaymentService(PaymentService* service) { paymentService = service; }
35
    void setWarehouseService(WarehouseService* service) { warehouseService = service; }
36
    void setAnalyticsService(AnalyticsService* service) { analyticsService = service; }
37

38
    const std::string& getOrderId() const { return orderId; }
39
    const std::vector<std::string>& getItems() const { return items; }
40
    double getTotal() const { return total; }
41
};
42

43
class EmailService {
44
public:
45
    void sendConfirmation(const std::string& orderId) {
46
        std::cout << "📧 Email sent: Order " << orderId << " confirmation" << std::endl;
47
    }
48
};
49

50
class InventoryService {
51
public:
52
    void updateInventory(const std::vector<std::string>& items) {
53
        std::cout << "📦 Inventory updated for " << items.size() << " items" << std::endl;
54
    }
55
};
56

57
class PaymentService {
58
public:
59
    void processPayment(const std::string& orderId, double amount) {
60
        std::cout << "💳 Payment processed: $" << amount << " for order " << orderId << std::endl;
61
    }
62
};
63

64
class WarehouseService {
65
public:
66
    void notifyWarehouse(const std::string& orderId, const std::vector<std::string>& items) {
67
        std::cout << "🏭 Warehouse notified: Order " << orderId << " with " << items.size() << " items" << std::endl;
68
    }
69
};
70

71
class AnalyticsService {
72
public:
73
    void recordOrder(const std::string& orderId, double amount) {
74
        std::cout << "📊 Analytics: Order " << orderId << " recorded, amount: $" << amount << std::endl;
75
    }
76
};
77

78
void Order::placeOrder() {
79
    status = "placed";
80

81
    // Problem: Manual notification to each service
82
    if (emailService) {
83
        emailService->sendConfirmation(orderId);
84
    }
85

86
    if (inventoryService) {
87
        inventoryService->updateInventory(items);
88
    }
89

90
    if (paymentService) {
91
        paymentService->processPayment(orderId, total);
92
    }
93

94
    if (warehouseService) {
95
        warehouseService->notifyWarehouse(orderId, items);
96
    }
97

98
    if (analyticsService) {
99
        analyticsService->recordOrder(orderId, total);
100
    }
101
}
102

103
// Usage
104
int main() {
105
    Order order("ORD-123", {"item1", "item2"}, 99.99);
106

107
    EmailService emailService;
108
    InventoryService inventoryService;
109
    PaymentService paymentService;
110
    WarehouseService warehouseService;
111
    AnalyticsService analyticsService;
112

113
    order.setEmailService(&emailService);
114
    order.setInventoryService(&inventoryService);
115
    order.setPaymentService(&paymentService);
116
    order.setWarehouseService(&warehouseService);
117
    order.setAnalyticsService(&analyticsService);
118

119
    order.placeOrder();
120

121
    return 0;
122
}

1
// ❌ Without Observer Pattern
2

3
using System;
4
using System.Collections.Generic;
5

6
public class Order
7
{
8
    private string orderId;
9
    private List<string> items;
10
    private double total;
11
    private string status = "pending";
12
    // Problem: Order knows about all services!
13
    private EmailService emailService = null;
14
    private InventoryService inventoryService = null;
15
    private PaymentService paymentService = null;
16
    private WarehouseService warehouseService = null;
17
    private AnalyticsService analyticsService = null;
18

19
    public Order(string orderId, List<string> items, double total)
20
    {
21
        this.orderId = orderId;
22
        this.items = items;
23
        this.total = total;
24
    }
25

26
    public void PlaceOrder()
27
    {
28
        /** Place order and notify all services */
29
        status = "placed";
30

31
        // Problem: Manual notification to each service
32
        if (emailService != null)
33
        {
34
            emailService.SendConfirmation(orderId);
35
        }
36

37
        if (inventoryService != null)
38
        {
39
            inventoryService.UpdateInventory(items);
40
        }
41

42
        if (paymentService != null)
43
        {
44
            paymentService.ProcessPayment(orderId, total);
45
        }
46

47
        if (warehouseService != null)
48
        {
49
            warehouseService.NotifyWarehouse(orderId, items);
50
        }
51

52
        if (analyticsService != null)
53
        {
54
            analyticsService.RecordOrder(orderId, total);
55
        }
56
    }
57

58
    public void SetEmailService(EmailService service) { emailService = service; }
59
    public void SetInventoryService(InventoryService service) { inventoryService = service; }
60
    public void SetPaymentService(PaymentService service) { paymentService = service; }
61
    public void SetWarehouseService(WarehouseService service) { warehouseService = service; }
62
    public void SetAnalyticsService(AnalyticsService service) { analyticsService = service; }
63
}
64

65
public class EmailService
66
{
67
    public void SendConfirmation(string orderId)
68
    {
69
        Console.WriteLine($"📧 Email sent: Order {orderId} confirmation");
70
    }
71
}
72

73
public class InventoryService
74
{
75
    public void UpdateInventory(List<string> items)
76
    {
77
        Console.WriteLine($"📦 Inventory updated for {items.Count} items");
78
    }
79
}
80

81
public class PaymentService
82
{
83
    public void ProcessPayment(string orderId, double amount)
84
    {
85
        Console.WriteLine($"💳 Payment processed: ${amount} for order {orderId}");
86
    }
87
}
88

89
public class WarehouseService
90
{
91
    public void NotifyWarehouse(string orderId, List<string> items)
92
    {
93
        Console.WriteLine($"🏭 Warehouse notified: Order {orderId} with {items.Count} items");
94
    }
95
}
96

97
public class AnalyticsService
98
{
99
    public void RecordOrder(string orderId, double amount)
100
    {
101
        Console.WriteLine($"📊 Analytics: Order {orderId} recorded, amount: ${amount}");
102
    }
103
}
104

105
// Usage
106
class Program
107
{
108
    static void Main()
109
    {
110
        Order order = new Order("ORD-123", new List<string> { "item1", "item2" }, 99.99);
111
        order.SetEmailService(new EmailService());
112
        order.SetInventoryService(new InventoryService());
113
        order.SetPaymentService(new PaymentService());
114
        order.SetWarehouseService(new WarehouseService());
115
        order.SetAnalyticsService(new AnalyticsService());
116

117
        order.PlaceOrder();
118
    }
119
}

1
package main
2

3
import "fmt"
4

5
// ❌ Without Observer Pattern - Order knows about all services!
6

7
type EmailService struct{}
8
type InventoryService struct{}
9
type PaymentService struct{}
10

11
func (e *EmailService) SendConfirmation(id string)       { fmt.Printf("📧 Email sent: Order %s confirmation\n", id) }
12
func (i *InventoryService) UpdateInventory(items int)    { fmt.Printf("📦 Inventory updated for %d items\n", items) }
13
func (p *PaymentService) ProcessPayment(id string, amt float64) { fmt.Printf("💳 Payment processed: $%.2f for order %s\n", amt, id) }
14

15
type Order struct {
16
  orderId  string
17
  items    []string
18
  total    float64
19
  email    *EmailService
20
  inventory *InventoryService
21
  payment  *PaymentService
22
}
23

24
func (o *Order) PlaceOrder() {
25
  if o.email != nil { o.email.SendConfirmation(o.orderId) }
26
  if o.inventory != nil { o.inventory.UpdateInventory(len(o.items)) }
27
  if o.payment != nil { o.payment.ProcessPayment(o.orderId, o.total) }
28
}
29

30
func main() {
31
  order := &Order{orderId: "ORD-123", items: []string{"item1", "item2"}, total: 99.99}
32
  order.email = &EmailService{}
33
  order.inventory = &InventoryService{}
34
  order.payment = &PaymentService{}
35
  order.PlaceOrder()
36
}

1
struct OrderService;
2

3
impl OrderService {
4
    fn place_order(&self, order_id: u32) {
5
        println!("Order {} placed", order_id);
6
        println!("Sending email");
7
        println!("Updating analytics");
8
        println!("Notifying warehouse");
9
    }
10
}

1
📧 Email sent: Order ORD-123 confirmation
2
📦 Inventory updated for 2 items
3
💳 Payment processed: $99.99 for order ORD-123
4
🏭 Warehouse notified: Order ORD-123 with 2 items
5
📊 Analytics: Order ORD-123 recorded, amount: $99.99

Problems:

Order class knows about all services (tight coupling)
Need to modify place_order() to add new services
Hard to test - need to mock all services
Violates Single Responsibility Principle
Can’t easily add/remove services at runtime

The Solution: Observer Pattern

Class Structure

Observer pattern for order processing: Order subject notifies Email, Inventory, Payment, Warehouse and Analytics services when an order is placed

💡 Tip: Click dropdown to switch between languages

1
from abc import ABC, abstractmethod
2
from typing import List, Dict, Any
3
from dataclasses import dataclass
4

5
# Step 1: Define the Observer interface
6
class OrderObserver(ABC):
7
    """Interface for order observers"""
8

9
    @abstractmethod
10
    def on_order_placed(self, order_data: Dict[str, Any]) -> None:
11
        """Called when an order is placed"""
12
        pass
13

14
# Step 2: Define the Subject interface
15
class OrderSubject(ABC):
16
    """Interface for order subjects"""
17

18
    @abstractmethod
19
    def attach(self, observer: OrderObserver) -> None:
20
        """Attach an observer"""
21
        pass
22

23
    @abstractmethod
24
    def detach(self, observer: OrderObserver) -> None:
25
        """Detach an observer"""
26
        pass
27

28
    @abstractmethod
29
    def notify_order_placed(self, order_data: Dict[str, Any]) -> None:
30
        """Notify all observers about order placement"""
31
        pass
32

33
# Step 3: Create concrete Subject
34
@dataclass
35
class Order:
36
    """Order data class"""
37
    order_id: str
38
    items: List[str]
39
    total: float
40
    status: str = "pending"
41

42
class OrderService(OrderSubject):
43
    """Order service - the subject being observed"""
44

45
    def __init__(self):
46
        self._observers: List[OrderObserver] = []
47

48
    def attach(self, observer: OrderObserver) -> None:
49
        """Subscribe an observer"""
50
        if observer not in self._observers:
51
            self._observers.append(observer)
52
            print(f"✅ Service subscribed: {observer.__class__.__name__}")
53

54
    def detach(self, observer: OrderObserver) -> None:
55
        """Unsubscribe an observer"""
56
        if observer in self._observers:
57
            self._observers.remove(observer)
58
            print(f"❌ Service unsubscribed: {observer.__class__.__name__}")
59

60
    def notify_order_placed(self, order_data: Dict[str, Any]) -> None:
61
        """Notify all observers about order placement"""
62
        for observer in self._observers:
63
            observer.on_order_placed(order_data)
64

65
    def place_order(self, order: Order) -> None:
66
        """Place an order and notify all observers"""
67
        order.status = "placed"
68
        print(f"\n🛒 Order {order.order_id} placed!")
69

70
        order_data = {
71
            "order_id": order.order_id,
72
            "items": order.items,
73
            "total": order.total,
74
            "status": order.status
75
        }
76

77
        # Notify all observers automatically!
78
        self.notify_order_placed(order_data)
79

80
# Step 4: Create concrete Observers
81
class EmailService(OrderObserver):
82
    """Email service observer"""
83

84
    def on_order_placed(self, order_data: Dict[str, Any]) -> None:
85
        order_id = order_data["order_id"]
86
        print(f"📧 Email sent: Order {order_id} confirmation")
87

88
class InventoryService(OrderObserver):
89
    """Inventory service observer"""
90

91
    def on_order_placed(self, order_data: Dict[str, Any]) -> None:
92
        items = order_data["items"]
93
        print(f"📦 Inventory updated for {len(items)} items")
94

95
class PaymentService(OrderObserver):
96
    """Payment service observer"""
97

98
    def on_order_placed(self, order_data: Dict[str, Any]) -> None:
99
        order_id = order_data["order_id"]
100
        amount = order_data["total"]
101
        print(f"💳 Payment processed: ${amount} for order {order_id}")
102

103
class WarehouseService(OrderObserver):
104
    """Warehouse service observer"""
105

106
    def on_order_placed(self, order_data: Dict[str, Any]) -> None:
107
        order_id = order_data["order_id"]
108
        items = order_data["items"]
109
        print(f"🏭 Warehouse notified: Order {order_id} with {len(items)} items")
110

111
class AnalyticsService(OrderObserver):
112
    """Analytics service observer"""
113

114
    def on_order_placed(self, order_data: Dict[str, Any]) -> None:
115
        order_id = order_data["order_id"]
116
        amount = order_data["total"]
117
        print(f"📊 Analytics: Order {order_id} recorded, amount: ${amount}")
118

119
# Step 5: Use the pattern
120
def main():
121
    # Create order service
122
    order_service = OrderService()
123

124
    # Create services (observers)
125
    email_service = EmailService()
126
    inventory_service = InventoryService()
127
    payment_service = PaymentService()
128
    warehouse_service = WarehouseService()
129
    analytics_service = AnalyticsService()
130

131
    # Subscribe all services
132
    order_service.attach(email_service)
133
    order_service.attach(inventory_service)
134
    order_service.attach(payment_service)
135
    order_service.attach(warehouse_service)
136
    order_service.attach(analytics_service)
137

138
    # Place an order - all services get notified automatically!
139
    order = Order("ORD-123", ["Laptop", "Mouse"], 999.99)
140
    order_service.place_order(order)
141

142
    # Add a new service - no need to modify OrderService!
143
    class NotificationService(OrderObserver):
144
        def on_order_placed(self, order_data: Dict[str, Any]) -> None:
145
            order_id = order_data["order_id"]
146
            print(f"🔔 Push notification sent: Order {order_id} placed")
147

148
    notification_service = NotificationService()
149
    order_service.attach(notification_service)
150

151
    # Place another order - new service also gets notified!
152
    order2 = Order("ORD-124", ["Keyboard"], 49.99)
153
    order_service.place_order(order2)
154

155
if __name__ == "__main__":
156
    main()

1
import java.util.ArrayList;
2
import java.util.HashMap;
3
import java.util.List;
4
import java.util.Map;
5

6
// Step 1: Define the Observer interface
7
public interface OrderObserver {
8
    /**
9
     * Called when an order is placed
10
     */
11
    void onOrderPlaced(Map<String, Object> orderData);
12
}
13

14
// Step 2: Define the Subject interface
15
public interface OrderSubject {
16
    /**
17
     * Attach an observer
18
     */
19
    void attach(OrderObserver observer);
20

21
    /**
22
     * Detach an observer
23
     */
24
    void detach(OrderObserver observer);
25

26
    /**
27
     * Notify all observers about order placement
28
     */
29
    void notifyOrderPlaced(Map<String, Object> orderData);
30
}
31

32
// Step 3: Create concrete Subject
33
public class Order {
34
    private String orderId;
35
    private List<String> items;
36
    private double total;
37
    private String status = "pending";
38

39
    public Order(String orderId, List<String> items, double total) {
40
        this.orderId = orderId;
41
        this.items = items;
42
        this.total = total;
43
    }
44

45
    // Getters and setters
46
    public String getOrderId() { return orderId; }
47
    public List<String> getItems() { return items; }
48
    public double getTotal() { return total; }
49
    public String getStatus() { return status; }
50
    public void setStatus(String status) { this.status = status; }
51
}
52

53
public class OrderService implements OrderSubject {
54
    private List<OrderObserver> observers = new ArrayList<>();
55

56
    @Override
57
    public void attach(OrderObserver observer) {
58
        if (!observers.contains(observer)) {
59
            observers.add(observer);
60
            System.out.println("✅ Service subscribed: " + observer.getClass().getSimpleName());
61
        }
62
    }
63

64
    @Override
65
    public void detach(OrderObserver observer) {
66
        if (observers.remove(observer)) {
67
            System.out.println("❌ Service unsubscribed: " + observer.getClass().getSimpleName());
68
        }
69
    }
70

71
    @Override
72
    public void notifyOrderPlaced(Map<String, Object> orderData) {
73
        for (OrderObserver observer : observers) {
74
            observer.onOrderPlaced(orderData);
75
        }
76
    }
77

78
    public void placeOrder(Order order) {
79
        order.setStatus("placed");
80
        System.out.println("\n🛒 Order " + order.getOrderId() + " placed!");
81

82
        Map<String, Object> orderData = new HashMap<>();
83
        orderData.put("order_id", order.getOrderId());
84
        orderData.put("items", order.getItems());
85
        orderData.put("total", order.getTotal());
86
        orderData.put("status", order.getStatus());
87

88
        // Notify all observers automatically!
89
        notifyOrderPlaced(orderData);
90
    }
91
}
92

93
// Step 4: Create concrete Observers
94
public class EmailService implements OrderObserver {
95
    @Override
96
    public void onOrderPlaced(Map<String, Object> orderData) {
97
        String orderId = (String) orderData.get("order_id");
98
        System.out.println("📧 Email sent: Order " + orderId + " confirmation");
99
    }
100
}
101

102
public class InventoryService implements OrderObserver {
103
    @Override
104
    public void onOrderPlaced(Map<String, Object> orderData) {
105
        @SuppressWarnings("unchecked")
106
        List<String> items = (List<String>) orderData.get("items");
107
        System.out.println("📦 Inventory updated for " + items.size() + " items");
108
    }
109
}
110

111
public class PaymentService implements OrderObserver {
112
    @Override
113
    public void onOrderPlaced(Map<String, Object> orderData) {
114
        String orderId = (String) orderData.get("order_id");
115
        double amount = (Double) orderData.get("total");
116
        System.out.println("💳 Payment processed: $" + amount + " for order " + orderId);
117
    }
118
}
119

120
public class WarehouseService implements OrderObserver {
121
    @Override
122
    public void onOrderPlaced(Map<String, Object> orderData) {
123
        String orderId = (String) orderData.get("order_id");
124
        @SuppressWarnings("unchecked")
125
        List<String> items = (List<String>) orderData.get("items");
126
        System.out.println("🏭 Warehouse notified: Order " + orderId + " with " + items.size() + " items");
127
    }
128
}
129

130
public class AnalyticsService implements OrderObserver {
131
    @Override
132
    public void onOrderPlaced(Map<String, Object> orderData) {
133
        String orderId = (String) orderData.get("order_id");
134
        double amount = (Double) orderData.get("total");
135
        System.out.println("📊 Analytics: Order " + orderId + " recorded, amount: $" + amount);
136
    }
137
}
138

139
// Step 5: Use the pattern
140
public class Main {
141
    public static void main(String[] args) {
142
        // Create order service
143
        OrderService orderService = new OrderService();
144

145
        // Create services (observers)
146
        EmailService emailService = new EmailService();
147
        InventoryService inventoryService = new InventoryService();
148
        PaymentService paymentService = new PaymentService();
149
        WarehouseService warehouseService = new WarehouseService();
150
        AnalyticsService analyticsService = new AnalyticsService();
151

152
        // Subscribe all services
153
        orderService.attach(emailService);
154
        orderService.attach(inventoryService);
155
        orderService.attach(paymentService);
156
        orderService.attach(warehouseService);
157
        orderService.attach(analyticsService);
158

159
        // Place an order - all services get notified automatically!
160
        Order order = new Order("ORD-123", List.of("Laptop", "Mouse"), 999.99);
161
        orderService.placeOrder(order);
162

163
        // Add a new service - no need to modify OrderService!
164
        class NotificationService implements OrderObserver {
165
            @Override
166
            public void onOrderPlaced(Map<String, Object> orderData) {
167
                String orderId = (String) orderData.get("order_id");
168
                System.out.println("🔔 Push notification sent: Order " + orderId + " placed");
169
            }
170
        }
171

172
        NotificationService notificationService = new NotificationService();
173
        orderService.attach(notificationService);
174

175
        // Place another order - new service also gets notified!
176
        Order order2 = new Order("ORD-124", List.of("Keyboard"), 49.99);
177
        orderService.placeOrder(order2);
178
    }
179
}

1
// Complete TypeScript implementation matches Python/Java structure
2
// Due to length, showing key parts with all 5 services
3

4
interface OrderObserver {
5
    onOrderPlaced(orderData: Record<string, any>): void;
6
}
7

8
interface OrderSubject {
9
    attach(observer: OrderObserver): void;
10
    detach(observer: OrderObserver): void;
11
    notifyOrderPlaced(orderData: Record<string, any>): void;
12
}
13

14
class Order {
15
    constructor(
16
        public orderId: string,
17
        public items: string[],
18
        public total: number,
19
        public status: string = "pending"
20
    ) {}
21
}
22

23
class OrderService implements OrderSubject {
24
    private observers: OrderObserver[] = [];
25

26
    attach(observer: OrderObserver): void {
27
        if (!this.observers.includes(observer)) {
28
            this.observers.push(observer);
29
            console.log(`✅ Service subscribed: ${observer.constructor.name}`);
30
        }
31
    }
32

33
    detach(observer: OrderObserver): void {
34
        const index = this.observers.indexOf(observer);
35
        if (index > -1) {
36
            this.observers.splice(index, 1);
37
            console.log(`❌ Service unsubscribed: ${observer.constructor.name}`);
38
        }
39
    }
40

41
    notifyOrderPlaced(orderData: Record<string, any>): void {
42
        for (const observer of this.observers) {
43
            observer.onOrderPlaced(orderData);
44
        }
45
    }
46

47
    placeOrder(order: Order): void {
48
        order.status = "placed";
49
        console.log(`\n🛒 Order ${order.orderId} placed!`);
50

51
        const orderData = {
52
            order_id: order.orderId,
53
            items: order.items,
54
            total: order.total,
55
            status: order.status
56
        };
57

58
        this.notifyOrderPlaced(orderData);
59
    }
60
}
61

62
// Concrete Observers
63
class EmailService implements OrderObserver {
64
    onOrderPlaced(orderData: Record<string, any>): void {
65
        console.log(`📧 Email sent: Order ${orderData.order_id} confirmation`);
66
    }
67
}
68

69
class InventoryService implements OrderObserver {
70
    onOrderPlaced(orderData: Record<string, any>): void {
71
        console.log(`📦 Inventory updated for ${orderData.items.length} items`);
72
    }
73
}
74

75
class PaymentService implements OrderObserver {
76
    onOrderPlaced(orderData: Record<string, any>): void {
77
        console.log(`💳 Payment processed: $${orderData.total} for order ${orderData.order_id}`);
78
    }
79
}
80

81
class WarehouseService implements OrderObserver {
82
    onOrderPlaced(orderData: Record<string, any>): void {
83
        console.log(`🏭 Warehouse notified: Order ${orderData.order_id} with ${orderData.items.length} items`);
84
    }
85
}
86

87
class AnalyticsService implements OrderObserver {
88
    onOrderPlaced(orderData: Record<string, any>): void {
89
        console.log(`📊 Analytics: Order ${orderData.order_id} recorded, amount: $${orderData.total}`);
90
    }
91
}
92

93
class NotificationService implements OrderObserver {
94
    onOrderPlaced(orderData: Record<string, any>): void {
95
        console.log(`🔔 Push notification sent: Order ${orderData.order_id} placed`);
96
    }
97
}
98

99
// Usage
100
const orderService = new OrderService();
101
const emailService = new EmailService();
102
const inventoryService = new InventoryService();
103
const paymentService = new PaymentService();
104
const warehouseService = new WarehouseService();
105
const analyticsService = new AnalyticsService();
106

107
orderService.attach(emailService);
108
orderService.attach(inventoryService);
109
orderService.attach(paymentService);
110
orderService.attach(warehouseService);
111
orderService.attach(analyticsService);
112

113
const order = new Order("ORD-123", ["Laptop", "Mouse"], 999.99);
114
orderService.placeOrder(order);
115

116
const notificationService = new NotificationService();
117
orderService.attach(notificationService);
118

119
const order2 = new Order("ORD-124", ["Keyboard"], 49.99);
120
orderService.placeOrder(order2);

1
// Complete C++ implementation with all 5 services
2
#include <iostream>
3
#include <vector>
4
#include <string>
5
#include <map>
6
#include <algorithm>
7

8
using OrderData = std::map<std::string, std::string>;
9

10
class OrderObserver {
11
public:
12
    virtual ~OrderObserver() = default;
13
    virtual void onOrderPlaced(const OrderData& orderData) = 0;
14
    virtual std::string getName() const = 0;
15
};
16

17
class OrderSubject {
18
public:
19
    virtual ~OrderSubject() = default;
20
    virtual void attach(OrderObserver* observer) = 0;
21
    virtual void detach(OrderObserver* observer) = 0;
22
    virtual void notifyOrderPlaced(const OrderData& orderData) = 0;
23
};
24

25
struct Order {
26
    std::string orderId;
27
    std::vector<std::string> items;
28
    double total;
29
    std::string status = "pending";
30

31
    Order(const std::string& id, const std::vector<std::string>& itms, double tot)
32
        : orderId(id), items(itms), total(tot) {}
33
};
34

35
class OrderService : public OrderSubject {
36
private:
37
    std::vector<OrderObserver*> observers;
38

39
public:
40
    void attach(OrderObserver* observer) override {
41
        if (std::find(observers.begin(), observers.end(), observer) == observers.end()) {
42
            observers.push_back(observer);
43
            std::cout << "✅ Service subscribed: " << observer->getName() << std::endl;
44
        }
45
    }
46

47
    void detach(OrderObserver* observer) override {
48
        auto it = std::find(observers.begin(), observers.end(), observer);
49
        if (it != observers.end()) {
50
            observers.erase(it);
51
            std::cout << "❌ Service unsubscribed: " << observer->getName() << std::endl;
52
        }
53
    }
54

55
    void notifyOrderPlaced(const OrderData& orderData) override {
56
        for (auto observer : observers) {
57
            observer->onOrderPlaced(orderData);
58
        }
59
    }
60

61
    void placeOrder(Order& order) {
62
        order.status = "placed";
63
        std::cout << "\n🛒 Order " << order.orderId << " placed!" << std::endl;
64

65
        OrderData orderData;
66
        orderData["order_id"] = order.orderId;
67
        orderData["total"] = std::to_string(order.total);
68
        orderData["items_count"] = std::to_string(order.items.size());
69

70
        notifyOrderPlaced(orderData);
71
    }
72
};
73

74
// Concrete Observers (showing all 5 services)
75
class EmailService : public OrderObserver {
76
public:
77
    void onOrderPlaced(const OrderData& orderData) override {
78
        std::cout << "📧 Email sent: Order " << orderData.at("order_id") << " confirmation" << std::endl;
79
    }
80
    std::string getName() const override { return "EmailService"; }
81
};
82

83
class InventoryService : public OrderObserver {
84
public:
85
    void onOrderPlaced(const OrderData& orderData) override {
86
        std::cout << "📦 Inventory updated for " << orderData.at("items_count") << " items" << std::endl;
87
    }
88
    std::string getName() const override { return "InventoryService"; }
89
};
90

91
class PaymentService : public OrderObserver {
92
public:
93
    void onOrderPlaced(const OrderData& orderData) override {
94
        std::cout << "💳 Payment processed: $" << orderData.at("total") << " for order " << orderData.at("order_id") << std::endl;
95
    }
96
    std::string getName() const override { return "PaymentService"; }
97
};
98

99
class WarehouseService : public OrderObserver {
100
public:
101
    void onOrderPlaced(const OrderData& orderData) override {
102
        std::cout << "🏭 Warehouse notified: Order " << orderData.at("order_id") << " with " << orderData.at("items_count") << " items" << std::endl;
103
    }
104
    std::string getName() const override { return "WarehouseService"; }
105
};
106

107
class AnalyticsService : public OrderObserver {
108
public:
109
    void onOrderPlaced(const OrderData& orderData) override {
110
        std::cout << "📊 Analytics: Order " << orderData.at("order_id") << " recorded, amount: $" << orderData.at("total") << std::endl;
111
    }
112
    std::string getName() const override { return "AnalyticsService"; }
113
};
114

115
class NotificationService : public OrderObserver {
116
public:
117
    void onOrderPlaced(const OrderData& orderData) override {
118
        std::cout << "🔔 Push notification sent: Order " << orderData.at("order_id") << " placed" << std::endl;
119
    }
120
    std::string getName() const override { return "NotificationService"; }
121
};
122

123
// Usage
124
int main() {
125
    OrderService orderService;
126
    EmailService emailService;
127
    InventoryService inventoryService;
128
    PaymentService paymentService;
129
    WarehouseService warehouseService;
130
    AnalyticsService analyticsService;
131

132
    orderService.attach(&emailService);
133
    orderService.attach(&inventoryService);
134
    orderService.attach(&paymentService);
135
    orderService.attach(&warehouseService);
136
    orderService.attach(&analyticsService);
137

138
    Order order("ORD-123", {"Laptop", "Mouse"}, 999.99);
139
    orderService.placeOrder(order);
140

141
    NotificationService notificationService;
142
    orderService.attach(&notificationService);
143

144
    Order order2("ORD-124", {"Keyboard"}, 49.99);
145
    orderService.placeOrder(order2);
146

147
    return 0;
148
}

1
// Complete C# implementation with all 5 services
2
using System;
3
using System.Collections.Generic;
4
using System.Linq;
5

6
public interface IOrderObserver
7
{
8
    void OnOrderPlaced(Dictionary<string, object> orderData);
9
}
10

11
public interface IOrderSubject
12
{
13
    void Attach(IOrderObserver observer);
14
    void Detach(IOrderObserver observer);
15
    void NotifyOrderPlaced(Dictionary<string, object> orderData);
16
}
17

18
public class Order
19
{
20
    public string OrderId { get; set; }
21
    public List<string> Items { get; set; }
22
    public double Total { get; set; }
23
    public string Status { get; set; } = "pending";
24

25
    public Order(string orderId, List<string> items, double total)
26
    {
27
        OrderId = orderId;
28
        Items = items;
29
        Total = total;
30
    }
31
}
32

33
public class OrderService : IOrderSubject
34
{
35
    private List<IOrderObserver> observers = new List<IOrderObserver>();
36

37
    public void Attach(IOrderObserver observer)
38
    {
39
        if (!observers.Contains(observer))
40
        {
41
            observers.Add(observer);
42
            Console.WriteLine($"✅ Service subscribed: {observer.GetType().Name}");
43
        }
44
    }
45

46
    public void Detach(IOrderObserver observer)
47
    {
48
        if (observers.Remove(observer))
49
        {
50
            Console.WriteLine($"❌ Service unsubscribed: {observer.GetType().Name}");
51
        }
52
    }
53

54
    public void NotifyOrderPlaced(Dictionary<string, object> orderData)
55
    {
56
        foreach (var observer in observers)
57
        {
58
            observer.OnOrderPlaced(orderData);
59
        }
60
    }
61

62
    public void PlaceOrder(Order order)
63
    {
64
        order.Status = "placed";
65
        Console.WriteLine($"\n🛒 Order {order.OrderId} placed!");
66

67
        var orderData = new Dictionary<string, object>
68
        {
69
            ["order_id"] = order.OrderId,
70
            ["items"] = order.Items,
71
            ["total"] = order.Total,
72
            ["status"] = order.Status
73
        };
74

75
        NotifyOrderPlaced(orderData);
76
    }
77
}
78

79
// Concrete Observers (all 5 services)
80
public class EmailService : IOrderObserver
81
{
82
    public void OnOrderPlaced(Dictionary<string, object> orderData)
83
    {
84
        Console.WriteLine($"📧 Email sent: Order {orderData["order_id"]} confirmation");
85
    }
86
}
87

88
public class InventoryService : IOrderObserver
89
{
90
    public void OnOrderPlaced(Dictionary<string, object> orderData)
91
    {
92
        var items = (List<string>)orderData["items"];
93
        Console.WriteLine($"📦 Inventory updated for {items.Count} items");
94
    }
95
}
96

97
public class PaymentService : IOrderObserver
98
{
99
    public void OnOrderPlaced(Dictionary<string, object> orderData)
100
    {
101
        Console.WriteLine($"💳 Payment processed: ${orderData["total"]} for order {orderData["order_id"]}");
102
    }
103
}
104

105
public class WarehouseService : IOrderObserver
106
{
107
    public void OnOrderPlaced(Dictionary<string, object> orderData)
108
    {
109
        var items = (List<string>)orderData["items"];
110
        Console.WriteLine($"🏭 Warehouse notified: Order {orderData["order_id"]} with {items.Count} items");
111
    }
112
}
113

114
public class AnalyticsService : IOrderObserver
115
{
116
    public void OnOrderPlaced(Dictionary<string, object> orderData)
117
    {
118
        Console.WriteLine($"📊 Analytics: Order {orderData["order_id"]} recorded, amount: ${orderData["total"]}");
119
    }
120
}
121

122
public class NotificationService : IOrderObserver
123
{
124
    public void OnOrderPlaced(Dictionary<string, object> orderData)
125
    {
126
        Console.WriteLine($"🔔 Push notification sent: Order {orderData["order_id"]} placed");
127
    }
128
}
129

130
// Usage
131
class Program
132
{
133
    static void Main()
134
    {
135
        var orderService = new OrderService();
136
        var emailService = new EmailService();
137
        var inventoryService = new InventoryService();
138
        var paymentService = new PaymentService();
139
        var warehouseService = new WarehouseService();
140
        var analyticsService = new AnalyticsService();
141

142
        orderService.Attach(emailService);
143
        orderService.Attach(inventoryService);
144
        orderService.Attach(paymentService);
145
        orderService.Attach(warehouseService);
146
        orderService.Attach(analyticsService);
147

148
        var order = new Order("ORD-123", new List<string> { "Laptop", "Mouse" }, 999.99);
149
        orderService.PlaceOrder(order);
150

151
        var notificationService = new NotificationService();
152
        orderService.Attach(notificationService);
153

154
        var order2 = new Order("ORD-124", new List<string> { "Keyboard" }, 49.99);
155
        orderService.PlaceOrder(order2);
156
    }
157
}

1
package main
2

3
import "fmt"
4

5
// Observer interface for order events
6
type OrderObserver interface {
7
  OnOrderPlaced(data map[string]any)
8
}
9

10
// Order struct
11
type Order struct {
12
  orderId string
13
  items   []string
14
  total   float64
15
}
16

17
// Subject: OrderService
18
type OrderService struct {
19
  observers []OrderObserver
20
}
21

22
func (os *OrderService) Attach(o OrderObserver) {
23
  os.observers = append(os.observers, o)
24
  fmt.Printf("✅ Service subscribed\n")
25
}
26

27
func (os *OrderService) Notify(data map[string]any) {
28
  for _, o := range os.observers {
29
    o.OnOrderPlaced(data)
30
  }
31
}
32

33
func (os *OrderService) PlaceOrder(order *Order) {
34
  fmt.Printf("\n🛒 Order %s placed!\n", order.orderId)
35
  data := map[string]any{
36
    "order_id": order.orderId,
37
    "items":    order.items,
38
    "total":    order.total,
39
  }
40
  os.Notify(data)
41
}
42

43
// Concrete observers
44
type EmailSvc struct{}
45
type InventorySvc struct{}
46
type PaymentSvc struct{}
47

48
func (e *EmailSvc) OnOrderPlaced(d map[string]any) {
49
  fmt.Printf("📧 Email sent: Order %s confirmation\n", d["order_id"])
50
}
51
func (i *InventorySvc) OnOrderPlaced(d map[string]any) {
52
  items := d["items"].([]string)
53
  fmt.Printf("📦 Inventory updated for %d items\n", len(items))
54
}
55
func (p *PaymentSvc) OnOrderPlaced(d map[string]any) {
56
  fmt.Printf("💳 Payment processed: $%.2f for order %s\n", d["total"], d["order_id"])
57
}
58

59
func main() {
60
  svc := &OrderService{}
61
  svc.Attach(&EmailSvc{})
62
  svc.Attach(&InventorySvc{})
63
  svc.Attach(&PaymentSvc{})
64

65
  svc.PlaceOrder(&Order{"ORD-123", []string{"Laptop", "Mouse"}, 999.99})
66
  svc.PlaceOrder(&Order{"ORD-124", []string{"Keyboard"}, 49.99})
67
}

1
trait Observer {
2
    fn update(&self, event: &str);
3
}
4

5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15

16
impl Subject {
17
    fn attach(&mut self, observer: Box<dyn Observer>) {
18
        self.observers.push(observer);
19
    }
20
    fn notify(&self, event: &str) {
21
        for observer in &self.observers {
22
            observer.update(event);
23
        }
24
    }
25
}

1
✅ Service subscribed: EmailService
2
✅ Service subscribed: InventoryService
3
✅ Service subscribed: PaymentService
4
✅ Service subscribed: WarehouseService
5
✅ Service subscribed: AnalyticsService
6

7
🛒 Order ORD-123 placed!
8
📧 Email sent: Order ORD-123 confirmation
9
📦 Inventory updated for 2 items
10
💳 Payment processed: $999.99 for order ORD-123
11
🏭 Warehouse notified: Order ORD-123 with 2 items
12
📊 Analytics: Order ORD-123 recorded, amount: $999.99
13
✅ Service subscribed: NotificationService
14

15
🛒 Order ORD-124 placed!
16
📧 Email sent: Order ORD-124 confirmation
17
📦 Inventory updated for 1 items
18
💳 Payment processed: $49.99 for order ORD-124
19
🏭 Warehouse notified: Order ORD-124 with 1 items
20
📊 Analytics: Order ORD-124 recorded, amount: $49.99
21
🔔 Push notification sent: Order ORD-124 placed

Adding a New Service

With Observer Pattern, adding a new service is super easy:

💡 Tip: Click dropdown to switch between languages

1
# Step 1: Create the new service observer
2
class LoyaltyPointsService(OrderObserver):
3
    """Loyalty points service observer"""
4

5
    def on_order_placed(self, order_data: Dict[str, Any]) -> None:
6
        order_id = order_data["order_id"]
7
        amount = order_data["total"]
8
        points = int(amount * 0.1)  # 10% of order value
9
        print(f"🎁 Loyalty points added: {points} points for order {order_id}")
10

11
# Step 2: Subscribe it (that's it!)
12
loyalty_service = LoyaltyPointsService()
13
order_service.attach(loyalty_service)
14

15
# Now it automatically gets notified for all future orders!
16
# No changes needed to OrderService or place_order() method!

1
// Step 1: Create the new service observer
2
public class LoyaltyPointsService implements OrderObserver {
3
    /**
4
     * Loyalty points service observer
5
     */
6
    @Override
7
    public void onOrderPlaced(Map<String, Object> orderData) {
8
        String orderId = (String) orderData.get("order_id");
9
        double amount = (Double) orderData.get("total");
10
        int points = (int) (amount * 0.1);  // 10% of order value
11
        System.out.println("🎁 Loyalty points added: " + points + " points for order " + orderId);
12
    }
13
}
14

15
// Step 2: Subscribe it (that's it!)
16
LoyaltyPointsService loyaltyService = new LoyaltyPointsService();
17
orderService.attach(loyaltyService);
18

19
// Now it automatically gets notified for all future orders!
20
// No changes needed to OrderService or placeOrder() method!

1
// Step 1: Create the new service observer
2
class LoyaltyPointsService implements OrderObserver {
3
    /** Loyalty points service observer */
4
    onOrderPlaced(orderData: Record<string, any>): void {
5
        const orderId = orderData.order_id;
6
        const amount = orderData.total;
7
        const points = Math.floor(amount * 0.1);  // 10% of order value
8
        console.log(`🎁 Loyalty points added: ${points} points for order ${orderId}`);
9
    }
10
}
11

12
// Step 2: Subscribe it (that's it!)
13
const loyaltyService = new LoyaltyPointsService();
14
orderService.attach(loyaltyService);
15

16
// Now it automatically gets notified for all future orders!
17
// No changes needed to OrderService or placeOrder() method!

1
// Step 1: Create the new service observer
2
class LoyaltyPointsService : public OrderObserver {
3
public:
4
    void onOrderPlaced(const OrderData& orderData) override {
5
        std::string orderId = orderData.at("order_id");
6
        double amount = std::stod(orderData.at("total"));
7
        int points = static_cast<int>(amount * 0.1);  // 10% of order value
8
        std::cout << "🎁 Loyalty points added: " << points << " points for order " << orderId << std::endl;
9
    }
10

11
    std::string getName() const override {
12
        return "LoyaltyPointsService";
13
    }
14
};
15

16
// Step 2: Subscribe it (that's it!)
17
LoyaltyPointsService loyaltyService;
18
orderService.attach(&loyaltyService);
19

20
// Now it automatically gets notified for all future orders!
21
// No changes needed to OrderService or placeOrder() method!

1
// Step 1: Create the new service observer
2
public class LoyaltyPointsService : IOrderObserver
3
{
4
    /** Loyalty points service observer */
5
    public void OnOrderPlaced(Dictionary<string, object> orderData)
6
    {
7
        string orderId = (string)orderData["order_id"];
8
        double amount = (double)orderData["total"];
9
        int points = (int)(amount * 0.1);  // 10% of order value
10
        Console.WriteLine($"🎁 Loyalty points added: {points} points for order {orderId}");
11
    }
12
}
13

14
// Step 2: Subscribe it (that's it!)
15
LoyaltyPointsService loyaltyService = new LoyaltyPointsService();
16
orderService.Attach(loyaltyService);
17

18
// Now it automatically gets notified for all future orders!
19
// No changes needed to OrderService or PlaceOrder() method!

1
// Step 1: Create the new service observer
2
type LoyaltyPointsService struct{}
3

4
func (l *LoyaltyPointsService) OnOrderPlaced(data map[string]any) {
5
  orderId := data["order_id"].(string)
6
  amount := data["total"].(float64)
7
  points := int(amount * 0.1)
8
  fmt.Printf("🎁 Loyalty points added: %d points for order %s\n", points, orderId)
9
}
10

11
// Step 2: Subscribe it (that's it!)
12
// orderService.Attach(&LoyaltyPointsService{})
13
// No changes needed to OrderService!

1
// Adding a New Service
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

Observer Pattern Variants

There are several variations of the Observer Pattern:

1. Push Model (What We Used)

Subject sends all data to observers:

💡 Tip: Click dropdown to switch between languages

1
class Observer(ABC):
2
    @abstractmethod
3
    def update(self, data: Dict[str, Any]) -> None:
4
        pass
5

6
# Subject pushes all data
7
def notify(self):
8
    for observer in self._observers:
9
        observer.update({
10
            "temperature": self._temperature,
11
            "humidity": self._humidity,
12
            "pressure": self._pressure
13
        })

1
public interface Observer {
2
    void update(Map<String, Object> data);
3
}
4

5
// Subject pushes all data
6
public void notifyObservers() {
7
    Map<String, Object> data = new HashMap<>();
8
    data.put("temperature", this.temperature);
9
    data.put("humidity", this.humidity);
10
    data.put("pressure", this.pressure);
11

12
    for (Observer observer : observers) {
13
        observer.update(data);
14
    }
15
}

1
interface Observer {
2
    update(data: Record<string, any>): void;
3
}
4

5
// Subject pushes all data
6
class Subject {
7
    private observers: Observer[] = [];
8
    private temperature: number;
9
    private humidity: number;
10
    private pressure: number;
11

12
    notify(): void {
13
        for (const observer of this.observers) {
14
            observer.update({
15
                temperature: this.temperature,
16
                humidity: this.humidity,
17
                pressure: this.pressure
18
            });
19
        }
20
    }
21
}

1
#include <map>
2
#include <vector>
3
#include <string>
4

5
class Observer {
6
public:
7
    virtual ~Observer() = default;
8
    virtual void update(const std::map<std::string, double>& data) = 0;
9
};
10

11
// Subject pushes all data
12
class Subject {
13
private:
14
    std::vector<Observer*> observers;
15
    double temperature;
16
    double humidity;
17
    double pressure;
18

19
public:
20
    void notify() {
21
        std::map<std::string, double> data;
22
        data["temperature"] = temperature;
23
        data["humidity"] = humidity;
24
        data["pressure"] = pressure;
25

26
        for (Observer* observer : observers) {
27
            observer->update(data);
28
        }
29
    }
30
};

1
using System.Collections.Generic;
2

3
public interface IObserver
4
{
5
    void Update(Dictionary<string, object> data);
6
}
7

8
// Subject pushes all data
9
public class Subject
10
{
11
    private List<IObserver> observers = new List<IObserver>();
12
    private double temperature;
13
    private double humidity;
14
    private double pressure;
15

16
    public void Notify()
17
    {
18
        var data = new Dictionary<string, object>
19
        {
20
            ["temperature"] = temperature,
21
            ["humidity"] = humidity,
22
            ["pressure"] = pressure
23
        };
24

25
        foreach (var observer in observers)
26
        {
27
            observer.Update(data);
28
        }
29
    }
30
}

1
// Push Model - subject pushes all data to observers
2
type Observer interface {
3
  Update(data map[string]any)
4
}
5

6
type Subject struct {
7
  observers   []Observer
8
  temperature float64
9
  humidity    float64
10
  pressure    float64
11
}
12

13
func (s *Subject) Notify() {
14
  data := map[string]any{
15
    "temperature": s.temperature,
16
    "humidity":    s.humidity,
17
    "pressure":    s.pressure,
18
  }
19
  for _, o := range s.observers {
20
    o.Update(data)
21
  }
22
}

1
// 1. Push Model What We Used
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

Pros: Observers get all data
Cons: Observers might not need all data

2. Pull Model

Observers pull data they need from subject:

💡 Tip: Click dropdown to switch between languages

1
class Observer(ABC):
2
    @abstractmethod
3
    def update(self, subject: Subject) -> None:
4
        # Observer pulls what it needs
5
        temp = subject.get_temperature()
6
        humidity = subject.get_humidity()
7
        pass
8

9
# Subject just notifies, observers pull what they need
10
def notify(self):
11
    for observer in self._observers:
12
        observer.update(self)  # Pass subject reference

1
public interface Observer {
2
    void update(Subject subject);
3
}
4

5
// Observer pulls what it needs
6
public class ConcreteObserver implements Observer {
7
    @Override
8
    public void update(Subject subject) {
9
        double temp = subject.getTemperature();
10
        double humidity = subject.getHumidity();
11
        // Use the data...
12
    }
13
}
14

15
// Subject just notifies, observers pull what they need
16
public void notifyObservers() {
17
    for (Observer observer : observers) {
18
        observer.update(this);  // Pass subject reference
19
    }
20
}

1
interface Observer {
2
    update(subject: Subject): void;
3
}
4

5
abstract class Subject {
6
    abstract getTemperature(): number;
7
    abstract getHumidity(): number;
8
}
9

10
class ConcreteObserver implements Observer {
11
    update(subject: Subject): void {
12
        // Observer pulls what it needs
13
        const temp = subject.getTemperature();
14
        const humidity = subject.getHumidity();
15
        // Use the data...
16
    }
17
}
18

19
// Subject just notifies, observers pull what they need
20
class ConcreteSubject extends Subject {
21
    private observers: Observer[] = [];
22

23
    notify(): void {
24
        for (const observer of this.observers) {
25
            observer.update(this);  // Pass subject reference
26
        }
27
    }
28

29
    getTemperature(): number { return 0; }
30
    getHumidity(): number { return 0; }
31
}

1
class Subject;
2

3
class Observer {
4
public:
5
    virtual ~Observer() = default;
6
    virtual void update(Subject* subject) = 0;
7
};
8

9
class Subject {
10
protected:
11
    std::vector<Observer*> observers;
12

13
public:
14
    virtual ~Subject() = default;
15
    virtual double getTemperature() const = 0;
16
    virtual double getHumidity() const = 0;
17

18
    void notify() {
19
        for (Observer* observer : observers) {
20
            observer->update(this);  // Pass subject reference
21
        }
22
    }
23
};
24

25
class ConcreteObserver : public Observer {
26
public:
27
    void update(Subject* subject) override {
28
        // Observer pulls what it needs
29
        double temp = subject->getTemperature();
30
        double humidity = subject->getHumidity();
31
        // Use the data...
32
    }
33
};

1
using System.Collections.Generic;
2

3
public interface IObserver
4
{
5
    void Update(ISubject subject);
6
}
7

8
public interface ISubject
9
{
10
    double GetTemperature();
11
    double GetHumidity();
12
}
13

14
public class ConcreteObserver : IObserver
15
{
16
    public void Update(ISubject subject)
17
    {
18
        // Observer pulls what it needs
19
        double temp = subject.GetTemperature();
20
        double humidity = subject.GetHumidity();
21
        // Use the data...
22
    }
23
}
24

25
// Subject just notifies, observers pull what they need
26
public class ConcreteSubject : ISubject
27
{
28
    private List<IObserver> observers = new List<IObserver>();
29

30
    public void Notify()
31
    {
32
        foreach (var observer in observers)
33
        {
34
            observer.Update(this);  // Pass subject reference
35
        }
36
    }
37

38
    public double GetTemperature() { return 0; }
39
    public double GetHumidity() { return 0; }
40
}

1
// Pull Model - observer pulls data it needs from subject
2

3
type SubjectI interface {
4
  GetTemperature() float64
5
  GetHumidity() float64
6
}
7

8
type ObserverI interface {
9
  Update(s SubjectI)
10
}
11

12
type ConcreteObserver struct{}
13

14
func (o *ConcreteObserver) Update(s SubjectI) {
15
  // Observer pulls only what it needs
16
  temp := s.GetTemperature()
17
  humidity := s.GetHumidity()
18
  fmt.Printf("Temp: %.1f, Humidity: %.1f\n", temp, humidity)
19
}
20

21
type ConcreteSubject struct {
22
  observers   []ObserverI
23
  temperature float64
24
  humidity    float64
25
}
26

27
func (s *ConcreteSubject) GetTemperature() float64 { return s.temperature }
28
func (s *ConcreteSubject) GetHumidity() float64    { return s.humidity }
29
func (s *ConcreteSubject) Notify() {
30
  for _, o := range s.observers {
31
    o.Update(s) // Pass subject reference
32
  }
33
}

1
// 2. Pull Model
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

Pros: Observers get only what they need
Cons: Observers need to know subject’s interface

3. Event-Based Observer

Using events instead of direct method calls:

💡 Tip: Click dropdown to switch between languages

1
from typing import Callable
2

3
class EventObserver:
4
    """Event-based observer using callbacks"""
5

6
    def __init__(self):
7
        self._callbacks: List[Callable] = []
8

9
    def subscribe(self, callback: Callable) -> None:
10
        self._callbacks.append(callback)
11

12
    def notify(self, event_data: Dict[str, Any]) -> None:
13
        for callback in self._callbacks:
14
            callback(event_data)
15

16
# Usage
17
def on_order_placed(data):
18
    print(f"Order {data['order_id']} placed!")
19

20
observer = EventObserver()
21
observer.subscribe(on_order_placed)
22
observer.notify({"order_id": "ORD-123"})

1
import java.util.function.Consumer;
2
import java.util.ArrayList;
3
import java.util.List;
4
import java.util.Map;
5

6
public class EventObserver {
7
    /**
8
     * Event-based observer using callbacks
9
     */
10
    private List<Consumer<Map<String, Object>>> callbacks = new ArrayList<>();
11

12
    public void subscribe(Consumer<Map<String, Object>> callback) {
13
        callbacks.add(callback);
14
    }
15

16
    public void notify(Map<String, Object> eventData) {
17
        for (Consumer<Map<String, Object>> callback : callbacks) {
18
            callback.accept(eventData);
19
        }
20
    }
21
}
22

23
// Usage
24
public class Main {
25
    public static void main(String[] args) {
26
        EventObserver observer = new EventObserver();
27
        observer.subscribe(data -> {
28
            String orderId = (String) data.get("order_id");
29
            System.out.println("Order " + orderId + " placed!");
30
        });
31

32
        Map<String, Object> eventData = new HashMap<>();
33
        eventData.put("order_id", "ORD-123");
34
        observer.notify(eventData);
35
    }
36
}

1
type EventCallback = (data: Record<string, any>) => void;
2

3
class EventObserver {
4
    /** Event-based observer using callbacks */
5
    private callbacks: EventCallback[] = [];
6

7
    subscribe(callback: EventCallback): void {
8
        this.callbacks.push(callback);
9
    }
10

11
    notify(eventData: Record<string, any>): void {
12
        for (const callback of this.callbacks) {
13
            callback(eventData);
14
        }
15
    }
16
}
17

18
// Usage
19
const observer = new EventObserver();
20
observer.subscribe((data) => {
21
    console.log(`Order ${data.order_id} placed!`);
22
});
23

24
observer.notify({ order_id: "ORD-123" });

1
#include <functional>
2
#include <vector>
3
#include <map>
4
#include <string>
5

6
using EventCallback = std::function<void(const std::map<std::string, std::string>&)>;
7

8
class EventObserver {
9
private:
10
    std::vector<EventCallback> callbacks;
11

12
public:
13
    void subscribe(EventCallback callback) {
14
        callbacks.push_back(callback);
15
    }
16

17
    void notify(const std::map<std::string, std::string>& eventData) {
18
        for (const auto& callback : callbacks) {
19
            callback(eventData);
20
        }
21
    }
22
};
23

24
// Usage
25
// EventObserver observer;
26
// observer.subscribe([](const auto& data) {
27
//     std::cout << "Order " << data.at("order_id") << " placed!" << std::endl;
28
// });
29
// observer.notify({{"order_id", "ORD-123"}});

1
using System;
2
using System.Collections.Generic;
3

4
public class EventObserver
5
{
6
    /** Event-based observer using callbacks */
7
    private List<Action<Dictionary<string, object>>> callbacks = new List<Action<Dictionary<string, object>>>();
8

9
    public void Subscribe(Action<Dictionary<string, object>> callback)
10
    {
11
        callbacks.Add(callback);
12
    }
13

14
    public void Notify(Dictionary<string, object> eventData)
15
    {
16
        foreach (var callback in callbacks)
17
        {
18
            callback(eventData);
19
        }
20
    }
21
}
22

23
// Usage
24
class Program
25
{
26
    static void Main()
27
    {
28
        EventObserver observer = new EventObserver();
29
        observer.Subscribe(data => {
30
            Console.WriteLine($"Order {data["order_id"]} placed!");
31
        });
32

33
        var eventData = new Dictionary<string, object> { ["order_id"] = "ORD-123" };
34
        observer.Notify(eventData);
35
    }
36
}

1
package main
2

3
import "fmt"
4

5
// Event-based observer using function callbacks
6
type EventCallback func(data map[string]any)
7

8
type EventObserver struct {
9
  callbacks []EventCallback
10
}
11

12
func (e *EventObserver) Subscribe(cb EventCallback) {
13
  e.callbacks = append(e.callbacks, cb)
14
}
15

16
func (e *EventObserver) Notify(eventData map[string]any) {
17
  for _, cb := range e.callbacks {
18
    cb(eventData)
19
  }
20
}
21

22
func main() {
23
  observer := &EventObserver{}
24
  observer.Subscribe(func(data map[string]any) {
25
    fmt.Printf("Order %s placed!\n", data["order_id"])
26
  })
27
  observer.Notify(map[string]any{"order_id": "ORD-123"})
28
}

1
// 3. Event-Based Observer
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

When to Use Observer Pattern?

Use Observer Pattern when:

✅ One object changes and multiple objects need to be notified
✅ You want loose coupling - Subject shouldn’t know about observers
✅ You need dynamic relationships - Add/remove observers at runtime
✅ You want to avoid polling - No constant checking for changes
✅ You have one-to-many dependency - One subject, many observers
✅ You’re following Open/Closed Principle - Open for extension, closed for modification

When NOT to Use Observer Pattern?

Don’t use Observer Pattern when:

❌ Simple one-to-one communication - Direct method call is simpler
❌ Performance is critical - Observer adds overhead (usually negligible)
❌ Order of notifications matters - Observers might execute in unpredictable order
❌ Observers need to modify subject - Can create circular dependencies
❌ You have few, stable observers - Overhead might not be worth it

Common Mistakes to Avoid

Mistake 1: Observers Modifying Subject

💡 Tip: Click dropdown to switch between languages

1
# ❌ Observer modifying subject - can cause infinite loops!
2
class BadObserver(Observer):
3
    def update(self, temperature: float):
4
        if temperature > 30:
5
            self.subject.set_temperature(25)  # Modifying subject!
6
            # This triggers notify() again, which calls update() again... infinite loop!
7

8
# ✅ Better: Observer should only react, not modify
9
class GoodObserver(Observer):
10
    def update(self, temperature: float):
11
        if temperature > 30:
12
            self.send_alert()  # Just react, don't modify subject

1
// ❌ Observer modifying subject - can cause infinite loops!
2
public class BadObserver implements Observer {
3
    private Subject subject;
4

5
    public BadObserver(Subject subject) {
6
        this.subject = subject;
7
    }
8

9
    @Override
10
    public void update(double temperature) {
11
        if (temperature > 30) {
12
            subject.setTemperature(25);  // Modifying subject!
13
            // This triggers notify() again, which calls update() again... infinite loop!
14
        }
15
    }
16
}
17

18
// ✅ Better: Observer should only react, not modify
19
public class GoodObserver implements Observer {
20
    @Override
21
    public void update(double temperature) {
22
        if (temperature > 30) {
23
            sendAlert();  // Just react, don't modify subject
24
        }
25
    }
26

27
    private void sendAlert() {
28
        // Send alert logic
29
    }
30
}

1
// ❌ Observer modifying subject - can cause infinite loops!
2
class BadObserver implements Observer {
3
    private subject: Subject;
4

5
    constructor(subject: Subject) {
6
        this.subject = subject;
7
    }
8

9
    update(temperature: number): void {
10
        if (temperature > 30) {
11
            this.subject.setTemperature(25);  // Modifying subject!
12
            // This triggers notify() again, which calls update() again... infinite loop!
13
        }
14
    }
15
}
16

17
// ✅ Better: Observer should only react, not modify
18
class GoodObserver implements Observer {
19
    update(temperature: number): void {
20
        if (temperature > 30) {
21
            this.sendAlert();  // Just react, don't modify subject
22
        }
23
    }
24

25
    private sendAlert(): void {
26
        // Send alert logic
27
    }
28
}

1
// ❌ Observer modifying subject - can cause infinite loops!
2
class BadObserver : public Observer {
3
private:
4
    Subject* subject;
5

6
public:
7
    BadObserver(Subject* subject) : subject(subject) {}
8

9
    void update(double temperature) override {
10
        if (temperature > 30) {
11
            subject->setTemperature(25);  // Modifying subject!
12
            // This triggers notify() again, which calls update() again... infinite loop!
13
        }
14
    }
15

16
    std::string getName() const override { return "BadObserver"; }
17
};
18

19
// ✅ Better: Observer should only react, not modify
20
class GoodObserver : public Observer {
21
public:
22
    void update(double temperature) override {
23
        if (temperature > 30) {
24
            sendAlert();  // Just react, don't modify subject
25
        }
26
    }
27

28
private:
29
    void sendAlert() {
30
        // Send alert logic
31
    }
32

33
    std::string getName() const override { return "GoodObserver"; }
34
};

1
// ❌ Observer modifying subject - can cause infinite loops!
2
public class BadObserver : IObserver
3
{
4
    private ISubject subject;
5

6
    public BadObserver(ISubject subject)
7
    {
8
        this.subject = subject;
9
    }
10

11
    public void Update(double temperature)
12
    {
13
        if (temperature > 30)
14
        {
15
            subject.SetTemperature(25);  // Modifying subject!
16
            // This triggers Notify() again, which calls Update() again... infinite loop!
17
        }
18
    }
19
}
20

21
// ✅ Better: Observer should only react, not modify
22
public class GoodObserver : IObserver
23
{
24
    public void Update(double temperature)
25
    {
26
        if (temperature > 30)
27
        {
28
            SendAlert();  // Just react, don't modify subject
29
        }
30
    }
31

32
    private void SendAlert()
33
    {
34
        // Send alert logic
35
    }
36
}

1
// ❌ Bad: Observer modifying subject - infinite loop risk
2
type BadObserver struct{ subject *WeatherStation }
3

4
func (b *BadObserver) Update(temp float64) {
5
  if temp > 30 {
6
    b.subject.SetTemperature(25) // Modifying subject - causes infinite loop!
7
  }
8
}
9

10
// ✅ Good: Observer only reacts, does not modify subject
11
type GoodObserver struct{}
12

13
func (g *GoodObserver) Update(temp float64) {
14
  if temp > 30 {
15
    sendAlert() // Just react, don't modify subject
16
  }
17
}
18

19
func sendAlert() { fmt.Println("Alert: High temperature!") }

1
// Mistake 1: Observers Modifying Subject
2
struct OrderService;
3
impl OrderService {
4
    fn place_order(&self, id: u32) {
5
        println!("Order {}", id);
6
        println!("Email");
7
        println!("Analytics");
8
    }
9
}

Mistake 2: Not Handling Observer Errors

💡 Tip: Click dropdown to switch between languages

1
# ❌ If one observer fails, others don't get notified
2
def notify(self):
3
    for observer in self._observers:
4
        observer.update(self._temperature)  # If this fails, loop stops!
5

6
# ✅ Better: Handle errors so all observers get notified
7
def notify(self):
8
    for observer in self._observers:
9
        try:
10
            observer.update(self._temperature)
11
        except Exception as e:
12
            print(f"Error notifying {observer}: {e}")
13
            # Continue with other observers

1
// ❌ If one observer fails, others don't get notified
2
public void notifyObservers() {
3
    for (Observer observer : observers) {
4
        observer.update(temperature);  // If this fails, loop stops!
5
    }
6
}
7

8
// ✅ Better: Handle errors so all observers get notified
9
public void notifyObservers() {
10
    for (Observer observer : observers) {
11
        try {
12
            observer.update(temperature);
13
        } catch (Exception e) {
14
            System.err.println("Error notifying " + observer + ": " + e.getMessage());
15
            // Continue with other observers
16
        }
17
    }
18
}

1
// ❌ If one observer fails, others don't get notified
2
class Subject {
3
    private observers: Observer[] = [];
4
    private temperature: number;
5

6
    notify(): void {
7
        for (const observer of this.observers) {
8
            observer.update(this.temperature);  // If this fails, loop stops!
9
        }
10
    }
11
}
12

13
// ✅ Better: Handle errors so all observers get notified
14
class BetterSubject {
15
    private observers: Observer[] = [];
16
    private temperature: number;
17

18
    notify(): void {
19
        for (const observer of this.observers) {
20
            try {
21
                observer.update(this.temperature);
22
            } catch (e) {
23
                console.error(`Error notifying ${observer.constructor.name}: ${e}`);
24
                // Continue with other observers
25
            }
26
        }
27
    }
28
}

1
#include <iostream>
2
#include <vector>
3

4
// ❌ If one observer fails, others don't get notified
5
class Subject {
6
private:
7
    std::vector<Observer*> observers;
8
    double temperature;
9

10
public:
11
    void notify() {
12
        for (Observer* observer : observers) {
13
            observer->update(temperature);  // If this throws, loop stops!
14
        }
15
    }
16
};
17

18
// ✅ Better: Handle errors so all observers get notified
19
class BetterSubject {
20
private:
21
    std::vector<Observer*> observers;
22
    double temperature;
23

24
public:
25
    void notify() {
26
        for (Observer* observer : observers) {
27
            try {
28
                observer->update(temperature);
29
            } catch (const std::exception& e) {
30
                std::cerr << "Error notifying observer: " << e.what() << std::endl;
31
                // Continue with other observers
32
            }
33
        }
34
    }
35
};

1
using System;
2
using System.Collections.Generic;
3

4
// ❌ If one observer fails, others don't get notified
5
public class Subject
6
{
7
    private List<IObserver> observers = new List<IObserver>();
8
    private double temperature;
9

10
    public void Notify()
11
    {
12
        foreach (var observer in observers)
13
        {
14
            observer.Update(temperature);  // If this fails, loop stops!
15
        }
16
    }
17
}
18

19
// ✅ Better: Handle errors so all observers get notified
20
public class BetterSubject
21
{
22
    private List<IObserver> observers = new List<IObserver>();
23
    private double temperature;
24

25
    public void Notify()
26
    {
27
        foreach (var observer in observers)
28
        {
29
            try
30
            {
31
                observer.Update(temperature);
32
            }
33
            catch (Exception e)
34
            {
35
                Console.Error.WriteLine($"Error notifying observer: {e.Message}");
36
                // Continue with other observers
37
            }
38
        }
39
    }
40
}

1
// ❌ Bad: If one observer panics, others don't get notified
2
func (s *Subject) BadNotify() {
3
  for _, o := range s.observers {
4
    o.Update(s.temperature) // If this panics, loop stops!
5
  }
6
}
7

8
// ✅ Good: Handle errors so all observers get notified
9
func (s *Subject) Notify() {
10
  for _, o := range s.observers {
11
    func() {
12
      defer func() {
13
        if r := recover(); r != nil {
14
          fmt.Fprintf(os.Stderr, "Error notifying observer: %v\n", r)
15
          // Continue with other observers
16
        }
17
      }()
18
      o.Update(s.temperature)
19
    }()
20
  }
21
}

1
// Mistake 2: Not Handling Observer Errors
2
struct OrderService;
3
impl OrderService {
4
    fn place_order(&self, id: u32) {
5
        println!("Order {}", id);
6
        println!("Email");
7
        println!("Analytics");
8
    }
9
}

Mistake 3: Memory Leaks (Not Unsubscribing)

💡 Tip: Click dropdown to switch between languages

1
# ❌ Observer holds reference to subject, subject holds reference to observer
2
# If observer is deleted but not unsubscribed, memory leak!
3

4
class BadObserver(Observer):
5
    def __init__(self, subject: Subject):
6
        self.subject = subject
7
        subject.attach(self)  # Attached but never detached
8

9
# ✅ Better: Always unsubscribe when done
10
class GoodObserver(Observer):
11
    def __init__(self, subject: Subject):
12
        self.subject = subject
13
        subject.attach(self)
14

15
    def cleanup(self):
16
        self.subject.detach(self)  # Always clean up!

1
// ❌ Observer holds reference to subject, subject holds reference to observer
2
// If observer is deleted but not unsubscribed, memory leak!
3

4
public class BadObserver implements Observer {
5
    private Subject subject;
6

7
    public BadObserver(Subject subject) {
8
        this.subject = subject;
9
        subject.attach(this);  // Attached but never detached
10
    }
11
}
12

13
// ✅ Better: Always unsubscribe when done
14
public class GoodObserver implements Observer {
15
    private Subject subject;
16

17
    public GoodObserver(Subject subject) {
18
        this.subject = subject;
19
        subject.attach(this);
20
    }
21

22
    public void cleanup() {
23
        subject.detach(this);  // Always clean up!
24
    }
25
}

1
// ❌ Observer holds reference to subject, subject holds reference to observer
2
// If observer is deleted but not unsubscribed, memory leak!
3

4
class BadObserver implements Observer {
5
    private subject: Subject;
6

7
    constructor(subject: Subject) {
8
        this.subject = subject;
9
        subject.attach(this);  // Attached but never detached
10
    }
11

12
    update(data: any): void {
13
        // Update logic
14
    }
15
}
16

17
// ✅ Better: Always unsubscribe when done
18
class GoodObserver implements Observer {
19
    private subject: Subject;
20

21
    constructor(subject: Subject) {
22
        this.subject = subject;
23
        subject.attach(this);
24
    }
25

26
    update(data: any): void {
27
        // Update logic
28
    }
29

30
    cleanup(): void {
31
        this.subject.detach(this);  // Always clean up!
32
    }
33
}

1
// ❌ Observer holds reference to subject, subject holds reference to observer
2
// If observer is deleted but not unsubscribed, memory leak!
3

4
class BadObserver : public Observer {
5
private:
6
    Subject* subject;
7

8
public:
9
    BadObserver(Subject* subject) : subject(subject) {
10
        subject->attach(this);  // Attached but never detached
11
    }
12

13
    void update(double data) override {
14
        // Update logic
15
    }
16

17
    std::string getName() const override { return "BadObserver"; }
18
};
19

20
// ✅ Better: Always unsubscribe when done
21
class GoodObserver : public Observer {
22
private:
23
    Subject* subject;
24

25
public:
26
    GoodObserver(Subject* subject) : subject(subject) {
27
        subject->attach(this);
28
    }
29

30
    ~GoodObserver() {
31
        cleanup();
32
    }
33

34
    void update(double data) override {
35
        // Update logic
36
    }
37

38
    void cleanup() {
39
        subject->detach(this);  // Always clean up!
40
    }
41

42
    std::string getName() const override { return "GoodObserver"; }
43
};

1
// ❌ Observer holds reference to subject, subject holds reference to observer
2
// If observer is deleted but not unsubscribed, memory leak!
3

4
public class BadObserver : IObserver
5
{
6
    private ISubject subject;
7

8
    public BadObserver(ISubject subject)
9
    {
10
        this.subject = subject;
11
        subject.Attach(this);  // Attached but never detached
12
    }
13

14
    public void Update(double data)
15
    {
16
        // Update logic
17
    }
18
}
19

20
// ✅ Better: Always unsubscribe when done
21
public class GoodObserver : IObserver, IDisposable
22
{
23
    private ISubject subject;
24

25
    public GoodObserver(ISubject subject)
26
    {
27
        this.subject = subject;
28
        subject.Attach(this);
29
    }
30

31
    public void Update(double data)
32
    {
33
        // Update logic
34
    }
35

36
    public void Dispose()
37
    {
38
        subject.Detach(this);  // Always clean up!
39
    }
40
}

1
// ❌ Bad: Observer attached but never detached
2
type BadObserver struct{ subject *WeatherStation }
3

4
func NewBadObserver(s *WeatherStation) *BadObserver {
5
  o := &BadObserver{subject: s}
6
  s.Attach(o) // Attached but never detached
7
  return o
8
}
9
func (b *BadObserver) Update(temp float64) {}
10

11
// ✅ Good: Provide cleanup method
12
type GoodObserver struct{ subject *WeatherStation }
13

14
func NewGoodObserver(s *WeatherStation) *GoodObserver {
15
  o := &GoodObserver{subject: s}
16
  s.Attach(o)
17
  return o
18
}
19
func (g *GoodObserver) Update(temp float64) {}
20
func (g *GoodObserver) Close() {
21
  g.subject.Detach(g) // Always clean up!
22
}

1
// Mistake 3: Memory Leaks Not Unsubscribing
2
struct OrderService;
3
impl OrderService {
4
    fn place_order(&self, id: u32) {
5
        println!("Order {}", id);
6
        println!("Email");
7
        println!("Analytics");
8
    }
9
}

Benefits of Observer Pattern

Loose Coupling - Subject doesn’t depend on concrete observer classes
Dynamic Relationships - Observers can be added/removed at runtime
Open/Closed Principle - Easy to add observers without modifying subject
Broadcast Communication - One notification reaches all observers
No Polling - Observers don’t need to constantly check for changes
Follows SOLID Principles - Especially Open/Closed and Dependency Inversion

Revision: Quick Catch-Up

What is Observer Pattern?

Observer Pattern is a behavioral design pattern that defines a one-to-many dependency between objects. When one object (subject) changes state, all dependent objects (observers) are notified and updated automatically.

Why Use It?

✅ Loose coupling - Subject doesn’t know about specific observers
✅ Dynamic subscription - Add/remove observers at runtime
✅ Broadcast communication - One change notifies all observers
✅ Avoid polling - No need to constantly check for changes
✅ Follow Open/Closed Principle

How It Works?

Define Observer interface - What all observers can do
Define Subject interface - Methods to attach/detach/notify
Create concrete Subject - Maintains list of observers
Create concrete Observers - React to subject changes
Subscribe observers - Attach observers to subject
Notify on change - Subject notifies all observers when state changes

Key Components

1
Subject → attach/detach → Observers
2
Subject → notify() → Observer.update()

Subject - The object being observed (has state)
Observer - Objects that watch the subject
attach() - Subscribe an observer
detach() - Unsubscribe an observer
notify() - Notify all observers
update() - Observer’s reaction method

Simple Example

💡 Tip: Click dropdown to switch between languages

1
# Observer interface
2
class Observer(ABC):
3
    @abstractmethod
4
    def update(self, data): pass
5

6
# Subject
7
class Subject:
8
    def __init__(self):
9
        self._observers = []
10
        self._state = None
11

12
    def attach(self, observer):
13
        self._observers.append(observer)
14

15
    def notify(self):
16
        for observer in self._observers:
17
            observer.update(self._state)
18

19
# Concrete Observer
20
class ConcreteObserver(Observer):
21
    def update(self, data):
22
        print(f"Updated: {data}")
23

24
# Usage
25
subject = Subject()
26
observer = ConcreteObserver()
27
subject.attach(observer)
28
subject.notify()

1
// Observer interface
2
public interface Observer {
3
    void update(Object data);
4
}
5

6
// Subject
7
public class Subject {
8
    private List<Observer> observers = new ArrayList<>();
9
    private Object state = null;
10

11
    public void attach(Observer observer) {
12
        observers.add(observer);
13
    }
14

15
    public void notifyObservers() {
16
        for (Observer observer : observers) {
17
            observer.update(state);
18
        }
19
    }
20
}
21

22
// Concrete Observer
23
public class ConcreteObserver implements Observer {
24
    @Override
25
    public void update(Object data) {
26
        System.out.println("Updated: " + data);
27
    }
28
}
29

30
// Usage
31
public class Main {
32
    public static void main(String[] args) {
33
        Subject subject = new Subject();
34
        Observer observer = new ConcreteObserver();
35
        subject.attach(observer);
36
        subject.notifyObservers();
37
    }
38
}

1
// Observer interface
2
interface Observer {
3
    update(data: any): void;
4
}
5

6
// Subject
7
class Subject {
8
    private observers: Observer[] = [];
9
    private state: any = null;
10

11
    attach(observer: Observer): void {
12
        this.observers.push(observer);
13
    }
14

15
    notify(): void {
16
        for (const observer of this.observers) {
17
            observer.update(this.state);
18
        }
19
    }
20
}
21

22
// Concrete Observer
23
class ConcreteObserver implements Observer {
24
    update(data: any): void {
25
        console.log(`Updated: ${data}`);
26
    }
27
}
28

29
// Usage
30
const subject = new Subject();
31
const observer = new ConcreteObserver();
32
subject.attach(observer);
33
subject.notify();

1
// Observer interface
2
class Observer {
3
public:
4
    virtual ~Observer() = default;
5
    virtual void update(void* data) = 0;
6
};
7

8
// Subject
9
class Subject {
10
private:
11
    std::vector<Observer*> observers;
12
    void* state = nullptr;
13

14
public:
15
    void attach(Observer* observer) {
16
        observers.push_back(observer);
17
    }
18

19
    void notify() {
20
        for (Observer* observer : observers) {
21
            observer->update(state);
22
        }
23
    }
24
};
25

26
// Concrete Observer
27
class ConcreteObserver : public Observer {
28
public:
29
    void update(void* data) override {
30
        // Update logic
31
    }
32
};
33

34
// Usage
35
// Subject subject;
36
// ConcreteObserver observer;
37
// subject.attach(&observer);
38
// subject.notify();

1
// Observer interface
2
public interface IObserver
3
{
4
    void Update(object data);
5
}
6

7
// Subject
8
public class Subject
9
{
10
    private List<IObserver> observers = new List<IObserver>();
11
    private object state = null;
12

13
    public void Attach(IObserver observer)
14
    {
15
        observers.Add(observer);
16
    }
17

18
    public void Notify()
19
    {
20
        foreach (var observer in observers)
21
        {
22
            observer.Update(state);
23
        }
24
    }
25
}
26

27
// Concrete Observer
28
public class ConcreteObserver : IObserver
29
{
30
    public void Update(object data)
31
    {
32
        Console.WriteLine($"Updated: {data}");
33
    }
34
}
35

36
// Usage
37
class Program
38
{
39
    static void Main()
40
    {
41
        Subject subject = new Subject();
42
        IObserver observer = new ConcreteObserver();
43
        subject.Attach(observer);
44
        subject.Notify();
45
    }
46
}

1
// Observer interface
2
type Observer interface {
3
  Update(data any)
4
}
5

6
// Subject
7
type Subject struct {
8
  observers []Observer
9
  state     any
10
}
11

12
func (s *Subject) Attach(o Observer) { s.observers = append(s.observers, o) }
13
func (s *Subject) Notify() {
14
  for _, o := range s.observers {
15
    o.Update(s.state)
16
  }
17
}
18

19
// Concrete Observer
20
type ConcreteObserver struct{}
21

22
func (c *ConcreteObserver) Update(data any) { fmt.Printf("Updated: %v\n", data) }
23

24
func main() {
25
  subject := &Subject{}
26
  subject.Attach(&ConcreteObserver{})
27
  subject.Notify()
28
}

1
// Simple Example
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

When to Use?

✅ One-to-many dependency
✅ Subject changes and multiple objects need notification
✅ Want loose coupling
✅ Need dynamic add/remove observers
✅ Want to avoid polling

When NOT to Use?

❌ Simple one-to-one communication
❌ Performance is critical
❌ Order of notifications matters
❌ Few, stable observers

Key Takeaways

Observer Pattern = One subject, many observers
Subject = Object being watched
Observer = Objects watching the subject
Benefit = Loose coupling, dynamic relationships
Principle = Open for extension, closed for modification

Common Pattern Structure

💡 Tip: Click dropdown to switch between languages

1
# 1. Observer Interface
2
class Observer(ABC):
3
    @abstractmethod
4
    def update(self, data): pass
5

6
# 2. Subject Interface
7
class Subject(ABC):
8
    @abstractmethod
9
    def attach(self, observer): pass
10

11
    @abstractmethod
12
    def detach(self, observer): pass
13

14
    @abstractmethod
15
    def notify(self): pass
16

17
# 3. Concrete Subject
18
class ConcreteSubject(Subject):
19
    def __init__(self):
20
        self._observers = []
21
        self._state = None
22

23
    def attach(self, observer):
24
        self._observers.append(observer)
25

26
    def notify(self):
27
        for observer in self._observers:
28
            observer.update(self._state)
29

30
# 4. Concrete Observer
31
class ConcreteObserver(Observer):
32
    def update(self, data):
33
        # React to change
34
        pass
35

36
# 5. Usage
37
subject = ConcreteSubject()
38
observer = ConcreteObserver()
39
subject.attach(observer)
40
subject.notify()

1
// 1. Observer Interface
2
public interface Observer {
3
    void update(Object data);
4
}
5

6
// 2. Subject Interface
7
public interface Subject {
8
    void attach(Observer observer);
9
    void detach(Observer observer);
10
    void notifyObservers();
11
}
12

13
// 3. Concrete Subject
14
public class ConcreteSubject implements Subject {
15
    private List<Observer> observers = new ArrayList<>();
16
    private Object state = null;
17

18
    @Override
19
    public void attach(Observer observer) {
20
        observers.add(observer);
21
    }
22

23
    @Override
24
    public void detach(Observer observer) {
25
        observers.remove(observer);
26
    }
27

28
    @Override
29
    public void notifyObservers() {
30
        for (Observer observer : observers) {
31
            observer.update(state);
32
        }
33
    }
34
}
35

36
// 4. Concrete Observer
37
public class ConcreteObserver implements Observer {
38
    @Override
39
    public void update(Object data) {
40
        // React to change
41
    }
42
}
43

44
// 5. Usage
45
public class Main {
46
    public static void main(String[] args) {
47
        Subject subject = new ConcreteSubject();
48
        Observer observer = new ConcreteObserver();
49
        subject.attach(observer);
50
        subject.notifyObservers();
51
    }
52
}

1
// 1. Observer Interface
2
interface Observer {
3
    update(data: any): void;
4
}
5

6
// 2. Subject Interface
7
interface Subject {
8
    attach(observer: Observer): void;
9
    detach(observer: Observer): void;
10
    notify(): void;
11
}
12

13
// 3. Concrete Subject
14
class ConcreteSubject implements Subject {
15
    private observers: Observer[] = [];
16
    private state: any = null;
17

18
    attach(observer: Observer): void {
19
        this.observers.push(observer);
20
    }
21

22
    detach(observer: Observer): void {
23
        const index = this.observers.indexOf(observer);
24
        if (index > -1) {
25
            this.observers.splice(index, 1);
26
        }
27
    }
28

29
    notify(): void {
30
        for (const observer of this.observers) {
31
            observer.update(this.state);
32
        }
33
    }
34
}
35

36
// 4. Concrete Observer
37
class ConcreteObserver implements Observer {
38
    update(data: any): void {
39
        // React to change
40
    }
41
}
42

43
// 5. Usage
44
const subject: Subject = new ConcreteSubject();
45
const observer: Observer = new ConcreteObserver();
46
subject.attach(observer);
47
subject.notify();

1
// 1. Observer Interface
2
class Observer {
3
public:
4
    virtual ~Observer() = default;
5
    virtual void update(void* data) = 0;
6
};
7

8
// 2. Subject Interface
9
class Subject {
10
public:
11
    virtual ~Subject() = default;
12
    virtual void attach(Observer* observer) = 0;
13
    virtual void detach(Observer* observer) = 0;
14
    virtual void notify() = 0;
15
};
16

17
// 3. Concrete Subject
18
class ConcreteSubject : public Subject {
19
private:
20
    std::vector<Observer*> observers;
21
    void* state = nullptr;
22

23
public:
24
    void attach(Observer* observer) override {
25
        observers.push_back(observer);
26
    }
27

28
    void detach(Observer* observer) override {
29
        auto it = std::find(observers.begin(), observers.end(), observer);
30
        if (it != observers.end()) {
31
            observers.erase(it);
32
        }
33
    }
34

35
    void notify() override {
36
        for (Observer* observer : observers) {
37
            observer->update(state);
38
        }
39
    }
40
};
41

42
// 4. Concrete Observer
43
class ConcreteObserver : public Observer {
44
public:
45
    void update(void* data) override {
46
        // React to change
47
    }
48
};
49

50
// 5. Usage
51
// ConcreteSubject subject;
52
// ConcreteObserver observer;
53
// subject.attach(&observer);
54
// subject.notify();

1
// 1. Observer Interface
2
public interface IObserver
3
{
4
    void Update(object data);
5
}
6

7
// 2. Subject Interface
8
public interface ISubject
9
{
10
    void Attach(IObserver observer);
11
    void Detach(IObserver observer);
12
    void Notify();
13
}
14

15
// 3. Concrete Subject
16
public class ConcreteSubject : ISubject
17
{
18
    private List<IObserver> observers = new List<IObserver>();
19
    private object state = null;
20

21
    public void Attach(IObserver observer)
22
    {
23
        observers.Add(observer);
24
    }
25

26
    public void Detach(IObserver observer)
27
    {
28
        observers.Remove(observer);
29
    }
30

31
    public void Notify()
32
    {
33
        foreach (var observer in observers)
34
        {
35
            observer.Update(state);
36
        }
37
    }
38
}
39

40
// 4. Concrete Observer
41
public class ConcreteObserver : IObserver
42
{
43
    public void Update(object data)
44
    {
45
        // React to change
46
    }
47
}
48

49
// 5. Usage
50
class Program
51
{
52
    static void Main()
53
    {
54
        ISubject subject = new ConcreteSubject();
55
        IObserver observer = new ConcreteObserver();
56
        subject.Attach(observer);
57
        subject.Notify();
58
    }
59
}

1
// 1. Observer interface
2
type Observer interface{ Update(data any) }
3

4
// 2. Subject interface
5
type Subject interface {
6
  Attach(Observer)
7
  Detach(Observer)
8
  Notify()
9
}
10

11
// 3. Concrete Subject
12
type ConcreteSubject struct {
13
  observers []Observer
14
  state     any
15
}
16

17
func (s *ConcreteSubject) Attach(o Observer) { s.observers = append(s.observers, o) }
18
func (s *ConcreteSubject) Detach(o Observer) {
19
  for i, obs := range s.observers {
20
    if obs == o { s.observers = append(s.observers[:i], s.observers[i+1:]...); return }
21
  }
22
}
23
func (s *ConcreteSubject) Notify() {
24
  for _, o := range s.observers { o.Update(s.state) }
25
}
26

27
// 4. Concrete Observer
28
type ConcreteObserver struct{}
29

30
func (c *ConcreteObserver) Update(data any) {} // React to change
31

32
// 5. Usage
33
// subject := &ConcreteSubject{}
34
// subject.Attach(&ConcreteObserver{})
35
// subject.Notify()

1
// Common Pattern Structure
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

Remember

Observer Pattern decouples subject from observers
It enables dynamic relationships - add/remove at runtime
It follows Open/Closed Principle - easy to extend
Use it when you need one-to-many notification
Don’t use it for simple one-to-one cases - avoid over-engineering!

Interview Focus: Observer Pattern

Key Points to Remember

1. Core Concept

What to say:

“Observer Pattern is a behavioral design pattern that defines a one-to-many dependency between objects. When the subject (the object being observed) changes state, all its observers are automatically notified and updated.”

Why it matters:

Shows you understand the fundamental purpose
Demonstrates knowledge of behavioral patterns category
Indicates you can explain concepts clearly

2. When to Use Observer Pattern

Must mention:

✅ One-to-many dependency - One subject, many observers
✅ Loose coupling - Subject shouldn’t know about specific observers
✅ Dynamic relationships - Add/remove observers at runtime
✅ Avoid polling - No need to constantly check for changes
✅ Event-driven architecture - React to events automatically

Example scenario to give:

“I’d use Observer Pattern when building a stock price monitoring system. When a stock price changes, multiple components need to react - the UI needs to update, alerts need to be sent, analytics need to be recorded. With Observer Pattern, the stock service just notifies all observers, and each handles the update differently.”

3. Structure and Components

Must explain:

Subject (Observable) - The object being observed, maintains list of observers
Observer - Interface for objects that watch the subject
Concrete Subject - Specific subject implementation
Concrete Observer - Specific observer implementations
attach() - Subscribe an observer
detach() - Unsubscribe an observer
notify() - Notify all observers
update() - Observer’s reaction method

Visual explanation:

1
Subject → attach(observer) → Observer list
2
Subject → notify() → Observer.update()

4. Benefits and Trade-offs

Benefits to mention:

Loose Coupling - Subject doesn’t depend on concrete observer classes
Dynamic Relationships - Observers can be added/removed at runtime
Open/Closed Principle - Easy to add observers without modifying subject
Broadcast Communication - One notification reaches all observers
No Polling - Observers don’t need to constantly check

Trade-offs to acknowledge:

Performance - Notifying many observers can be slow
Order of execution - Observers might execute in unpredictable order
Memory leaks - Need to properly unsubscribe observers
Debugging difficulty - Hard to trace notification flow

5. Common Interview Questions

Q: “What’s the difference between Observer Pattern and Pub-Sub Pattern?”

“Observer Pattern has direct communication - the subject knows about observers and calls their update methods directly. Pub-Sub (Publish-Subscribe) Pattern uses a message broker - publishers and subscribers don’t know about each other, they communicate through a broker. Pub-Sub is more decoupled but adds complexity.”

Q: “How do you handle errors in Observer Pattern?”

“I wrap each observer notification in a try-except block. If one observer fails, I log the error and continue notifying other observers. This ensures that one failing observer doesn’t prevent others from being notified. I might also implement a retry mechanism or dead-letter queue for critical observers.”

Q: “How does Observer Pattern relate to SOLID principles?”

“Observer Pattern primarily supports the Open/Closed Principle - you can add new observers without modifying the subject. It also supports Dependency Inversion Principle by making subjects depend on the Observer abstraction rather than concrete observer classes. Additionally, it helps with Single Responsibility Principle by separating the subject’s core logic from notification logic.”

6. Implementation Details

Key implementation points:

Use Abstract Base Class (ABC) for observer interface

💡 Tip: Click dropdown to switch between languages

1
from abc import ABC, abstractmethod
2

3
class Observer(ABC):
4
    @abstractmethod
5
    def update(self, data): pass

1
interface Observer {
2
    void update(Object data);
3
}

1
interface Observer {
2
    update(data: any): void;
3
}

1
class Observer {
2
public:
3
    virtual void update(void* data) = 0;
4
};

1
interface IObserver {
2
    void Update(object data);
3
}

1
type Observer interface {
2
  Update(data any)
3
}

1
// 6. Implementation Details
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

Maintain observer list - Use a list or set to store observers

💡 Tip: Click dropdown to switch between languages

1
def __init__(self):
2
    self._observers: List[Observer] = []

1
private List<Observer> observers = new ArrayList<>();

1
private observers: Observer[] = [];

1
std::vector<Observer*> observers;

1
private List<IObserver> observers = new List<IObserver>();

1
observers []Observer // slice of observers

1
// 6. Implementation Details
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

Handle duplicate subscriptions - Check if observer already exists

💡 Tip: Click dropdown to switch between languages

1
def attach(self, observer: Observer):
2
    if observer not in self._observers:
3
        self._observers.append(observer)

1
void attach(Observer o) {
2
    if (!observers.contains(o)) observers.add(o);
3
}

1
attach(observer: Observer): void {
2
    if (!this.observers.includes(observer))
3
        this.observers.push(observer);
4
}

1
void attach(Observer* o) {
2
    if (std::find(observers.begin(), observers.end(), o) == observers.end())
3
        observers.push_back(o);
4
}

1
public void Attach(IObserver o) {
2
    if (!observers.Contains(o)) observers.Add(o);
3
}

1
func (s *Subject) Attach(o Observer) {
2
  for _, existing := range s.observers {
3
    if existing == o { return } // already subscribed
4
  }
5
  s.observers = append(s.observers, o)
6
}

1
// 6. Implementation Details
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

Error handling - Wrap notifications in try-except

💡 Tip: Click dropdown to switch between languages

1
def notify(self):
2
    for observer in self._observers:
3
        try:
4
            observer.update(self._state)
5
        except Exception as e:
6
            logger.error(f"Error notifying {observer}: {e}")

1
void notifyObservers() {
2
    for (Observer o : observers) {
3
        try { o.update(state); }
4
        catch (Exception e) { logger.error("Error notifying", e); }
5
    }
6
}

1
notify(): void {
2
    for (const o of this.observers) {
3
        try { o.update(this.state); }
4
        catch (e) { console.error("Error notifying", e); }
5
    }
6
}

1
void notify() {
2
    for (auto* o : observers) {
3
        try { o->update(&state); }
4
        catch (const std::exception& e) { /* log error */ }
5
    }
6
}

1
public void Notify() {
2
    foreach (var o in observers) {
3
        try { o.Update(state); }
4
        catch (Exception e) { logger.Error("Error notifying", e); }
5
    }
6
}

1
func (s *Subject) Notify() {
2
  for _, o := range s.observers {
3
    func() {
4
      defer func() {
5
        if r := recover(); r != nil {
6
          log.Printf("Error notifying observer: %v", r)
7
        }
8
      }()
9
      o.Update(s.state)
10
    }()
11
  }
12
}

1
// 6. Implementation Details
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

7. Real-World Examples

Good examples to mention:

Model-View-Controller (MVC) - Model notifies views when data changes
Event-driven systems - UI events, button clicks, form submissions
Stock market - Stock prices notify multiple displays
Logging systems - Log events notify multiple handlers
Notification systems - Order placed notifies email, SMS, push services
GUI frameworks - Widgets notify listeners on events

8. Common Mistakes to Avoid

Mistakes interviewers watch for:

Memory leaks - Not unsubscribing observers
- ❌ Bad: Attach observer, never detach
- ✅ Good: Always detach when observer is no longer needed
Observers modifying subject - Can cause infinite loops
- ❌ Bad: Observer calls subject.set_state() in update()
- ✅ Good: Observer only reacts, doesn’t modify subject
No error handling - One failing observer stops all notifications
- ❌ Bad: No try-except in notify()
- ✅ Good: Wrap each notification in try-except
Order dependencies - Assuming observers execute in specific order
- ❌ Bad: Observer A depends on Observer B executing first
- ✅ Good: Observers are independent

9. Comparison with Other Patterns

Observer vs Strategy:

Observer - One subject notifies many observers about changes
Strategy - One context uses one strategy at a time (algorithm selection)

Observer vs Mediator:

Observer - Direct communication, subject knows about observers
Mediator - Centralized communication through mediator

Observer vs Chain of Responsibility:

Observer - All observers get notified
Chain of Responsibility - Request passes through chain until handled

10. Code Quality Points

What interviewers look for:

✅ Clean code - Readable, well-structured
✅ Type hints - Proper type annotations
✅ Error handling - Handle observer failures gracefully
✅ Memory management - Proper cleanup, avoid leaks
✅ SOLID principles - Follows design principles
✅ Testability - Easy to test and mock

Example of good code:

💡 Tip: Click dropdown to switch between languages

1
from abc import ABC, abstractmethod
2
from typing import List, Dict, Any
3
import logging
4

5
logger = logging.getLogger(__name__)
6

7
class Observer(ABC):
8
    """Interface for observers"""
9
    @abstractmethod
10
    def update(self, data: Dict[str, Any]) -> None:
11
        """Called when subject's state changes"""
12
        pass
13

14
class Subject(ABC):
15
    """Interface for subjects"""
16
    @abstractmethod
17
    def attach(self, observer: Observer) -> None:
18
        """Attach an observer"""
19
        pass
20

21
    @abstractmethod
22
    def detach(self, observer: Observer) -> None:
23
        """Detach an observer"""
24
        pass
25

26
    @abstractmethod
27
    def notify(self) -> None:
28
        """Notify all observers"""
29
        pass
30

31
class WeatherStation(Subject):
32
    """Weather station subject"""
33

34
    def __init__(self):
35
        self._temperature = 0
36
        self._observers: List[Observer] = []
37

38
    def attach(self, observer: Observer) -> None:
39
        """Subscribe an observer"""
40
        if observer not in self._observers:
41
            self._observers.append(observer)
42
            logger.info(f"Observer attached: {observer.__class__.__name__}")
43

44
    def detach(self, observer: Observer) -> None:
45
        """Unsubscribe an observer"""
46
        if observer in self._observers:
47
            self._observers.remove(observer)
48
            logger.info(f"Observer detached: {observer.__class__.__name__}")
49

50
    def notify(self) -> None:
51
        """Notify all observers with error handling"""
52
        data = {"temperature": self._temperature}
53
        for observer in self._observers:
54
            try:
55
                observer.update(data)
56
            except Exception as e:
57
                logger.error(f"Error notifying {observer}: {e}")
58
                # Continue with other observers
59

60
    def set_temperature(self, temperature: float) -> None:
61
        """Set temperature and notify observers"""
62
        self._temperature = temperature
63
        self.notify()

1
import java.util.ArrayList;
2
import java.util.HashMap;
3
import java.util.List;
4
import java.util.Map;
5
import java.util.logging.Logger;
6

7
public interface Observer {
8
    /**
9
     * Called when subject's state changes
10
     */
11
    void update(Map<String, Object> data);
12
}
13

14
public interface Subject {
15
    /**
16
     * Attach an observer
17
     */
18
    void attach(Observer observer);
19

20
    /**
21
     * Detach an observer
22
     */
23
    void detach(Observer observer);
24

25
    /**
26
     * Notify all observers
27
     */
28
    void notifyObservers();
29
}
30

31
public class WeatherStation implements Subject {
32
    private static final Logger logger = Logger.getLogger(WeatherStation.class.getName());
33

34
    private double temperature = 0;
35
    private List<Observer> observers = new ArrayList<>();
36

37
    @Override
38
    public void attach(Observer observer) {
39
        // Subscribe an observer
40
        if (!observers.contains(observer)) {
41
            observers.add(observer);
42
            logger.info("Observer attached: " + observer.getClass().getSimpleName());
43
        }
44
    }
45

46
    @Override
47
    public void detach(Observer observer) {
48
        // Unsubscribe an observer
49
        if (observers.remove(observer)) {
50
            logger.info("Observer detached: " + observer.getClass().getSimpleName());
51
        }
52
    }
53

54
    @Override
55
    public void notifyObservers() {
56
        // Notify all observers with error handling
57
        Map<String, Object> data = new HashMap<>();
58
        data.put("temperature", temperature);
59

60
        for (Observer observer : observers) {
61
            try {
62
                observer.update(data);
63
            } catch (Exception e) {
64
                logger.severe("Error notifying " + observer + ": " + e.getMessage());
65
                // Continue with other observers
66
            }
67
        }
68
    }
69

70
    public void setTemperature(double temperature) {
71
        // Set temperature and notify observers
72
        this.temperature = temperature;
73
        notifyObservers();
74
    }
75
}

1
import { Logger } from './logger';
2

3
const logger = new Logger();
4

5
interface Observer {
6
    /** Called when subject's state changes */
7
    update(data: Record<string, any>): void;
8
}
9

10
interface Subject {
11
    /** Attach an observer */
12
    attach(observer: Observer): void;
13
    /** Detach an observer */
14
    detach(observer: Observer): void;
15
    /** Notify all observers */
16
    notify(): void;
17
}
18

19
class WeatherStation implements Subject {
20
    /** Weather station subject */
21
    private temperature: number = 0;
22
    private observers: Observer[] = [];
23

24
    attach(observer: Observer): void {
25
        /** Subscribe an observer */
26
        if (!this.observers.includes(observer)) {
27
            this.observers.push(observer);
28
            logger.info(`Observer attached: ${observer.constructor.name}`);
29
        }
30
    }
31

32
    detach(observer: Observer): void {
33
        /** Unsubscribe an observer */
34
        const index = this.observers.indexOf(observer);
35
        if (index > -1) {
36
            this.observers.splice(index, 1);
37
            logger.info(`Observer detached: ${observer.constructor.name}`);
38
        }
39
    }
40

41
    notify(): void {
42
        /** Notify all observers with error handling */
43
        const data = { temperature: this.temperature };
44
        for (const observer of this.observers) {
45
            try {
46
                observer.update(data);
47
            } catch (e) {
48
                logger.error(`Error notifying ${observer.constructor.name}: ${e}`);
49
                // Continue with other observers
50
            }
51
        }
52
    }
53

54
    setTemperature(temperature: number): void {
55
        /** Set temperature and notify observers */
56
        this.temperature = temperature;
57
        this.notify();
58
    }
59
}

1
#include <vector>
2
#include <map>
3
#include <string>
4
#include <algorithm>
5
#include <iostream>
6

7
class Observer {
8
public:
9
    virtual ~Observer() = default;
10
    virtual void update(const std::map<std::string, double>& data) = 0;
11
    virtual std::string getName() const = 0;
12
};
13

14
class Subject {
15
public:
16
    virtual ~Subject() = default;
17
    virtual void attach(Observer* observer) = 0;
18
    virtual void detach(Observer* observer) = 0;
19
    virtual void notify() = 0;
20
};
21

22
class WeatherStation : public Subject {
23
private:
24
    double temperature = 0;
25
    std::vector<Observer*> observers;
26

27
public:
28
    void attach(Observer* observer) override {
29
        // Subscribe an observer
30
        if (std::find(observers.begin(), observers.end(), observer) == observers.end()) {
31
            observers.push_back(observer);
32
            std::cout << "Observer attached: " << observer->getName() << std::endl;
33
        }
34
    }
35

36
    void detach(Observer* observer) override {
37
        // Unsubscribe an observer
38
        auto it = std::find(observers.begin(), observers.end(), observer);
39
        if (it != observers.end()) {
40
            observers.erase(it);
41
            std::cout << "Observer detached: " << observer->getName() << std::endl;
42
        }
43
    }
44

45
    void notify() override {
46
        // Notify all observers with error handling
47
        std::map<std::string, double> data;
48
        data["temperature"] = temperature;
49

50
        for (Observer* observer : observers) {
51
            try {
52
                observer->update(data);
53
            } catch (const std::exception& e) {
54
                std::cerr << "Error notifying observer: " << e.what() << std::endl;
55
                // Continue with other observers
56
            }
57
        }
58
    }
59

60
    void setTemperature(double temp) {
61
        // Set temperature and notify observers
62
        temperature = temp;
63
        notify();
64
    }
65
};

1
using System;
2
using System.Collections.Generic;
3

4
public interface IObserver
5
{
6
    /** Called when subject's state changes */
7
    void Update(Dictionary<string, object> data);
8
}
9

10
public interface ISubject
11
{
12
    /** Attach an observer */
13
    void Attach(IObserver observer);
14
    /** Detach an observer */
15
    void Detach(IObserver observer);
16
    /** Notify all observers */
17
    void Notify();
18
}
19

20
public class WeatherStation : ISubject
21
{
22
    /** Weather station subject */
23
    private double temperature = 0;
24
    private List<IObserver> observers = new List<IObserver>();
25

26
    public void Attach(IObserver observer)
27
    {
28
        /** Subscribe an observer */
29
        if (!observers.Contains(observer))
30
        {
31
            observers.Add(observer);
32
            Console.WriteLine($"Observer attached: {observer.GetType().Name}");
33
        }
34
    }
35

36
    public void Detach(IObserver observer)
37
    {
38
        /** Unsubscribe an observer */
39
        if (observers.Remove(observer))
40
        {
41
            Console.WriteLine($"Observer detached: {observer.GetType().Name}");
42
        }
43
    }
44

45
    public void Notify()
46
    {
47
        /** Notify all observers with error handling */
48
        var data = new Dictionary<string, object> { ["temperature"] = temperature };
49
        foreach (var observer in observers)
50
        {
51
            try
52
            {
53
                observer.Update(data);
54
            }
55
            catch (Exception e)
56
            {
57
                Console.Error.WriteLine($"Error notifying observer: {e.Message}");
58
                // Continue with other observers
59
            }
60
        }
61
    }
62

63
    public void SetTemperature(double temp)
64
    {
65
        /** Set temperature and notify observers */
66
        temperature = temp;
67
        Notify();
68
    }
69
}

1
package main
2

3
import (
4
  "fmt"
5
  "log"
6
)
7

8
// Observer interface
9
type Observer interface {
10
  Update(data map[string]any)
11
}
12

13
// Subject interface
14
type Subject interface {
15
  Attach(Observer)
16
  Detach(Observer)
17
  Notify()
18
}
19

20
// WeatherStation - production-ready subject
21
type WeatherStation struct {
22
  observers   []Observer
23
  temperature float64
24
}
25

26
func (ws *WeatherStation) Attach(o Observer) {
27
  for _, existing := range ws.observers {
28
    if existing == o { return }
29
  }
30
  ws.observers = append(ws.observers, o)
31
  fmt.Printf("Observer attached\n")
32
}
33

34
func (ws *WeatherStation) Detach(o Observer) {
35
  for i, obs := range ws.observers {
36
    if obs == o {
37
      ws.observers = append(ws.observers[:i], ws.observers[i+1:]...)
38
      fmt.Printf("Observer detached\n")
39
      return
40
    }
41
  }
42
}
43

44
func (ws *WeatherStation) Notify() {
45
  data := map[string]any{"temperature": ws.temperature}
46
  for _, o := range ws.observers {
47
    func() {
48
      defer func() {
49
        if r := recover(); r != nil {
50
          log.Printf("Error notifying observer: %v", r)
51
        }
52
      }()
53
      o.Update(data)
54
    }()
55
  }
56
}
57

58
func (ws *WeatherStation) SetTemperature(temp float64) {
59
  ws.temperature = temp
60
  ws.Notify()
61
}

1
// 10. Code Quality Points
2
trait Observer {
3
    fn update(&self, event: &str);
4
}
5
struct EmailObserver;
6
impl Observer for EmailObserver {
7
    fn update(&self, event: &str) {
8
        println!("Email: {}", event);
9
    }
10
}
11

12
struct Subject {
13
    observers: Vec<Box<dyn Observer>>,
14
}
15
impl Subject {
16
    fn attach(&mut self, observer: Box<dyn Observer>) {
17
        self.observers.push(observer);
18
    }
19
    fn notify(&self, event: &str) {
20
        for observer in &self.observers {
21
            observer.update(event);
22
        }
23
    }
24
}

Interview Checklist

Before your interview, make sure you can:

Remember: Observer Pattern is about keeping objects informed automatically - when one object changes, all observers get notified without tight coupling! 👀

Share feedback or report an issue