Пакеты и пространства имен

Определение пространств имен

Пространства имен содержат одно значение, универсальный идентификатор ресурса (URI), который иногда называется именем пространства имен . Идентификатор URI позволяет обеспечить уникальность определения пространства имен.

Пространство имен создается путем объявления определения пространства имен одним из следующих способов. Можно либо определить пространство имен путем явного указания URI, как это делалось бы для пространства имен XML, либо можно пропустить URI. В следующем примере показано, как можно определить пространство имен с помощью URI.

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

Идентификатор URI выступает в качестве уникальной строки идентификации пространства имен. Если идентификатор URI пропущен, как показано в следующем примере, компилятор создаст уникальную внутреннюю строку идентификации вместо этого URI. Доступ пользователя к этой внутренней строке идентификации невозможен.

namespace flash_proxy;

Как только пространство имен определено, с использованием URI или без его использования, это пространство имен не может быть переопределено в той же области действия. Попытка определить пространство имен, которое уже было определено ранее в этой области действия, приведет к ошибке компилятора.

Если пространство имен определяется в пакете или классе, это пространство имен может быть невидимо для программного кода за пределами этого пакета или класса до тех пор, пока не будет использован соответствующий спецификатор контроля доступа. Например, в следующем программном коде показано пространство имен flash_proxy , определенное в пакете flash.utils. В следующем примере отсутствие спецификатора контроля доступа означает, что пространство имен flash_proxy будет видимо только программному коду в самом пакете flash.utils и будет недоступно любому программному коду вне пакета.

package flash.utils 
{ 
    namespace flash_proxy; 
}

В следующем программном коде атрибут public используется для открытия доступа к пространству имени flash_proxy извне этого пакета.

package flash.utils 
{ 
    public namespace flash_proxy; 
}

Применение пространств имен

Применение пространства имен означает размещение определения в пространстве имен. В число определений, которые можно помещать в пространства имен, входят функции, переменные и постоянные (нельзя поместить класс в произвольное пространство имен).

Например, рассмотрим функцию, объявленную с использованием пространства имен для контроля доступа public . Использование атрибута public в определении функции вызывает ее размещение в пространстве имен public, что делает эту функцию доступной для всех программных кодов. Как только пространство имен задано, можно использовать его тем же способом, что и атрибут public , и определение доступно программному коду, из которого можно обращаться к произвольно заданным пространствам имен. Например, если определяется пространство имен example1 , можно добавить метод с названием myFunction() , используя в качестве атрибута example1 , как показано в следующем примере.

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

Объявление метода myFunction() с использованием пространства имен example1 в качестве атрибута означает, что этот метод принадлежит пространству имен example1 .

При применении пространств имен необходимо учитывать следующие правила.

• Для каждого объявления можно применять только одно пространство имен.

• Невозможно применить атрибут пространства имен более чем к одному определению одновременно. Говоря другими словами, если потребуется применить пространство имен к десяти различным функциям, необходимо будет добавить это пространство имен в качестве атрибута к определению каждой из десяти функций.

• Если применяется пространство имен, нельзя также указывать спецификатор контроля доступа, поскольку пространства имен и спецификаторы контроля доступа взаимоисключают друг друга. То есть нельзя объявить функцию или свойство с атрибутом public , private , protected или internal в дополнение к применению пространства имен.

Привязка пространств имен

Нет необходимости явно выполнять привязку к пространствам имен, если используется метод или свойство, объявленные с каким-либо пространством имен для контроля доступа, например атрибутами public , private , protected и internal . Доступ к этим специальным пространствам имен управляется контекстом. Например, определения, помещенные в пространство имен private , автоматически доступны для программных кодов в рамках данного класса. Однако для самостоятельно определенных пространств имен такой контекстной чувствительности не существует. Чтобы использовать метод или свойство, помещенное в произвольное пространство имен, необходимо создать ссылку на это пространство имен.

Привязку пространства имен можно выполнить с помощью директивы use namespace или можно уточнить имя с помощью пространства имен, используя в качестве уточняющего имя знака пунктуации ( :: ). Привязка пространства имен с помощью директивы use namespace открывает пространство имен, так что его можно применять к любому неуточненному идентификатору. Например, если определено пространство имен example1 , можно обращаться к именам в этом пространстве, используя директиву use namespace example1 .

use namespace example1; 
myFunction();

Одновременно может быть открыто сразу несколько пространств имен. Как только пространство имен открыто с помощью директивы use namespace , оно становится открытым для всего блока программного кода, в котором оно открыто. Не существует способов явным образом закрыть пространство имен.

Открытие нескольких пространств имен увеличивает вероятность возникновения конфликтов имен. Если предпочтительнее не открывать пространство имен, можно избежать директивы use namespace , просто уточняя имя метода или свойства с помощью пространства имен и уточняющего имя знака пунктуации. Например, в следующем программном коде показано, как можно уточнить имя myFunction() , используя пространство имен example1 .

example1::myFunction();

Использование пространств имен

