Классы

ActionScript 3.0 обеспечивает четыре специальных атрибута для управления доступом к свойствам, определенным внутри класса: public , private , protected и internal .

Атрибут public делает свойство видимым во всем сценарии. Например, чтобы сделать метод доступным для кода за пределами пакета, необходимо объявить его с атрибутом public . Это относится ко всем свойствам независимо от того, с использованием каких ключевых слов они объявлены: var , const или function .

Атрибут private делает свойство видимым только для вызывающих методов внутри определяющего класса данного свойства. Это поведение отличает его от атрибута private в ActionScript 2.0, который разрешал подклассу доступ к закрытому свойству суперкласса. Другое значительное изменение поведение имеет отношение к доступу во время выполнения. В ActionScript 2.0 ключевое слово private запрещало доступ только во время компиляции, а во время выполнения этот запрет можно было легко обойти. В ActionScript 3.0 это уже не удастся. Свойства, помеченные атрибутом private , остаются недоступными как во время компиляции, так и во время выполнения.

Например, следующий код создает простой класс с именем PrivateExample с одной закрытой переменной, а затем к этой переменной пытается обратиться внешний метод.

class PrivateExample 
{ 
    private var privVar:String = "private variable"; 
} 
 
var myExample:PrivateExample = new PrivateExample(); 
trace(myExample.privVar);// compile-time error in strict mode 
trace(myExample["privVar"]); // ActionScript 2.0 allows access, but in ActionScript 3.0, this is a run-time error. 

В ActionScript 3.0 попытка обращения к свойству с помощью оператора «точка» ( myExample.privVar ) приведет к ошибке компиляции, если используется строгий режим. В противном случае ошибка появляется во время выполнения, как и в случае использования оператора доступа к свойству ( myExample["privVar"] ).

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

В классах, объявленных с использованием атрибута dynamic , попытки обращения к закрытым свойствам не приведут к ошибкам выполнения. Переменная не является видимой, поэтому возвращается значение undefined . Однако ошибка компиляции возникает, если в строгом режиме используется оператор «точка». Следующий пример похож на предыдущий и отличается от него только тем, что класс PrivateExample объявляется с атрибутом dynamic.

dynamic class PrivateExample 
{ 
    private var privVar:String = "private variable"; 
} 
 
var myExample:PrivateExample = new PrivateExample(); 
trace(myExample.privVar);// compile-time error in strict mode 
trace(myExample["privVar"]); // output: undefined

Динамические классы обычно возвращают значение undefined вместо ошибки, когда внешний код пытается обратиться к закрытому свойству класса. В следующей таблице показано, что ошибка выдается, только когда оператор «точка» используется для обращения к закрытому свойству в строгом режиме.

Атрибут protected , впервые введенный в версии ActionScript 3.0, делает свойство видимым для вызывающих методов собственного класса или подкласса. Другими словами, защищенное свойство доступно для собственного класса и подклассов, находящихся под ним в иерархии наследования. Оно доступно даже для подклассов, находящихся в других пакетах.

Для пользователей, знакомых со средой ActionScript 2.0, эта возможность аналогична атрибуту private в среде ActionScript 2.0. Атрибут protected среды ActionScript 3.0 также равнозначен атрибуту protected в Java. Он отличается от атрибута в версии Java тем, что также разрешает доступ к вызывающим объектам в том же пакете. Атрибут protected полезен, когда имеется свойство (переменная или метод), необходимое для подкласса, которое требуется скрыть для кода, находящегося за пределами цепи наследования.

Атрибут internal , впервые введенный в версии ActionScript 3.0, делает свойство видимым для вызывающих методов внутри своего пакета. Это атрибут по умолчанию для кода внутри пакета, он применяется ко всем свойствам, у которых нет ни одного из перечисленных ниже атрибутов:

• public ;

• private ;

• protected ;

• пространство имен, определенное пользователем.

Атрибут internal похож на управление доступом по умолчанию в Java. Однако в Java нет выраженного имени для этого уровня доступа, и его можно реализовать только путем опущения других модификаторов доступа. Атрибут internal введен в ActionScript 3.0, чтобы можно было выразить намерение сделать свойство доступным только для вызывающих методов в его собственном пакете.

Атрибут static , который может использоваться со свойствами, объявленными с использованием ключевых слов var , const или function , позволяет присоединить свойство к классу, а не к его экземплярам. Внешний код должен вызывать статические свойства с использованием имени класса, а не экземпляра.

Статические свойства не наследуются подклассами, но входят в цепочку области действия подкласса. Это означает, что в теле подкласса статическое свойство (переменная или метод) может использоваться без ссылки на класс, в котором оно было определено.

