Se você reparar bem, quando falamos de aproveitamento de código em OOP, esse padrão é a base de quase tudo – ou a base de quase tudo se parece muito com ele. O problema dele em relação ao ActionScript é que ele é baseado em classes e métodos abstratos e como a linguagem ainda não disponibiliza este recurso, podemos apenas tapar um olho e simular o padrão.

Nota: Eu particularmente gosto de usar o prefixo Base em todas as classes que crio em AS e que em teoria deveriam ser classes abstratas. Ao menos assim existe uma forma simples e rápida de identificá-las dentro da estrutura de um projeto ou framework.

Segue um exemplo extremamente simples (e sem funcionalidade) só para entendermos alguns conceitos. 

Classe “abstrata”:

package
{
	public class BaseTest extends MovieClip
	{
		public function BaseTest()
		{
		}
 
		// definindo um método que não pode ser sobrescrito
		public final function finalMethod():void
		{
			// chamada a método opcional (gancho)
                        this.hookMethod();
 
                        // implementação padrão
			this.x = 200;
 
			// chamada ao método que será sobrescrito
			this.customMethod();
		}
 
		// método que deveria ser abstrato
		protected function customMethod():void
		{
			// implementação na classe concreta
		}
 
		// método gancho que pode ou não ser sobrescrito
		protected override function hookMethod():void
		{
		}
        }
}

Classe concreta:

package
{
	public class CustomTest extends BaseTest
	{
		public function CustomTest()
		{
		}
 
		// método que deveria ser abstrato
		protected override function customMethod():void
		{
			// implementação personalizada obrigatória
			this.y = 45;
                }
        }
}

Neste padrão as chamadas normalmente ocorrem mem modo inverso daqueles que normalmente aplicamos. Ao invés de fazer a chamada ao código comum (ou código reutilizado) na classe filha (CustomTest), fazemos as chamadas pela classe pai (BaseTest). Assim, é possivel garantir o fluxo de execução das tarefas pelo objeto.

Podemos observar também que na classe “abstrata” os métodos públicos (que são implementados) são declarados com a palavra reservada final, isto significa (garante) que ele não poderá ser sobrescrito. Os métodos personalizáveis, ao contrário, são declarados como protected permitindo que sejam sobrescritos através de herança.

As principais chamadas que a classe “abstrata” faz são as seguintes:

Métodos concretos

Da classe abstrata – implementações úteis a todas as classes filhas -, da classe concreta ou de outras classes.

Métodos abstratos

Devem obrigatoriamente ser sobrescritos. Isto é um problema pois não conseguimos garantir a sobrescrita de um método utilizando ActionScript a não ser que seja por interfaces.

Métodos ganchos

Podem ou não ser sobrescritos e são uma implementação opcional. É uma maneira de utilizar herança de forma controlada. Estes métodos não possuem implementação na classe abstrata.

É interessante que ao usar essa idéia em ActionScript seja definido um padrão para os nomes dos métodos, que facilite a identificação do métodos que são obrigatórios (teoricamente abstratos) e dos que são opcionais, ainda que não se tenha a garantia de um método abastrato.