Pacotes e namespaces

Definição de espaços para nomes

Os espaços para nomes contêm um valor, o URI (localizador uniforme de recursos), que às vezes é chamado de nome do espaço para nomes . Um URI permite garantir que a definição do espaço para nomes seja exclusiva.

Você cria um espaço para nomes declarando uma definição para ele de duas formas. Você pode definir um espaço para nomes com um URI explícito, assim como definiria um espaço para nomes XML, ou pode omitir o URI. O exemplo a seguir mostra como um espaço para nomes pode ser definido usando um URI:

namespace flash_proxy = "http://www.adobe.com/flash/proxy";

O URI funciona como uma seqüência de caracteres de identificação exclusiva para o espaço para nomes. Se você omitir o URI, como no exemplo a seguir, o compilador cria uma sequência de caracteres de identificação interna exclusiva no lugar do URI. Você não possui acesso a essa seqüência de caracteres de identificação interna.

namespace flash_proxy;

Depois de definido, com ou sem um URI, o espaço para nomes não poderá ser redefinido no mesmo escopo. A tentativa de definir um espaço para nomes definido anteriormente no mesmo escopo irá gerar um erro de compilação.

Se for definido dentro de um pacote ou uma classe, talvez o espaço para nomes não fique visível para o código fora do pacote ou da classe, a menos que seja usado o especificador de controle de acesso apropriado. Por exemplo, o seguinte código mostra o espaço para nomes flash_proxy definido com o pacote flash.utils. No exemplo a seguir, a falta de um especificador de controle de acesso significa que o espaço para nomes flash_proxy deve ser visível apenas para o código dentro do pacote flash.utils e não para qualquer outro código fora do pacote:

package flash.utils 
{ 
    namespace flash_proxy; 
}

O código a seguir usa o atributo public para tornar o espaço para nomes flash_proxy visível para o código fora do pacote:

package flash.utils 
{ 
    public namespace flash_proxy; 
}

Aplicação de espaços para nomes

Aplicar um espaço para nomes significa colocar uma definição em um espaço para nomes. As definições que podem ser colocadas em espaços para nomes incluem funções, variáveis e constantes (não é possível colocar uma classe em um espaço para nomes personalizado).

Considere, por exemplo, uma função declarada usando o espaço para nomes de controle de acesso public . O uso do atributo public em uma definição de função coloca a função no espaço público para nomes, tornando-a disponível para todo o código. Depois de definir um espaço para nomes, você pode usá-lo da mesma forma que usa o atributo public , e a definição fica disponível para o código que pode referenciar o seu espaço para nomes personalizado. Por exemplo, se você definir um espaço para nomes example1 , poderá adicionar um método chamado myFunction() usando example1 como um atributo, como mostra este exemplo:

namespace example1; 
class someClass 
{ 
    example1 myFunction() {} 
}

A declaração do método myFunction() usando o espaço para nomes example1 como um atributo significa que o método pertence ao espaço para nomes example1 .

Tenha em mente o seguinte durante a aplicação de espaços para nomes:

• Você só pode aplicar um espaço para nomes por declaração.

• Não há como aplicar um atributo de espaço para nomes a mais de uma definição por vez. Em outras palavras, se você quiser aplicar seu espaço para nomes a dez funções diferentes, deverá adicioná-lo como um atributo a cada uma das dez definições de função.

• Se aplicar um espaço para nomes, também não será possível definir um especificador de controle de acesso porque espaços para nomes e especificadores de acesso são mutuamente exclusivos. Ou seja, não é possível declarar uma função ou propriedade como public , private , protected ou internal e aplicar o espaço para nomes.

Referência a espaços para nomes

Não é necessário fazer referência a um espaço para nomes explicitamente durante o uso de um método ou uma propriedade declarados com qualquer um dos espaços para nomes de controle de acesso, como public , private , protected e internal . Isso porque o acesso a esses espaços para nomes especiais é controlado por contexto. Por exemplo, as definições colocadas no espaço para nomes private ficam disponíveis automaticamente para o código dentro da mesma classe. Para os espaços para nomes que você definir, porém, essa diferenciação de contexto não existe. Para usar um método ou uma propriedade colocados em um espaço para nomes personalizado, é necessário fazer referência ao espaço para nomes.