В качестве альтернативы предварительно определенным атрибутам управления доступом можно создать пользовательское пространство имен и использовать его как атрибут. Для одного определения можно использовать только один атрибут пространства имен. Кроме того, нельзя использовать атрибут пространства имен в сочетании с другими атрибутами управления доступом ( public , private , protected , internal ).

Методы-конструкторы (иногда их называют просто конструкторами ) представляют собой функции с тем же именем, которым назван класс, в котором они определены. Любой код, включенный в метод-конструктор, выполняется при каждом создании экземпляра класса с использованием ключевого слова new . Например, следующий код определяет простой класс Example, содержащий одно свойство с именем status . Начальное значение переменной status задается в функции конструктора.

class Example 
{ 
    public var status:String; 
    public function Example() 
    { 
        status = "initialized"; 
    } 
} 
 
var myExample:Example = new Example(); 
trace(myExample.status); // output: initialized

Методы-конструкторы могут быть только открытыми, но использование атрибута public является необязательным. Для конструктора нельзя использовать никаких других спецификаторов управления доступом, включая private , protected или internal . Кроме того, с методом-конструктором нельзя использовать пользовательское пространство имен.

Конструктор может явно вызвать конструктор находящегося непосредственно над ним суперкласса с помощью инструкции super() . Если конструктор суперкласса не вызывается явно, компилятор автоматически вставляет вызов перед первой инструкцией в теле конструктора. Также вызывать методы суперкласса можно, используя префикс super в качестве ссылки на суперкласс. Если в теле одного конструктора требуется использовать и конструктор super() , и префикс super , первым должен идти конструктор super() . В противном случае ссылка super может повести себя не так, как предполагалось. Конструктор super() также необходимо вызывать перед инструкциями throw или return .

В следующем примере показано, что происходит при попытке использования ссылки super перед вызовом конструктора super() . Новый класс, ExampleEx, расширяет класс Example. Конструктор ExampleEx пытается получить переменную status, определенную в его суперклассе, но делает это перед вызовом super() . Инструкция trace() в конструкторе ExampleEx возвращает значение null , так как переменная status недоступна, пока не будет вызван конструктор super() .

class ExampleEx extends Example 
{ 
    public function ExampleEx() 
    { 
        trace(super.status); 
        super(); 
    } 
} 
 
var mySample:ExampleEx = new ExampleEx(); // output: null

Хотя в конструкторе можно использовать инструкцию return , он не может вернуть значение. Другими словами, инструкции return не должны иметь связанных выражений или значений. Соответственно, методы-конструкторы не могут возвращать значения, вследствие чего невозможно указать тип возврата.

Если для класса не определить метод-конструктор, компилятор автоматически создает пустой конструктор. Если данный класс расширяет другой, компилятор включает вызов super() в созданный им конструктор.

Статические методы, также называемые методами класса — это методы, которые объявляются с использованием ключевого слова static . Статические методы, присоединяемые к классу, а не к его экземпляру, полезны для инкапсуляции, которая затрагивает не только состояние отдельного экземпляра. Так как статические методы присоединяются ко всему классу, их можно вызвать только через класс, а через его экземпляр — нет.

Статические методы полезны для инкапсуляции, действие которой не ограничивается состоянием экземпляров класса. Другими словами, метод должен быть статическим, если он обеспечивает функцию, которая не оказывает прямого влияния на значение экземпляра класса. Например, класс Date имеет статический метод parse() , который преобразует строку в число. Это статический метод, так как он не оказывает влияния на отдельные экземпляры класса. Вместо этого метод parse() берет строку, которая представляет собой значение даты, анализирует ее и возвращает число в формате, совместимом с внутренним представлением объекта Date. Этот метод не является методом экземпляра, так как его бессмысленно применять к одному экземпляру класса Date.

Сравните статический метод parse() с одним из методов экземпляра класса Date, таким как getMonth() . Метод getMonth() является методом экземпляра, так как он воздействует непосредственно на значение экземпляра, получая определенный компонент (месяц) экземпляра Date.

Так как статические методы не связаны с отдельными экземплярами, в их теле нельзя использовать ключевые слова this и super . Ссылки this и super имеют значение, только в контексте метода экземпляра.

В отличие от других языков программирования на базе классов, в ActionScript 3.0 статические методы не наследуются.

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

В теле метода экземпляра могут содержаться и статические переменные, и переменные экземпляра. Это означает, что на переменные, определенные в одном классе, можно ссылаться с использованием простого идентификатора. Например, следующий класс, CustomArray, расширяет класс Array. Класс CustomArray определяет статическую переменную arrayCountTotal для отслеживания общего числа экземпляров класса, переменную экземпляра arrayNumber , отслеживающую порядок создания экземпляров, и метод экземпляра getPosition() , возвращающий значения этих переменных.

