Prá começar, aí está o Diagrama de Classes:

Ele é simples como a estrutura do padrão: as classes que são observadoras implementam a interface IObserver, o sujeito observado implementa a ISubect que, por sua vez, tem um conjunto de IObservers.

Aqui você baixa o código do projeto CS3 em Actionscript 3.0  [download id="3"]

Até a próxima!

Primeiramente, nossa implementação do Observer terá 2 interfaces:

-        IObserver, implementada por todos os observadores que devem responder às mudanças no Sujeito

-        ISubject. Implementada pelo Sujeito Observado.

Trabalhar com essas interfaces simplifica muito a manutenção do código graças ao princípio da substituição de Liskov como veremos no final do artigo. Por enquanto, continuaremos com a implementação.

Nossa interface IObserver terá somente o método Atualizar(direcao:String):void. Esse é o único método que todos os outros observadores do meu sistema deverão ter. "E o que ele faz, Tiago?" Esse é o método que atualiza a direção do Observador baseado na direção que o Sujeito Observado tomar em um dado instante.

package Observer

{
	public interface IObserver
	{
		function Atualizar(direcao:String):void;
	}
}

Nossos Sujeitos, porém, terão outras funcionalidades: ISubject deverá ter um método para registrar novos observadores e um outro para notificá-los sobre as mudanças de direção.

package Observer

{
	import Observer.IObserver;

	public interface ISubject
	{
		function RegistrarObservador(observador:IObserver):void;
		function NotificarObservador():void;
	}
}

Esse é nosso jato, um sujeito observado pelos mísseis teleguiados. Notem que, por ser um sujeito, ele obrigatoriamente deve implementar a interface ISubject que criamos e, consequentemente, também seus métodos.

package Observer
{

	public class TJato implements ISubject
	{
		private var _observadores:Array;
		private var _direcao:String;

		public function TJato(direcao:String)
		{
		this._observadores = new Array();
		this._direcao = direcao;
		}

/***************************************************************

Adiciona um observador à coleção de observadores do sujeito  ...

... observado, para que ele possa notificá-los quando seu    ...

... estado mudar.

Por ser passado um objeto IObservador, TODA E QUALQUER...

... CLASSE pode se tornar um observador, desde que ...

... implemente a interface IObserver.

****************************************************************/

		public function RegistrarObservador(observador:IObserver):void
		{
			// Adiciono um observador à lista...
			this._observadores.push(observador);

			// ... e aviso a todo mundo quem foi registrado
			trace ("observador registrado: "+ observador);
		}

/***************************************************************

Varre a coleção de observadores, enviando à eles o novo estado.

... Utiliza a metodologia de empurrar dados observados.

****************************************************************/

		public function NotificarObservador():void
		{
			for(var i:int=0; i<this._observadores.length; i++)
			this._observadores[i].Atualizar(this._direcao);
		}

/***************************************************************

Retorna a direção para onde o Jato está voando

****************************************************************/

		public function RetornarDirecao():String
		{
			return this._direcao;
		}

/***************************************************************

Modifica a direção do Jato para uma nova direção

****************************************************************/

		public function ModificarDirecao(direcao:String):void
		{
			this._direcao=direcao;
			this.NotificarObservador();
		}
	}
}

O míssil terá somente esses 2 métodos. Note que eles são passivos, fazendo com que o funcionamento da classe dependenda exclusivamente do que é passado para ela.

package Observer
{

	public class TMissil implements IObserver
	{
		private var _direcao:String;

		public function TMissil(direcao:String)
		{
			this._direcao = direcao;
		}

/***************************************************************
Atualiza a direção para onde o Míssil está indo
****************************************************************/

		public function Atualizar(direcao:String):void
		{
			this._direcao = direcao;
		}

/***************************************************************
Retorna a direção para onde o Míssil está voando
****************************************************************/

		public function RetornarDirecao():String
		{
			return this._direcao;
		}
	}
}

Por fim, nossa classe principal, a TMain. Nela vamos realizar uma sequência de testes da funcionalidade do Observer.