Você pode fazer referência a espaços para nomes com a diretiva use namespace ou pode qualificar o nome com o espaço para nomes usando o pontuador do qualificador de nome ( :: ). A referência a um espaço para nomes com a diretiva use namespace "abre" o espaço para nomes, para que ele possa ser aplicado a quaisquer identificadores não qualificados. Por exemplo, se definir o espaço para nomes example1 , você poderá acessar seus nomes usando use namespace example1 :

use namespace example1; 
myFunction();

É possível abrir mais de um espaço para nomes por vez. Quando aberto com use namespace , o espaço para nomes permanecerá aberto em todo o bloco de código no qual se encontra. Não há como fechar explicitamente um espaço para nomes.

O uso de mais de um espaço para nomes, contudo, aumenta a probabilidade de conflitos de nome. Se preferir não abrir um espaço para nomes, você poderá evitar a diretiva use namespace qualificando o nome do método ou da propriedade com o espaço para nomes e o pontuador do qualificador de nome. Por exemplo, o seguinte código mostra como qualificar o nome myFunction() com o espaço para nomes example1 :

example1::myFunction();

Uso de espaços para nomes

Um exemplo real de um espaço para nomes usado para evitar conflitos de nome é a classe flash.utils.Proxy que faz parte do ActionScript 3.0. A classe Proxy, que é a substituição para a propriedade Object.__resolve do ActionScript 2.0, permite interceptar diferenças em propriedades ou métodos não definidos antes da ocorrência de um erro. Todos os métodos da classe Proxy residem no espaço para nomes flash_proxy para evitar conflitos de nome.

Para entender melhor como o espaço para nomes flash_proxy é usado, é preciso entender como usar a classe Proxy. A funcionalidade da classe Proxy está disponível somente para suas classes herdadas. Em outras palavras, se quiser usar os métodos da classe Proxy em um objeto, a definição de classe do objeto deve estender a classe Proxy. Por exemplo, para interceptar as tentativas de chamar um método não definido, é necessário estender a classe Proxy e substituir seu método callProperty() .

Você deve se lembrar de que a implementação de espaços para nomes, em geral, é um processo de três etapas: definir, aplicar e referenciar um espaço para nomes. Como os métodos da classe Proxy nunca são chamados explicitamente, o espaço para nomes flash_proxy é definido e aplicado, mas não referenciado. O ActionScript 3.0 define o espaço para nomes flash_proxy e o aplica na classe Proxy. O código precisa apenas aplicar o espaço para nomes flash_proxy às classes que estendem a classe Proxy.

O espaço para nomes flash_proxy é definido no pacote flash.utils de forma semelhante à seguinte:

package flash.utils 
{ 
    public namespace flash_proxy; 
}

O espaço para nomes é aplicado aos métodos da classe Proxy como mostrado no seguinte trecho dessa classe:

public class Proxy 
{ 
    flash_proxy function callProperty(name:*, ... rest):* 
    flash_proxy function deleteProperty(name:*):Boolean 
    ... 
}

Como mostra o código a seguir, primeiro você deve importar a classe Proxy e o espaço para nomes flash_proxy . Depois, deve declarar sua classe de forma que estenda a classe Proxy (você também deve adicionar o atributo dynamic se estiver compilando no modo estrito). Ao substituir o método callProperty() , o espaço para nomes flash_proxy deve ser usado.

package 
{ 
    import flash.utils.Proxy; 
    import flash.utils.flash_proxy; 
 
    dynamic class MyProxy extends Proxy 
    { 
        flash_proxy override function callProperty(name:*, ...rest):* 
        { 
            trace("method call intercepted: " + name); 
        } 
    } 
}

Se criar uma ocorrência da classe MyProxy e chamar um método não definido, tal como o método testing() chamado no exemplo a seguir, seu objeto Proxy irá interceptar a chamada de método e executar as instruções dentro do método callProperty() (neste caso, uma instrução trace() simples).

var mySample:MyProxy = new MyProxy(); 
mySample.testing(); // method call intercepted: testing

Há duas vantagens em ter os métodos da classe Proxy dentro do espaço para nomes flash_proxy . Primeiro, ter um espaço para nomes separado reduz a desordem na interface pública de qualquer classe que estende a classe Proxy. (Há aproximadamente uma dúzia de métodos na classe Proxy que podem ser substituídos e nenhum foi criado para ser chamado diretamente. Colocá-los no espaço para nomes público poderia gerar confusão.) Em segundo lugar, o uso do espaço para nomes flash_proxy evitará os conflitos de nome caso a subclasse Proxy contenha métodos de ocorrência com nomes que correspondem a qualquer método da classe Proxy. Por exemplo, você pode querer chamar um de seus métodos de callProperty() . O código a seguir é aceitável, porque sua versão do método callProperty() está em um espaço para nomes diferente:

