class AbstractSubject:
    def register(self, listener):
        raise NotImplementedError("Must subclass me")
 
    def unregister(self, listener):
        raise NotImplementedError("Must subclass me")
 
    def notify_listeners(self, event):
        raise NotImplementedError("Must subclass me")
 
class Listener:
    def __init__(self, name, subject):
        self.name = name
        subject.register(self)
 
    def notify(self, event):
        print self.name, "received event", event
 
class Subject(AbstractSubject):
    def __init__(self):
        self.listeners = 
        self.data = None
 
    def getUserAction(self):
        self.data = raw_input('Enter something to do:')
        return self.data
 
    # Implement abstract Class AbstractSubject
 
    def register(self, listener):
        self.listeners.append(listener)
 
    def unregister(self, listener):
        self.listeners.remove(listener)
 
    def notify_listeners(self, event):
        for listener in self.listeners:
            listener.notify(event)
 
 
if __name__=="__main__":
    # make a subject object to spy on
    subject = Subject()
 
    # register two listeners to monitor it.
    listenerA = Listener("<listener A>", subject)
    listenerB = Listener("<listener B>", subject)
 
    # simulated event
    subject.notify_listeners ("<event 1>")
    # outputs:
    #     <listener A> received event <event 1>
    #     <listener B> received event <event 1>
 
    action = subject.getUserAction()
    subject.notify_listeners(action)
    #Enter something to do:hello
    # outputs:
    #     <listener A> received event hello
    #     <listener B> received event hello

/* File Name : EventSource.java */
 
