сивами — но внешне их поведение весьма схоже с массивами универсальных языков. Поэтому мы, удобства ради, называем их массивами, хотя это, строго говоря, не совсем верно. Аналогично мы будем использовать и понятие «класс», чтобы применяемая нами терминология была близка к традиционной терминологии объектно-ориентированного программирования. Однако нужно помнить, что между классами универсальных языков и конструкторами ActionScript 1.0 имеется много различий. Кстати, поэтому в ЕСМА-262 (третье издание) не используется понятие «класс». Функ- ции-конструкторы называются просто объектами (например, объект Array, но не класс Array), Вообще объектно-ориентированное программирование в ActionScript i .0 повторяет лишь некоторые стороны его многогранности, например, в C++. И это абсолютно оправданно, так как язык сценариев должен быть скорее простым, чем изящным и пластичным, но требующим изрядной подготовки.
В этой книге под классом мы будем понимать множество объектов, созданных одним конструктором.
9.2.5. Наследование
Как было показано выше, при активации функции-конструктора с использованием оператора new происходит создание объекта с последующим заданием его свойств за счет выполнения кода в блоке. При этом каждый экземпляр класса получает индивидуальный набор свойств. Зачастую это не совсем рационально. Так, если значение свойства должно быть одинаковым для всех объектов класса, то создавать отдельную его копию для каждого экземпляра — это не лучший шаг. Гораздо эффективнее сохранить такое свойство в конструкторе, а объектам лишь указать, где оно находится. При этом при необходимости узнать значение свойства все экземпляры класса будут обращаться к одному объектуданных, что может дать весьма ощутимую экономию в потребляемых ресурсах компьютера. Описанная модель, по которой объекты могут использовать методы и свойства других объектов, называется наследованием.
В ActionScript наследование реализуется при помощи прототипов конструкторов. Прототип — это объект, сохраненный в свойстве prototype конструктора. Данное свойство имеется у всех функций, в чем можно убедиться, сняв защиту от перечисления со скрытых свойств:
function func():Void {} ASSetPropFlags{func, null, null, 1); for (var i in func) {
trace(i); // Выводит: prototype __proto__ constructor
Каждый объект имеет ссылку на прототип своего конструктора. Если запрашиваемое свойство не обнаруживается в числе компонентов объекта, проверяется прототип. Если в прототипе обнаруживается свойство, то его значение считывается. В противном случае проверяется прототип надкласса — и так до конца цепочки наследования.
Таким образом, если вы хотите, чтобы объекты класса наследовали свойство или метод, то данные компоненты должны быть сохранены в прототипе конструктора:
function Кот(пол:String, цвет:String, характер:String):Void { // Код, инициализирующий индивидуальные свойства экземпляров this.пол=пол, this.цвет=цвет, this.характер=характер;
}
// Задаем свойства, которые объектами класса должны наследоваться Кот.prototype.лап=4, Кот.prototype.хвост=1, Кот.prototype.нос=1;
var барсик = new Кот("кот", "рыжий", "вредный"); // Создаем экземпляр класса
// Перечисляем все свойства объекта
for (var i in барсик) { |
// Выводит: нос=1 хвост=1 лап=4 |
trace(i+"="+6apсик[i]); |
|
} |
// характер=вредный цвет=рыжий пол=кот |
|
Свойство, наследуемое из прототипа, не может быть изменено или удалено. Это связано с тем, что
если вы попытаетесь присвоить ему новое значение, то интерпретатор, не обнаружив у объекта свойства с таким именем, просто создаст новое свойство:
function Func ():Void{}; Func.prototype.prop="Привет"; var obj=new Func();
obj.рrор="Пока"; |
// |
Пытаемся |
переопределить наследуемое свойство |
|
trace(obj.prop); |
// |
Выводит: |
Пока |
|
trace(Func.prototype.prop); |
// |
Выводит: Привет (значение свойства прототипа |
||
|
|
|
// |
изменено не было) |
Если имена «личного» и наследуемого свойства совпадают, то при обращении будет возвращено значение собственного свойства объекта. Это явление называется переприсваиванием свойств.
Прототип является объектом класса Object. Это означает, что, если свойство не обнаруживается в прототипе класса, интерпретатор обращается к прототипу конструктора Object. Из этого вытекают два важных следствия:
•класс Object всегда завершает цепочку наследования. Следовательно, любой объект наследует методы его прототипа. Исключением является только объект Global, свойством которого является сам конструктор Object();
•по умолчанию цепочка наследования не может быть длиннее двух звеньев (прототип конструктора класса и прототип конструктора Object). Правда, ее можно с легкостью искусственно удлинить. (Как это делается, мы поговорим в следующем подразделе.)
Проверить справедливость приведенных утверждений очень просто:
function Func():Void {} |
// |
Создаем конструктор |
trace(Func.prototype instanceof |
Object); // |
Выводит: true (прототип |
|
// |
принадлежит к классу Object) |
//Делаем доступными для перечисления свойства прототипа конструктора
//Object — так мы сможем проверить факт их наследования
ASSetPropFlags(Object.prototype, null, null, 7);
var obj = new Func(); |
// Создаем экземпляр класса func |
|
for (var i in obj) { |
// Перечисляем все собственные |
|
trace(); |
// Выводит: |
// и наследуемые свойства объекта obj |
toLocaleString isPropertyEnumerable |
||
|
// isPrototypeOf hasOwnProperty |
|
|
// toString valueOf addProperty unwatch watch constructor |
|
|
// (все эти свойства унаследованы от прототипа конструктора Object())) |
|
Схема, иллюстрирующая наследование для объектов любых встроенных классов (кроме класса XML, у которого есть надкласс XMLNode) и объектов пользовательских классов, у которых искусственно не удлинялась цепочка прототипов, показана на рис. 9.1.
Object.prototype
Constructor.prototype
Constructor
Obj1 Obj2 Obj3
Рис. 9.1. Типичная схема наследования
Объект «знает», где находится прототип его класса, благодаря наличию специального свойства __proto__. Данное свойство хранит ссылку на прототип конструктора, участвовавшего в создании объекта. Свойство __proto__ имеется абсолютно у всех объектов, кроме Global:
function Func():Void{} var obj = new Func();
//__proto__ и остальные служебные свойства защищены от перечисления -
//эту защиту нужно снять
ASSetPropFlags(obj, null, null, 1); for (var i in obj) {
trace(i); // Выводит: constructor __proto__
//(это обязательный минимальный набор свойств для любого объекта)
}
trace(obj.__proto__ == Func.prototype); // Выводит: true (свойство
// __proto__ указывает на прототип класса)
Свойство __proto__ может быть использовано для определения, к какому классу относится объект. Однако практическую важность оно представляет прежде всего потому, что, переопределяя его, можно создавать цепочки наследования любой длины.
Вторым обязательным свойством, имеющимся у любого объекта, является свойство constructor. Данное свойство хранит ссылку на конструктор, при помощи которого был создан объект:
function Func():Void {} var obj = new Func();
trace(obj.constructor Func); // Выводит: true
Свойства __proto__ и constructor задаются при создании объекта, Чтобы понять, как это делается, просмотрите еше раз созданную нами в предыдущем разделе функцию my_new, эмулирующую оператор new.
Интересные особенности связаны с использованием методов и свойств классов String, Boolean, Number. Как вы помните, они могут быть применены по отношению не только к объектам данных классов, но и к величинам соответствующих элементарных типов. Например:
trace("Привет".length); // Выводит: 6
Возникает вопрос: как может наследовать объект данных элементарного типа методы и свойства класса? Ответ — никак. Просто при использовании оператора «.» его левый операнд автоматически преобразуется в объект (аналогичную операцию проводит функция Object). Данное преобразование проводится над копией объекта данных, поэтому оно никак не сказывается на значении переменной, прописанной в качестве левого операнда «.». Доказать справедливость приведенных в
данном абзаце утверждений можно, определив тип величины, соответствующей свойству this объекта активации метода, вызванного объектом данных элементарного типа:
String.prototype.method = function() { trace(typeof this);
};
par="Привет"; // Переменная, хранящая элементарную строку par.method(); // Выводит: object (строка была преобразована в объект)
Сделаем краткое резюме. Итак, у объекта может быть два вида свойств. Свойства могут принадлежать ему непосредственно. Обычно такие свойства инициализируются при выполнении кода конструктора, и в них хранятся данные, которые должны быть индивидуальны для каждого объекта. Второй вид свойств — это наследуемые свойства. Они сохраняются в прототипе конструктора, и их совместно используют все экземпляры класса. В таких свойствах сохраняют методы и свойства, значения которых должны быть одинаковы для всех объектов. По умолчанию прототип является объектом класса Object, поэтому методы прототипа конструктора Object наследуются абсолютно всеми объектами ActionScript. Непосредственно механизм наследования реализуется при помощи особых скрытых свойств __proto__(указывает на прототип конструктора объекта) и constructor (указывает на конструктор объекта).
9.2.6. Создание надклассов и подклассов
По умолчанию длина цепочки прототипов в ActionScript не может превышать двух звеньев (прототип конструктора объекта и прототип конструктора Object). Этого далеко не всегда достаточно. Очень часто бывает необходимым организовывать более сложное наследование, создавая подклассы и надклассы.
Класс А называется надклассом по отношению к некоторому классу В, если объектами В наследуются методы и свойства класса А. Соответственно класс В в этом случае является подклассом класса А. Чтобы сделать класс А надклассом В, достаточно изменить значения свойств__proto__и (не обязательно) constructor прототипа конструктора класса В. Свойство__proto__должно указывать на прототип надкласса, constructor — на его конструктор.
Возвратившись к выбранной в самом начале главы ассоциации объекта с котом, можно, зная способ удлинения цепочки прототипов, несколько улучшить схему наследования для класса Кот. Сделать это можно, создав надкласс Млекопитающие, прототип конструктора которого будет хранить общие для всех теплокровных животных свойства (число лап, ушей, хвостов и т. д.):
function Млекопитающие():Void {}
//Создаем конструктор надкласса
//Задаем общие для всех млекопитающих свойства Млекопитающие.prototype.лап=4;
Млекопитающие.prototype.xвocт=1;
Млекопитающие.prototype.нос=1;
function Кот(пол:String, цвет:String, характер:String) {
// Задаем индивидуальные свойства кота
this.пoл=пол, this.цвет=цвет, this.характер=характер; }
//Делаем класс Млекопитающие надклассом класса Кот Кот.prototype.__proto__ = Млекопитающие.prototype;
Кот.prototype.constructor = Млекопитающие; // Данное предложение
//не обязательно
//Создаем экземпляр класса Кот
var барсик = new Кот("кот", "рыжий", "вредный");
for (var i in барсик) { // Перечисляем свойства экземпляра trace(i + "="+6apcик[i]); // Выводит:
//нос=1 хвост=1 лап=4 (унаследованы от надкласса)
//характер=вредный цвет=рыжий пол=кот
Вне зависимости от того, насколько сложной является цепочка наследования для объекта, ее последним звеном всегда будет прототип конструктора Object. Это связано с тем, что свойство__proto__прототипа любого конструктора по умолчанию указывает на Object.prototype. Создать
же собственный надкласс для всех классов в цепочке наследования, естественно, невозможно, так как при этом она станет бесконечной.
Изменяя значения свойств __proto__ и constructor, можно объекты, изначально принадлежащие к одному классу, делать экземплярами другого. Используя этот ход, можно, например, выделить в подкласс группу клипов. Это позволит оперировать сразу всей группой, не влияя на остальные клипы в фильме. Вспомните проект, в котором мы собирали из кубиков большой куб. Тогда, чтобы при щелчке по кубику он исчезал, мы воспользовались событием onPress. Чтобы не создавать для каждого экземпляра отдельный обработчик, соответствующий метод мы сохранили в прототипе класса MovieClip. При этом он был унаследован всеми кубиками. Однако подобное решение было приемлемо лишь потому, что на поле никаких клипов, кроме кубиков, не было. Иначе при щелчке исчезали бы даже те клипы, которые, по идее, этого делать не должны. Чтобы этого не происходило, кубики следует выделить в подкласс класса MovieClip, сохранив обработчик события onPress в его прототипе.
Переписывать проект мы не будем. Вместо этого решим схожую по идее, но более простую задачу:
// Создайте клип в виде кружочка и назовите его bl
function Ball():Void {} // Класс, к которому будут относиться шарики
//Делаем класс Ball подклассом класса MovieClip Ball.prototype.constructor = MovieClip; Ball.prototype.__proto__ = MovieClip.prototype;
//Создаем 100 случайно распределенных кружков for (var i = 0; i<100; i++) {
bl.duplicateMovieClip("bl"+i, i, {_x:Math.random()*550, _y:Math.random()*450});
//Делаем полученный экземпляр объектом класса Ball this["bl"+i].__proto__ = Ball.prototype;
this["bl"+i].constructor = Ball; // Данное предложение не обязательно
}
//При щелчке по кружку он должен исчезнуть
Ball.prototype.onPress = function():Void { this.removeMovieClip();
};
Приведенный пример демонстрирует очень интересную особенность реализации наследования в ActionScript. Чтобы объект принадлежал к некоторому классу, совсем не обязательно, чтобы он был создан при помощи его конструктора. Для этого достаточно, чтобы его свойство__proto__хранило указатель на прототип нужного конструктора.
Вообще же утверждение о принадлежности объекта к какому-то классу не очень корректно в случае ActionScript 1.0. Так, объект может быть создан одним конструктором, а получать свойства из прототипа другого. Правильнее говорить, что объект наследует свойства некоторых классов. Именно поэтому оператор instanceof определяет не то, указывает ли его правый операнд на тот же конструктор, что и свойство constructor объекта, заданного в качестве левого операнда, а имеется ли прототип данного конструктора в цепочке наследования объекта.
Из-за того, что сложное наследование реализуется в ActionScript 1.0 весьма искусственно путем переопределения свойства __proto__объектов и конструкторов, вполне вероятна такая ситуация, когда надкласс будет ссылаться на прототип подкласса. Это будет означать, что цепочка наследования станет замкнутой и поиск свойства в ней может продолжаться бесконечно долго. Чтобы этого не происходило, в ActionScript длина цепочки прототипов ограничена 256 звеньями. Если этот лимит окажется превышенным, то работа кода будет остановлена и на экран будет выведено со-
общение: 256 levels of prototype chain were exceeded. This is probably a circular prototype chainFurther execution of actions has been disabled in this movie. (256 уровней цепочки прототипов были превышены. Эта цепочка прототипов, вероятно, зациклена. Дальнейшее выполнение кода в этом фильме было прекращено).
Пример зацикленной цепочки наследования: