Observer pattern

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");
                }
        }
}

class AbstractObserve_me:
    def __init__(self):
        pass
    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(AbstractObserve_me):
    def __init__(self):
        self.listeners = []
        self.data=None
     #--------------------------
    "Implement abstract Class AbsObserve_me"
    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)
    #----------
    def getUserAction(self):
        self.data = raw_input('Enter something to do:')
        return self.data
 
 
 
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();
    }
}