Можно найти конкретный пример пространства имен, используемого для предотвращения конфликтов имен в классе flash.utils.Proxy, который входит в состав ActionScript 3.0. Класс Proxy, заменивший класс Object.__resolve , который использовался в ActionScript 2.0, позволяет перехватывать обращения к неопределенным свойствам или методам перед тем, как произойдет ошибка. Все методы класса Proxy находятся в пространстве имен flash_proxy , чтобы предотвратить конфликты имен.

Чтобы лучше понять, как используется пространство имен flash_proxy , необходимо разобраться с порядком использования класса Proxy. Функциональные возможности класса Proxy доступны только для классов, наследуемых из него. То есть если потребуется использовать методы класса Proxy к объекту, определение класса объекта должно расширять класс Proxy. Например, если требуется перехватить попытки вызова неопределенных методов, следует расширить класс Proxy, а затем переписать метод callProperty() в классе Proxy.

Необходимо помнить, что применение пространств имен обычно включает три этапа: определение, применение и привязку. Поскольку методы класса Proxy никогда не вызываются явным образом, то пространство имен flash_proxy только определяется и применяется, но никогда не привязывается. ActionScript 3.0 определяет пространство имен flash_proxy и применяет его в классе Proxy. Затем программному коду необходимо только применить пространство имен flash_proxy к классам, расширяющим класс Proxy.

Пространство имен flash_proxy определяется в пакете flash.utils способом, аналогичным следующему.

package flash.utils 
{ 
    public namespace flash_proxy; 
}

Пространство имен применяется к методам класса Proxy, как показано в следующей выборке из класса Proxy.

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

Как показано в следующем программном коде, необходимо вначале импортировать как класс Proxy, так и пространство имен flash_proxy . Затем следует объявить свой класс, расширяющий класс Proxy (необходимо также добавить атрибут dynamic , если предполагается компиляция в строгом режиме). Когда метод callProperty() будет перезаписан, необходимо использовать пространство имен flash_proxy .

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

Если создается экземпляр класса MyProxy и вызывается неопределенный метод, например метод testing() , см. следующий пример, то объект Proxy перехватывает вызов метода и выполняет инструкции, находящиеся в перезаписанном методе callProperty() (в данном случае простую инструкцию trace() ).

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

Расположение методов класса Proxy в пространстве имен flash_proxy обеспечивает два преимущества. Во-первых, отдельное пространство имен уменьшает беспорядок интерфейса общего доступа для любого класса, расширяющего класс Proxy. (В классе Proxy имеется около двенадцати методов, которые можно перезаписать, все они не предназначены для прямого вызова. Размещение всех их в пространстве имен public может привести к сбоям.) Во-вторых, использование пространства имен flash_proxy предотвращает конфликты имен, в случае если подкласс Proxy содержит методы экземпляров с именами, совпадающими с какими-либо именами методов в классе Proxy. Например, может потребоваться назвать один из создаваемых методов callProperty() . Показанный далее программный код допустим, поскольку созданная версия метода callProperty() находится в другом пространстве имен.

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

Пространства имен также могут быть полезны, если требуется обеспечить доступ к методам или свойствам таким способом, который нельзя организовать четырьмя спецификаторами контроля доступа ( public , private , internal и protected ). Например, может получиться, что несколько служебных методов распределены между несколькими пакетами. Требуется, чтобы эти методы были доступны для всех этих пакетов, но в то же время методы должны быть закрыты для общего доступа. Для решения этой задачи можно создать несколько пространств имен и использовать их в качестве собственных специальных спецификаторов контроля доступа.

В следующем примере определенное пользователем пространство имен используется для группировки двух функций, находящихся в разных пакетах. Группируя их в одном пространстве имен, можно сделать обе функции видимыми для класса и пакета, используя одну инструкцию use namespace .

В этом примере, чтобы продемонстрировать данную технологию, используется четыре файла. Все эти файлы должны находиться в подкаталоге классов. Первый файл, myInternal.as, используется для определения пространства имен myInternal . Поскольку этот файл находится в пакете с именем example, необходимо поместить файл в папку с именем example. Пространство имен помечено как public , поэтому его можно импортировать в другие пакеты.

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

Второй и третий файлы, Utility.as и Helper.as, определяют классы, которые содержат методы, доступные для других пакетов. Класс Utility находится в пакете example.alpha, что означает, что файл должен быть помещен в папку alpha, вложенную в папку example. Класс Helper находится в пакете example.beta, что означает, что файл должен быть помещен в папку beta, вложенную в папку example. Оба этих пакета, example.alpha и example.beta, должны импортировать пространство имен, прежде чем использовать его.

// 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; 
        } 
    } 
}

Четвертый файл, NamespaceUseCase.as, является основным классом приложения и должен располагаться на одном уровне с папкой example. Во Flash Professional этот класс будет использоваться в качестве класса документа для FLA. Класс NamespaceUseCase также импортирует пространство имен myInternal и использует его для вызова двух статических методов, которые находятся в других пакетах. Статические методы в этом примере использованы исключительно для упрощения программного кода. Оба метода, статический и создающий экземпляр, могут размещаться в пространстве имен 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] 
        } 
    } 
}