package
{
	import flash.display.MovieClip;
	import Observer.IObserver;
	import Observer.ISubject;
	import Observer.TJato;
	import Observer.TMissil;
	import Observer.THelicoptero;

	public class TMain extends MovieClip
	{
		private var _jato:TJato;
		private var _missil1:TMissil;
		private var _missil2:TMissil;

		private var _helicoptero:THelicoptero;

		public function TMain()
		{
			//Inicia a direção do Jato e dos mísseis
			this._jato = new TJato("CIMA");
			this._missil1 = new TMissil("BAIXO");
			this._missil2 = new TMissil("PARADO");

			//Exibe a direção dos objetos na tela
			trace( "Direção do jato: "
				  + this._jato.RetornarDirecao() );
			trace( "Direção do míssil 1: "
				  + this._missil1.RetornarDirecao() );
			trace( "Direção do míssil 2: "
				  + this._missil2.RetornarDirecao() );

			//Como os mísseis devem observar o ...
			//... comportamento do jato,...
			//... eles são registrados como...
			//... observadores do jato.

			trace("---------------------------------------------------------");

			trace ("Registrando observadores");
			this._jato.RegistrarObservador(this._missil1);
			this._jato.RegistrarObservador(this._missil2);

			trace("---------------------------------------------------------");

			trace("modificando a direção do jato prá BAIXO");

			//Altera a direção do jato...
			this._jato.ModificarDirecao("BAIXO");

			//... e exibe a direção dos objetos na tela
			trace( "Direção do jato: "
				  + this._jato.RetornarDirecao() );
			trace( "Direção do míssil 1: "
				  + this._missil1.RetornarDirecao() );
			trace( "Direção do míssil 2: "
				  + this._missil2.RetornarDirecao() );

			/*
			Caso um desenvolvedor queira estender a ...
			... funcionalidade do programa ...
			... adicionando um novo tipo de
			... observador, ele pode fazê-lo sem   ...
			... a necessidade de mexer no código atual.
			Para isso, basta ...
			... adicionar sua nova classe ...
			... (THelicoptero, nesse caso), fazê-la ...
			... implementar a interface IObserver ...
			... e adicioná-lo à lista de ...
			... chamadas de objetos de perseguição.
			Veja no exemplo abaixo:
			*/

			trace("---------------------------------------------------------");
			trace("Registrando observadores");

			//O Helicóptero entra na perseguição ...
			this._helicoptero = new THelicoptero("LESTE");
			// ... sendo registrado também como observador
			this._jato.RegistrarObservador(this._helicoptero);

			trace("---------------------------------------------------------");

			//Altera a direção do jato...
			trace("modificando a direção do jato prá CIMA");
			this._jato.ModificarDirecao("CIMA");

			//... e exibe a direção dos objetos na tela
			trace( "Direção do jato: "
				  + this._jato.RetornarDirecao() );
			trace( "Direção do míssil 1: "
				  + this._missil1.RetornarDirecao() );
			trace( "Direção do míssil 2: "
				  + this._missil2.RetornarDirecao() );
			trace( "Direção do helicóptero: "
				  + this._helicoptero.RetornarDirecao() );
		}
	}
}

A saída desse código é a seguinte:

Direção do jato: CIMA
Direção do míssil 1: BAIXO
Direção do míssil 2: PARADO
---------------------------------------------------------
Registrando observadores
observador registrado: [object TMissil]
observador registrado: [object TMissil]
---------------------------------------------------------
modificando a direção do jato prá BAIXO
Direção do jato: BAIXO
Direção do míssil 1: BAIXO
Direção do míssil 2: BAIXO
---------------------------------------------------------
Registrando observadores
observador registrado: [object THelicoptero]
---------------------------------------------------------
modificando a direção do jato prá CIMA
Direção do jato: CIMA
Direção do míssil 1: CIMA
Direção do míssil 2: CIMA
Direção do helicóptero: CIMA

"Mas Tiago... Que helicóptero foi aquele ali no meio do código?" Ah é... enquanto estávamos fazendo o código, um outro desenvolvedor achou que helicópteros também são maneiros em perseguições e resolveu implementar um. Notaram como foi fácil adicioná-lo? Bastou que ele implementasse a IObserver que o princípio de Liskov tomou conta do resto. Caso eu queria mais de um Sujeito observado, minha nova classe implementará ISubject. Dessa forma, adicionar observadores ou sujeitos não implica em modificação alguma no código que já estava pronto.

“Outra coisa: e se um observador não quiser mais ser avisado sobre as mudanças do sujeito?” Para isso, a IObserver deverá ter um método removerObservador (observador:IObserver) : void; que vai varrer a lista de observadores e retirá-lo de lá. Isso fica como exercício para quem quiser continuar estudando o padrão.

Na próxima - e última - parte do artigo, disponibilizarei o projeto em AS3.0 e o diagrama de Classes disso tudo ae. Então, até a próxima!