As3 e Orientação a Objetos >> Herança

Herança no ActionScript 3.0 é definida logo após o nome de uma classe, utilizamos a palavra ‘extends’ para esta tarefa. Ex: Suponha que tenhamos uma classe tela1 que é filha de uma classe telaBase, logo teríamos o código:

package {     public class tela1 extends telaBase  {         public function tela1 ():void{             super();         }     } }

Quando dizemos que uma classe estende a outra (extends) esta classe passa a ser a classe filho e herda todas funções e variáveis da classe pai. Pensando no exemplo anterior isso quer dizer que se na classe pai “telaBase” tivermos a variável ab e a função cd(), poderemos utilizá-los também na classe filho “tela1” desde que o escopo dos mesmos assim permita (desde que ambos não sejam ‘private’).

Ainda em nosso exemplo note que no construtor da classe tela1 existe a instrução “super();”, esta instrução serve para chamar o construtor de sua classe pai.

Sobrescrevendo funções

Para definirmos que uma função irá sobrescrever uma outra função de sua classe pai adicionamos a instrução override na declaração da função na classe filho e nos certificamos que ambos os métodos tenham o mesmo nome.

Suponha que você tenha um projeto onde a classe principal é a seguinte:

package{
    import flash.display.MovieClip;
    public class mainProject extends MovieClip{
        public static var mainProjectRef:MovieClip;
        public static var tela1Ref:tela1;
        public static var tela2Ref:tela2;

         public function mainProject(){
            mainProjectRef = this;
            tela1Ref = new tela1();
            tela2Ref = new tela2();
            tela1Ref.callTela();
        }
    }
}

Ainda no projeto você possui duas classes para representar 2 telas conforme abaixo:

package {
    import flash.events.MouseEvent;
    public class tela1 {
        public var grafico:tela1Grafico;
        public function tela1 ():void{
            this.grafico = new tela1Grafico();
            this.grafico.addEventListener(MouseEvent.CLICK, this.chamaOutraTela);
        }

        public function callTela ():void{
            mainProject.mainProjectRef.addChild(this.grafico);
        }

        public function quit ():void{
            mainProject.mainProjectRef.removeChild(this.grafico);
        }

        public function chamaOutraTela (E:MouseEvent):void{
            this.quit();
            mainProject.tela2Ref.callTela();
        }
    }
}

e

package {
    import flash.events.MouseEvent;
    public class tela2 {
        public var grafico:tela2Grafico;
        public function tela2 ():void{
            this.grafico = new tela2Grafico();
            this.grafico.addEventListener(MouseEvent.CLICK, this.chamaOutraTela);
        }
        public function callTela ():void{
            mainProject.mainProjectRef.addChild(this.grafico);
        }
        public function quit ():void{
            mainProject.mainProjectRef.removeChild(this.grafico);
        }
        public function chamaOutraTela (E:MouseEvent):void{
            this.quit();
            mainProject.tela1Ref.callTela();
        }
    }
}

Note que o comportamento das classes tela1 e tela2 são em grande parte igual exceto pelo tipo da variável “gráfico” e por parte do conteúdo do método chamaOutraTela(). Por terem um comportamento muito semelhante podemos nos beneficiar pelas características do uso de heranças na situação ilustrada. Apesar da variável gráfico ser de tipos diferentes, ambos os tipos são filhos da classe MovieClip por isso podemos criar uma variável na classe pai do tipo MovieClip que será capaz de aceitar valores de ambos os tipos. Para solucionar o problema da implementação diferente do método chamaOutraTela() entre as classes iremos criar um método “fantasma” na classe pai e sobrescrevê-lo nas classes filho. Tendo em mente esses pontos iremos criar uma classe pai telaBase e faremos com que as classes tela1 e tela2 virem filhas de telaBase, veja o código resultante:

package {
    import flash.display.MovieClip;
    import flash.events.MouseEvent;
   
    public class telaBase {
        public var grafico:MovieClip;
        public function telaBase(pGrafico:MovieClip):void{
            this.grafico = pGrafico
            this.grafico.addEventListener(MouseEvent.CLICK, this.chamaOutraTela);
        }
        public function callTela ():void{
            mainProject.mainProjectRef.addChild(this.grafico);
        }
        public function quit ():void{
            mainProject.mainProjectRef.removeChild(this.grafico);
        }
        private function chamaOutraTela(E:MouseEvent):void{
            this.quit();
            this.chamaOutraTela2();
        }
        public function chamaOutraTela2 ():void{  }
    }
}

package {
    public class tela1 extends telaBase  {
        public function tela1 ():void{
            super(new tela1Grafico());
        }
        public override function chamaOutraTela2 ():void{
            mainProject.tela2Ref.callTela();
        }
    }
}

package {
    public class tela2 extends telaBase  {
        public function tela2 ():void{
            super(new tela2Grafico());
        }
        public override function chamaOutraTela2 ():void{
            mainProject.tela1Ref.callTela();
        }
    }
}

Veja que agora todo aquele trecho de código que era semelhante nas classes tela1 e tela2 foi implementado em sua classe pai TelaBase e o trecho onde a execução era diferente entre as classes foi feito através da sobrescrição da função chamaOutraTela2() nas classes filhos tela1 e tela2.

Baixe aqui o código deste exemplo.