dynamic class MyProxy extends Proxy 
{ 
    public function callProperty() {} 
    flash_proxy override function callProperty(name:*, ...rest):* 
    { 
        trace("method call intercepted: " + name); 
    } 
}

Os espaços para nomes também podem ser úteis para fornecer acesso a métodos ou propriedades de uma forma que não seria possível com os quatro especificadores de controle de acesso ( public , private , internal e protected ). Por exemplo, você pode ter alguns métodos utilitários espalhados em vários pacotes. Você quer disponibilizar esses métodos para todos os pacotes, mas não quer que sejam públicos. Para fazer isso, você pode criar um espaço para nomes e usá-lo como seu próprio especificador de controle de acesso especial.

O exemplo a seguir usa um espaço para nomes definido pelo usuário para agrupar duas funções que residem em pacotes diferentes. Ao agrupá-las no mesmo espaço para nomes, você pode tornar as duas funções visíveis para uma classe ou um pacote por meio de uma única instrução use namespace .

Este exemplo usa quatro arquivos para demonstrar a técnica. Todos os arquivos devem estar no caminho de classe. O primeiro deles, myInternal.as, é usado para definir o espaço para nomes myInternal . Como o arquivo está em um pacote chamado example, você deve colocá-lo em uma pasta chamada example. O espaço para nomes é marcado como public para que possa ser importado para outros pacotes.

// myInternal.as in folder example 
package example 
{ 
    public namespace myInternal = "http://www.adobe.com/2006/actionscript/examples"; 
}

O segundo e terceiro arquivos, Utility.as e Helper.as, definem as classes que contêm os métodos que devem estar disponíveis para outros pacotes. A classe Utility é um pacote example.alpha, o que significa que o arquivo deve ser colocado dentro de uma pasta chamada alpha, que é uma subpasta da pasta example. A classe Helper é um pacote example.beta, o que significa que o arquivo deve ser colocado dentro de uma pasta chamada beta, que também é uma subpasta da pasta example. Os dois pacotes, example.alpha e example.beta, devem importar o espaço para nomes antes de usá-lo.

// Utility.as in the example/alpha folder 
package example.alpha 
{ 
    import example.myInternal; 
     
    public class Utility 
    { 
        private static var _taskCounter:int = 0; 
     
        public static function someTask() 
        { 
            _taskCounter++; 
        } 
         
        myInternal static function get taskCounter():int 
        { 
            return _taskCounter; 
        } 
    } 
} 
 
// Helper.as in the example/beta folder 
package example.beta 
{ 
    import example.myInternal; 
     
    public class Helper 
    { 
        private static var _timeStamp:Date; 
         
        public static function someTask() 
        { 
            _timeStamp = new Date(); 
        } 
         
        myInternal static function get lastCalled():Date 
        { 
            return _timeStamp; 
        } 
    } 
}

O quarto arquivo, NamespaceUseCase.as, é a classe de aplicativo principal e deve ser uma irmã da pasta example. No Flash Professional, essa classe deveria ser usada como a classe de documento para o FLA. A classe NamespaceUseCase também importa o espaço para nomes myInternal e o usa para chamar os dois métodos estáticos que residem nos outros pacotes. O exemplo usa métodos estáticos apenas para simplificar o código. Os métodos estáticos e de ocorrência podem ser colocados no espaço para nomes myInternal .

// NamespaceUseCase.as 
package 
{ 
    import flash.display.MovieClip; 
    import example.myInternal; // import namespace 
    import example.alpha.Utility;// import Utility class 
    import example.beta.Helper;// import Helper class 
     
    public class NamespaceUseCase extends MovieClip 
    { 
        public function NamespaceUseCase() 
        { 
            use namespace myInternal; 
             
            Utility.someTask(); 
            Utility.someTask(); 
            trace(Utility.taskCounter); // 2 
             
            Helper.someTask(); 
            trace(Helper.lastCalled); // [time someTask() was last called] 
        } 
    } 
}