public class CustomArray extends Array 
{ 
    public static var arrayCountTotal:int = 0; 
    public var arrayNumber:int; 
 
    public function CustomArray() 
    { 
        arrayNumber = ++arrayCountTotal; 
    } 
     
    public function getArrayPosition():String 
    { 
         return ("Array " + arrayNumber + " of " + arrayCountTotal); 
    } 
}

Хотя внешний код класса должен обращаться к статической переменной arrayCountTotal через объект класса с помощью CustomArray.arrayCountTotal , код, находящийся внутри тела метода getPosition() , может ссылаться непосредственно на статическую переменную arrayCountTotal . Это относится даже к статическим переменным суперклассов. Хотя статические свойства не наследуются в ActionScript 3.0, статические свойства суперклассов входят в область действия. Например, класс Array имеет несколько статических переменных, одна из которых является константой с именем DESCENDING . Код, находящийся в подклассе Array, может обращаться к статической константе DESCENDING с помощью простого идентификатора:

public class CustomArray extends Array 
{ 
    public function testStatic():void 
    { 
        trace(DESCENDING); // output: 2 
    } 
}

Значением ссылки this в теле метода экземпляра является ссылка на экземпляр, к которому присоединен метод. Следующий код демонстрирует, как ссылка this указывает на экземпляр, содержащий метод.

class ThisTest 
{ 
    function thisValue():ThisTest 
    { 
        return this; 
    } 
} 
 
var myTest:ThisTest = new ThisTest(); 
trace(myTest.thisValue() == myTest); // output: true

Наследованием методов экземпляров можно управлять с помощью ключевых слов override и final . Атрибут override можно использовать для переопределения унаследованного метода, а атрибут final — для запрета переопределения метода подклассами.

Методы доступа get и set, также называемые getter и setter , позволяют соблюдать принципы сокрытия информации и инкапсуляции, обеспечивая простой в использовании интерфейс программирования для создаваемых классов. Функции get и set позволяют делать свойства класса закрытыми, но при этом пользователи класса могут обращаться к этим свойствам так, будто они обращаются к переменной класса, а не вызывают метод класса.

Преимущество такого подхода заключается в том, что он позволяет отказаться от традиционных функций методов доступа с громоздкими именами, такими как getPropertyName() и setPropertyName() . Другое преимущество методов get и set состоит в том, что они позволяют избежать создания двух открытых функций для каждого свойства, разрешающего доступ для чтения и записи.

Следующий пример класса GetSet включает методы доступа get и set с именем publicAccess() , которые обеспечивают доступ к закрытой переменной privateProperty .

class GetSet 
{ 
    private var privateProperty:String; 
     
    public function get publicAccess():String 
    { 
        return privateProperty; 
    } 
     
    public function set publicAccess(setValue:String):void 
    { 
        privateProperty = setValue; 
    } 
}

Если обратиться к свойству privateProperty напрямую, возникает ошибка, как показано ниже.

var myGetSet:GetSet = new GetSet(); 
trace(myGetSet.privateProperty); // error occurs

Вместо этого пользователь класса GetSet использует свойство, похожее на свойство publicAccess , но на самом деле являющееся парой функций методов доступа get и set, которые работают с закрытым свойством privateProperty . В следующем примере создается экземпляр класса GetSet, а затем задается значение свойства privateProperty с помощью открытого метода доступа publicAccess .

var myGetSet:GetSet = new GetSet(); 
trace(myGetSet.publicAccess); // output: null 
myGetSet.publicAccess = "hello"; 
trace(myGetSet.publicAccess); // output: hello

Функции get и set также позволяют переопределять свойства, унаследованные от суперкласса, что невозможно выполнить при использовании обычных переменных-членов класса. Переменные-члены класса, объявленные с использованием ключевого слова var , не могут переопределяться в подклассе. Однако это ограничение не распространяется на свойства, созданные с помощью функций get и set. Для функций get и set, унаследованных от суперкласса, можно использовать атрибут override .

Связанный метод, иногда называемый замыканием метода — это метод, извлеченный из своего экземпляра. К числу связанных методов относятся методы, переданные функции в качестве аргументов или возвращенные функцией в качестве значений. Впервые в ActionScript 3.0 связанный метод уподобляется замыканию функции в том, что он сохраняет всю свою лексическую среду даже при извлечении из экземпляра. Однако между связанным методом и замыканием функции есть важное отличие: ключевое слово this для связанного метода продолжает ссылаться на экземпляр, в котором реализуется метод, то есть остается связанным с ним. Другими словами, ссылка this в связанном методе всегда указывает на исходный объект, в котором определен метод. Для замыканий функций ссылка this является общей, то есть она указывает на любой объект, с которым связана функция в момент вызова.

