=====Description====

Un objet (observable) contient des informations ou des actions que d'autres objets (observateurs) souhaiteraient connaître en cas de modification ou d'appel.

{{:helloworld:design_pattern:observer:observerpattern.png|Diagramme UML Observateur}}

[[https://www.protechtraining.com/bookshelf/java_fundamentals_tutorial/design_patterns?ncr=1|Java Fundamentals Tutorial_ Design Patterns]] {{ :helloworld:design_pattern:java_fundamentals_tutorial_design_patterns_2020-04-29_9_59_57_pm_.html |Archive le 29/04/2020}}

=====Code=====

====Java====

Les interfaces et classes abstraites sont déjà implémentées dans Java.

<file java BeanObservable.java>
package observer;

import java.util.Observable;

public class BeanObservable extends Observable {
  private int nb;

  public int getNb() {
    return nb;
  }

  public void setNb(int nb) {
    this.nb = nb;
    setChanged();
    // C'est notifyObservers qui appelle clearChanged();
    notifyObservers();
  }
}
</file>

<file java Observateur.java>
package observer;

import java.util.Observable;
import java.util.Observer;

public class Observateur implements Observer {
  @Override
  public void update(Observable o, Object arg) {
    System.out.println("Nouvelle valeur détectée : " + ((BeanObservable)o).getNb());
  }
}
</file>

<file java Main.java>
package observer;

public class Main {
  public static void main(String[] args) {
    // On crée l'observé et les deux observateurs
    BeanObservable bean = new BeanObservable();
    Observateur ob1 = new Observateur();
    Observateur ob2 = new Observateur();
		
    // On lit l'observé aux observateurs
    bean.addObserver(ob1);
    bean.addObserver(ob2);
		
    // On change une valeur pour générer l'événement
    bean.setNb(10);
  }
}
</file>

====C++====

===Liste avec shared_ptr===

<code cpp>
#include <algorithm>
#include <iostream>
#include <memory>
#include <vector>

class Observer {
   public:
    ~Observer() { std::cout << "~Observer\n"; }
    void call() { std::cout << "Call\n"; }
};

class Observable {
   public:
    std::vector<std::weak_ptr<Observer>> listener;
    void call() {
        listener.erase(std::remove_if(listener.begin(), listener.end(),
                                      [](std::weak_ptr<Observer> obs) -> bool {
                                          auto ob = obs.lock();
                                          if (ob) {
                                              ob->call();
                                              return false;
                                          } else {
                                              std::cout << "Fails\n";
                                              return true;
                                          }
                                      }),
                       listener.end());
    }
};

int main() {
    auto observer = std::make_shared<Observer>();
    Observable observable;
    observable.listener.push_back(observer);
    observable.call();
    observer = nullptr;
    observable.call();
    std::cout << "END\n";
}
</code>

Résultat:

<code>
Call
~Observer
Fails
END
</code>