package obs;
import java.util.Observable;          //Observable is here
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class EventSource extends Observable implements Runnable 
{
    public void run()
    {
        try
        {   
            final InputStreamReader isr = new InputStreamReader( System.in );
            final BufferedReader br = new BufferedReader( isr );
            while( true )
            {
                final String response = br.readLine();
                setChanged();
                notifyObservers( response );
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

/* File Name: ResponseHandler.java */
 
package obs;
 
import java.util.Observable;
import java.util.Observer;  /* this is Event Handler */
 
public class ResponseHandler implements Observer
{
    private String resp;
    public void update (Observable obj, Object arg)
    {
        if (arg instanceof String)
        {
            resp = (String) arg;
            System.out.println("\nReceived Response: "+ resp );
        }
    }
}

/* Filename : myapp.java */
/* This is main program */
 
package obs;
 
public class MyApp
{
    public static void main(String args)
    {            
        System.out.println("Enter Text >");
 
        // create an event source - reads from stdin
        final EventSource evSrc = new EventSource();
 
        // create an observer
        final ResponseHandler respHandler = new ResponseHandler();
 
        // subscribe the observer to the event source
        evSrc.addObserver( respHandler );
 
        // starts the event thread
        Thread thread = new Thread(evSrc);
        thread.start();
    }
}

using System;
using System.Collections;
 
namespace Wikipedia.Patterns.Strategy
{
	// IObserver --> interface for the observer
	public interface IObserver
	{
		// called by the subject to update the observer of any change
		// The method parameters can be modified to fit certain criteria
		void Update(string message);
	}
 
	public class Subject
	{
		// use array list implementation for collection of observers
		private ArrayList observers;
 
		// constructor
		public Subject()
		{
			observers = new ArrayList();
		}
 
		public void Register(IObserver observer)
		{
			// if list does not contain observer, add
			if (!observers.Contains(observer))
			{
				observers.Add(observer);
			}
		}
 
		public void Unregister(IObserver observer)
		{
			// if observer is in the list, remove
			if (observers.Contains(observer))
			{
				observers.Remove(observer);
			}
		}
 
		public void Notify(string message)
		{
			// call update method for every observer
			foreach (IObserver observer in observers)
			{
				observer.Update(message);
			}
		}
	}
 
	// Observer1 --> Implements the IObserver
	public class Observer1 : IObserver
	{
		public void Update(string message)
		{
			Console.WriteLine("Observer1:" + message);
		}
	}
 
	// Observer2 --> Implements the IObserver
	public class Observer2 : IObserver
	{
		public void Update(string message)
		{
			Console.WriteLine("Observer2:" + message);
		}
	}
 
	// Test class
	public class ObserverTester
	{
		STAThread
		public static void Main()
		{
			Subject mySubject = new Subject();
			IObserver myObserver1 = new Observer1();
			IObserver myObserver2 = new Observer2();
 
			// register observers
			mySubject.Register(myObserver1);
			mySubject.Register(myObserver2);
 
			mySubject.Notify("message 1");
			mySubject.Notify("message 2");
		}
	}
}

using System;
 
// first, declare a delegate type that will be used to fire events.  This is the same delegate as System.EventHandler.
// This delegate serves as the abstract observer.  It does not provide the implementation, but merely the contract.
public delegate void EventHandler(object sender, EventArgs e);
 
// Next, declare a published event.  This serves as the concrete subject.  Note that the abstract subject is handled implicitly by the runtime.
public class Button
{
    // The EventHandler contract is part of the event declaration.
    public event EventHandler Clicked;
 
    // By convention, .NET events are fired from descendant classes by a virtual method, allowing descendant classes to handle the event invocation without
    // subscribing to the event itself.
    protected virtual void OnClicked(EventArgs e)
    {
        if (Clicked != null) 
            Clicked(this, e); // implicitly calls all observers/subscribers
    }
}
 
// Then in an observing class, you are able to attach and detach from the events:
public class Window
{
    private Button okButton;
 
    public Window()
    {
        okButton = new Button();
        // This is an attach function.  Detaching is accomplished with -=.
        // Note that it is invalid to use the assignment operator - events are multicast and can have multiple observers.
        okButton.Clicked += new EventHandler(okButton_Clicked);
    }
 
    private void okButton_Clicked(object sender, EventArgs e)
    {
        // This method is called when Clicked(this, e) is called within the Button class unless it has been detached.
    }
}

#include <list>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
 
// The Abstract Observer
class ObserverBoardInterface
{
public:
    virtual void update(float a,float b,float c) = 0;
};
 
// Abstract Interface for Displays
class DisplayBoardInterface
{
public:
    virtual void show() = 0;
};
 
// The Abstract Subject
class WeatherDataInterface
{
public:
    virtual void registerob(ObserverBoardInterface* ob) = 0;
    virtual void removeob(ObserverBoardInterface* ob) = 0;
    virtual void notifyOb() = 0;
};
 
// The Concrete Subject
class ParaWeatherData: public WeatherDataInterface
{
public:
    void SensorDataChange(float a,float b,float c)
    {
        m_humidity = a;
        m_temperature = b;
        m_pressure = c;
        notifyOb();
    }
 
    void registerob(ObserverBoardInterface* ob)
    {
        m_obs.push_back(ob);
    }
 
    void removeob(ObserverBoardInterface* ob)
    {
        m_obs.remove(ob);
    }
protected:
    void notifyOb()
    {
        list<ObserverBoardInterface*>::iterator pos = m_obs.begin();
        while (pos != m_obs.end())
        {
            ((ObserverBoardInterface* )(*pos))->update(m_humidity,m_temperature,m_pressure);
            (dynamic_cast<DisplayBoardInterface*>(*pos))->show();
            ++pos;
        }
    }
 
private:
    float        m_humidity;
    float        m_temperature;
    float        m_pressure;
    list<ObserverBoardInterface* > m_obs;
};
 
// A Concrete Observer
class CurrentConditionBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
    CurrentConditionBoard(ParaWeatherData& a):m_data(a)
    {
        m_data.registerob(this);
    }
    void show()
    {
        cout<<"_____CurrentConditionBoard_____"<<endl;
        cout<<"humidity: "<<m_h<<endl;
        cout<<"temperature: "<<m_t<<endl;
        cout<<"pressure: "<<m_p<<endl;
        cout<<"_______________________________"<<endl;
    }
 
    void update(float h, float t, float p)
    {
        m_h = h;
        m_t = t;
        m_p = p;
    }
 
private:
    float m_h;
    float m_t;
    float m_p;
    ParaWeatherData& m_data;
};
 
// A Concrete Observer
class StatisticBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
    StatisticBoard(ParaWeatherData& a):m_maxt(-1000),m_mint(1000),m_avet(0),m_count(0),m_data(a)
    {
        m_data.registerob(this);
    }
 
    void show()
    {
        cout<<"________StatisticBoard_________"<<endl;
        cout<<"lowest  temperature: "<<m_mint<<endl;
        cout<<"highest temperature: "<<m_maxt<<endl;
        cout<<"average temperature: "<<m_avet<<endl;
        cout<<"_______________________________"<<endl;
    }
 
    void update(float h, float t, float p)
    {
        ++m_count;
        if (t>m_maxt)
        {
            m_maxt = t;
        }
        if (t<m_mint)
        {
            m_mint = t;
        }
        m_avet = (m_avet * (m_count-1) + t)/m_count;
    }
 
private:
    float m_maxt;
    float  m_mint;
    float m_avet;
    int m_count;
    ParaWeatherData& m_data;
};
 
 
int main(int argc, char *argv)
{
 
    ParaWeatherData * wdata = new ParaWeatherData;
    CurrentConditionBoard* currentB = new CurrentConditionBoard(*wdata);
    StatisticBoard* statisticB = new StatisticBoard(*wdata);
 
    wdata->SensorDataChange(10.2, 28.2, 1001);
    wdata->SensorDataChange(12, 30.12, 1003);
    wdata->SensorDataChange(10.2, 26, 806);
    wdata->SensorDataChange(10.3, 35.9, 900);
 
    wdata->removeob(currentB);
 
    wdata->SensorDataChange(100, 40, 1900);  
 
    delete statisticB;
    delete currentB;
    delete wdata;
 
    return 0;
}

<?php
class Student implements SplObserver{
	protected $tipo = "Student";
	private $nome;
    private $endereco;
	private $telefone;
	private $email;
    private $_classes = array();
 
	public function GET_tipo(){
		return $this->tipo;
	}
 
	public function GET_nome()
	{
		return $this->nome;
	}
 
	public function GET_email()
	{
		return $this->email;
	}
 
	public function GET_telefone()
	{
		return $this->nome;
	}
 
    function __construct($nome) {
     $this->nome = $nome;
    }
 
	public function update(SplSubject $object){
		$object->SET_log("Comes from ".$this->nome.": I'm a student of ".$object->GET_materia());
    }
 
}
 
?>

<?php
class Teacher implements SplObserver{
	protected $tipo = "Teacher";
	private $nome;
    private $endereco;
	private $telefone;
	private $email;
    private $_classes = array();
 
	public function GET_tipo(){
		return $this->tipo;
	}
 
	public function GET_nome()
	{
		return $this->nome;
	}
 
	public function GET_email()
	{
		return $this->email;
	}
 
	public function GET_telefone()
	{
		return $this->nome;
	}
 
    function __construct($nome) {
     $this->nome = $nome;
    }
 
	public function update(SplSubject $object){
		$object->SET_log("Comes from ".$this->nome.": I teach in ".$object->GET_materia());
    }
 
}
 
?>

<?php
 
class Subject implements SplSubject {
 
	private $nome_materia;
	private $_observadores = array();
	private $_log = array();
 
	public function GET_materia()
	{
		return $this->nome_materia;
	}
 
	function SET_log($valor){
		$this->_log = $valor ;
	}
	function GET_log(){
		return $this->_log;
	}
 
	function __construct($nome){
		$this->nome_materia = $nome;
		$this->_log = " Subject $nome was included";
	}
	/* Adiciona um observador */
    public function attach(SplObserver $classes){
        $this->_classes = $classes;
		$this->_log = " The ".$classes->GET_tipo()." ".$classes->GET_nome()." was included";
    }
 
    /* Remove um observador */
    public function detach(SplObserver $classes){
        foreach ($this->_classes as $key => $obj){
            if ($obj == $classes){
                unset($this->_classes$key);
                $this->_log = " The ".$classes->GET_tipo()." ".$classes->GET_nome()." was removed";
            }
        }
    }
 
    /* Notifica os observadores */
    public function notify(){
        foreach ($this->_classes as $classes){
            $classes->update($this);
        }
    }
}
?>

<?php
require_once("teacher.class.php");
require_once("student.class.php");
require_once("subject.class.php");
 
$subject = new Subject("Math");
$marcus = new Teacher("Marcus");
$rafael = new Student("Rafael");
$vinicius = new Student("Vinicius");
// Include observers in the math Subject
$subject->attach($rafael);
$subject->attach($vinicius);
$subject->attach($marcus);
 
$subject2 = new Subject("English");
$renato = new Teacher("Renato");
$fabio = new Student("Fabio");
$tiago = new Student("tiago");
// Include observers in the english Subject
$subject2->attach($renato);
$subject2->attach($vinicius);
$subject2->attach($fabio);
$subject2->attach($tiago);
 
 
// Remove the instance "Rafael from subject"
$subject->detach($rafael);
 
 
// Notify both subjects
$subject->notify();
$subject2->notify();
 
echo "First Subject <br>";
echo "<pre>";
print_r($subject->GET_log());
echo "</pre>";
echo "<hr>";
echo "Second Subject <br>";
echo "<pre>";
print_r($subject2->GET_log());
echo "</pre>";
?>