Важно понимать суть связанных методов, если используется ключевое слово this . Как вы помните, ключевое слово this обеспечивает ссылку на родительский объект метода. Большинство программистов, использующих ActionScript, считают, что ключевое слово this всегда представляет объект или класс, содержащий определение метода. Однако это не всегда так, если не применяется связывание метода. Например, в предыдущих версиях ActionScript ключевое слово this не всегда ссылается на экземпляр, в котором реализован метод. Когда методы извлекаются из экземпляра в ActionScript 2.0, ссылка this не связывается с исходным экземпляром, а переменные и методы экземпляра становятся недоступными. В ActionScript 3.0 этого не происходит, так как при передаче методов в качестве параметра автоматически создаются связанные методы. Связанные методы обеспечивают, чтобы ключевое слово this всегда ссылалось на объект или класс, в котором определяется метод.

Следующий код определяет класс ThisTest, который содержит метод foo() , определяющий связанный метод, и метод bar() , возвращающий связанный метод. Внешний код создает экземпляр класса ThisTest, создает метод bar() и сохраняет возвращенное значение в переменной myFunc .

class ThisTest 
{ 
    private var num:Number = 3; 
    function foo():void // bound method defined 
    { 
        trace("foo's this: " + this); 
        trace("num: " + num); 
    } 
    function bar():Function 
    { 
        return foo; // bound method returned 
    } 
} 
 
var myTest:ThisTest = new ThisTest(); 
var myFunc:Function = myTest.bar(); 
trace(this); // output: [object global] 
myFunc(); 
/* output:  
foo's this: [object ThisTest] 
output: num: 3 */

Две последние строки кода показывают, что ссылка this в связанном методе foo() по-прежнему указывает на экземпляр класса ThisTest, несмотря на то, что ссылка this в предшествующей строке указывает на глобальный объект. Более того, связанный метод, сохраненный в переменной myFunc , сохранил доступ к переменным-членам класса ThisTest. Если выполнить этот же код в ActionScript 2.0, ссылки this будут одинаковыми, а переменная num получит значение undefined .

Добавление связанных методов имеет самое большое значение, когда речь идет об обработчиках событий, так как метод addEventListener() требует, чтобы в качестве аргумента передавалась функция или метод.

Чтобы встроить ресурс, сначала поместите его в библиотеку FLA-файла. Затем используйте свойство связывания ресурса, чтобы передать имя для его класса встроенных ресурсов. Если класса с таким именем нет в пути к классам, он создается автоматически. После этого можно создать экземпляр класса встроенных ресурсов и использовать любые определенные или унаследованные им свойства и методы. Например, следующий код можно использовать для воспроизведения встроенного звука, связанного с классом встроенных ресурсов PianoMusic.

var piano:PianoMusic = new PianoMusic(); 
var sndChannel:SoundChannel = piano.play();

В противном случае можно использовать тег метаданных [Embed] для встраивания ресурсов в проект Flash Professional, как описано далее. Если в коде используется тег метаданных [Embed] , в инструменте Flash Professional для компиляции проекта используется компилятор Flex, а не компилятор Flash Professional.

При компиляции кода с помощью компилятора Flex для встраивания ресурса в код ActionScript используйте тег метаданных [Embed] . Поместите ресурс в основной исходной папке или в другой папке, включенной в путь сборки проекта. Когда компилятор Flex обнаружит тег метаданных Embed, он создаст класс встроенных ресурсов. Обратиться к классу можно через переменную типа данных Class, объявленную сразу после тега метаданных [Embed] . Например, следующий код встраивает звук с именем sound1.mp3 и использует переменную soundCls для хранения ссылки на класс встроенных ресурсов, связанный с этим звуком. После этого создается экземпляр класса встроенных ресурсов, для которого вызывается метод play() .

package 
{ 
    import flash.display.Sprite; 
    import flash.media.SoundChannel; 
    import mx.core.SoundAsset; 
 
    public class SoundAssetExample extends Sprite 
    { 
        [Embed(source="sound1.mp3")] 
        public var soundCls:Class; 
         
        public function SoundAssetExample() 
        { 
            var mySound:SoundAsset = new soundCls() as SoundAsset; 
            var sndChannel:SoundChannel = mySound.play(); 
        } 
    } 
}