ActionScript 2.0 для пользователей ActionScript 1.0: Часть третья. Наследование и интерфейсы

Автор: Joey Lott [http://www.person13.com/]

В первых двух частях [часть 1 | часть 2] мы рассматривали структуру и синтаксис классов в ActionScript 2.0. Мы узнали, как создавать классы в ActionScript 2.0, включая использование пакетов, членов класса с разными режимами доступа (public/private/static), а также геттеров и сеттеров. Теперь поговорим о наследовании (inheritance) и интерфейсах (interfaces).

О наследовании

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

Например, вы хотите создать класс Car, подобный тому, что мы создавали в предыдущих частях статьи. Ясно, что Автомобиль — это один из многих типов Машины, помимо Автомобилей существуют Вертолеты, Дрезины, Джипы, Терминаторы и т.д. Хотя Машины и отличаются друг от друга, у них есть много общего. Все вышеперечисленные машины могут иметь такие свойства, как "грузоподъемность" или "пробег" (для Самолетов — "пролет"). А если Машина еще и передвигается в пространстве, у нее есть методы для перемещения с заданной скоростью.

Так вот, если вы создадите суперкласс Vehicle (т. е. "Машина"), то можно в него поместить все общие для машин характеристики (свойства и методы). При этом код будет написан только в одном месте, а использовать его можно будет во многих местах: во всех подклассах класса Машины. Для создания суперкласса не нужно быть чемпионом по программированию среди домохозяек (или домохозяинов). Просто берете и создаете суперкласс, как раньше создавали обычные классы. А вот чтобы наследовать от этого класса (иными словами, расширить его), потребуются новая техника. Довольно легкая в освоении.

Расширение суперкласса

В терминах ООП можно сказать, что подкласс расширяет (extends) суперкласс. В нашем примере подкласс Car расширяет суперкласс Vehicle. Чтобы Flash создал такую связь между ними, нужно при объявлении подкласса использовать ключевое слово extends:

В случае с Автомобилем и Машиной получится приблизительно следующее:

Вы всего один раз говорите, что класс Car расширяет класс Vehicle, и получаете при этом в свое распоряжение все свойства и методы класса Vehicle, как будто бы они были определены в классе Car.

Вызов перекрытых методов суперкласса

Часто возникает ситуация, когда в подклассе необходимо унаследовать метод суперкласса без каких-либо изменений в этом методе. В таких случаях в определением подкласса просто не нужно ничего делать с этими методами. Но во многих других случаях метод суперкласса может быть перекрыт — для реализации в данном методе особенностей подкласса. Это называется перекрытием (overriding) метода суперкласса, поскольку при этом подкласс определяет в себе собственную реализацию метода, которая перекрывает унаследованную, родительскую.

Перекрывать методы суперкласса можно по-разному:

1. Вы можете перекрыть метод полностью, так что реализация метода в суперклассе будет полностью проигнорирована;
2. Можно сделать так, чтобы по-прежнему вызывался метод суперкласса, а реализация метода в подклассе добавляла бы всю нужную дополнительную функциональность.

Чтобы полностью перекрыть родительский метод, просто определите в классе-потомке метод с точно таким же именем, как и у родительского метода. Например, если у суперкласса есть метод типа:

Потом можно определить реализацию метода в подклассе, которая перекроет реализацию этого метода в суперклассе:

Это был первый подход.

Если же вы хотите реализовать в подклассе метод, который будет вызывать также свою реализацию в суперклассе, можете использовать ключевое слово super, чтобы ссылаться на суперкласс и явно вызывать его метод из метода подкласса. Например, пример с методом display() в таком случае можно переписать следующим образом:

Затем, если из экземпляра подкласса вызвать метод display() подкласса, в панели Output увидим следующее:

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

Создание классов Машины и Автомобиля

Конец теории. Выполним упражнение. Создадим суперкласс Vehicle (Машина) и подкласс Car (Автомобиль). Если вы сделали упражнение из второй части данной статьи, то вам будет легко следить за мыслью.

1. Создайте структуру директорий для пакета com.person13. Например, D:\Swf\Classes\com\person13;
2. Откройте новый ActionScript-файл;
3. Добавьте в него такой код:
   class com.person13.Vehicle {
   private var _nPassengers:Number;
   private var _nMiles:Number;
   private var _nInterval:Number;
   function Vehicle(nPassengers:Number, nMiles:Number) {
   _nPassengers = nPassengers;
   miles = nMiles;
   }
   public function get passengers():Number {
   return _nPassengers;
   }
   public function get miles():Number {
   return _nMiles;
   }
   public function set miles(nMiles:Number):Void { if(nMiles >= 0) {
   _nMiles = nMiles;
   }
   else {
   _nMiles = 0;
   }
   }
   public function move(nMPH:Number):Void {
   if(nMPH == null || nMPH <= 0) {
   clearInterval(_nInterval);
   }
   else {
   _nInterval = setInterval(this, "increment", 1000, nMPH);
   }
   }
   private function increment(nMPH:Number):Void {
   _nMiles += nMPH;
   }
   }
4. Сохраните файл как Vehicle.as в директории com/person13;
5. Откройте файл класса Car.as (мы создавали его во второй части) (по идее он должен был остаться в директории com/person13 ). В противном случае откройте новый ActionScript-файл;
6. Добавьте в файл Car.as код (или напишите заново, если вы все же поленились сделать упражнение из второй части). Должно получиться так:
   
   // Класс Car расширяет класс Vehicle и наследует все его свойства и методы
   class com.person13.Car extends com.person13.Vehicle{
   // Объявляем только свойства, специфические для класса Car.
   // Остальные свойства наследуются, так что не надо объявлять их заново.
   private var _sMake:String;
   private var _sModel:String;
   private var _nYear:Number;
   function Car(sMake:String, sModel:String, nYear:Number, nPassengers:Number, nMiles:Number) {
   // Вызываем конструктор суперкласса, затем присваиваем значения
   // свойств, специфических для класса Car.
   super(nPassengers, nMiles);
   _sMake = sMake;
   _sModel = sModel;
   year = nYear;
   }
   public function get make():String {
   return _sMake;
   }
   public function get model():String {
   return _sModel;
   }
   public function get year():Number {
   return _nYear;
   }
   public function set year(nYear:Number):Void {
   if(nYear >= 1886) {
   _nYear = nYear;
   }
   else {
   _nYear = 1886;
   }
   }
   // Определяем метод drive(), который на самом деле вызывает метод move(),
   // унаследованный из суперкласса Vehicle. Именно так делать не обязательно, но
   // лучше все же делать так, самому же потом разобраться легче будет,
   // поскольку термин "drive" больше подходит для машины, чем "move".
   // Таким образом, API для класса Car будет интуитивно понятнее.
   public function drive(nMPH:Number):Void {
   move(nMPH);
   }
   }
7. Сохраните файл Car.as в директории com/person13, где перед этим сохраняли Vehicle.as;
8. Возьмите .fla-файл, созданный ранее во второй части. Или создайте новый .fla-файл;
9. Как бы там ни было, в первом кадре этого .fla-файла должен оказаться такой код:
   import com.person13.*;
   function displayMileage(carObj:Car):Void {
   trace(carObj.miles);
   }
   var car:Car = new Car("Oldsmobile", "Alero", 2000, 5, 43000);
   car.drive(65);
   setInterval(displayMileage, 100, car);
10. Теперь можно делать Test Movie. В панели Output вы увидите пробег автомобиля в милях. Число будет увеличиваться раз в секунду, потому что автомобиль едет.
    

    [Необязательная часть для любителей воздушных аппаратов]

11. Откройте новый ActionScript-файл;
12. Добавьте в него такой код:
    
class com.person13.Plane extends com.person13.Vehicle{
private var _sMake:String;
private var _sModel:String;
function Plane(sMake:String, sModel:String, nPassengers:Number, nMiles:Number) {
super(nPassengers, nMiles);
_sMake = sMake;
_sModel = sModel;
}
public function get make():String {
return _sMake;
}
public function get model():String {
return _sModel;
} public function fly(nMPH:Number):Void {
move(nMPH);
}
}
13. Сохраните файл как Plane.as в директории in the com/person13;
14. Создайте новый .fla-файл;
15. Добавьте такой код в первый кадр:
    
    import com.person13.*;
    function displayMileage(obj:Plane):Void {
    trace(obj.miles);
    }
    var plane:Plane = new Plane("Boeing", "747", 300, 100000);
    plane.fly(400);
    setInterval(displayMileage, 100, plane);
16. Теперь — TestMovie.

Расширение подклассов

Об интерфейсах

Интерфейсы — это просто. Это набор правил, в соответствии с которыми реализуется некий набор классов. Когда вы определяете класс, который следует правилам интерфейса, то говорят, что класс реализует (иногда на жаргоне говорят — "имплементит", от англ. "implements") интерфейс.

Какие правила определяются в интерфейсе? Интерфейс в ActionScript 2.0 сообщает Flash, какие методы должны реализоваться в классе, включая следующую информацию:

• Имя метода;
• Входные параметры;
• Публичное объявление метода (объявления методов с режимом доступа private или static в интерфейсе недопустимы);
• Тип возвращаемого значения.

В интерфейсе недопустимы:

• Объявления свойств;
• Реализации методов;
• Объявления методов с режимами доступа private или static.

Затем можно реализовывать интерфейс в классе. При этом, кроме всего прочего, в классе должны реализовываться методы, объявленные в интерфейсе. В противном случае на этапе компиляции Flash выдаст сообщение об ошибке.

Преимущества интерфейсов

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

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

Например, вы работаете в команде, которая создает классы Vehicle (Машина), Animal (Животное), Wind (Ветер) и Planet (Планета). В то время как у каждого из этих классов может быть собственный API, между ними есть и общее — все они способны двигаться. Если вы хотите реализовать движение в каждом из этих классов, можно создать интерфейс IMoveable, который будет реализовываться всеми этими классами. Интерфейс IMoveable будет содержать объявление метода move(), так что теперь каждый конкретный человек, работающий над реализацией конкретного класса, будет учитывать этот факт в процессе разработки и реализует метод move() в разрабатываемом им классе. Это большой плюс при командной работе. Когда вы создаете интерфейс и определяете, какие классы будут его реализовать, то потом все разработчики, работающие над классом, будут заранее знать, какие методы писать, и это облегчает стандартизацию API всех классов. Еще одно преимущество получает разработчик, использующий такой класс. Зная, какой именно конкретный интерфейс реализуется в классе, вы ужен знаете много о своем API.

Один класс может реализовывать многочисленные интерфейсы. Поэтому интерфейсы часто используются как форма множественного наследования в языках, изначально не поддерживающих такой вид наследования. В ActionScript подкласс может наследовать только от одного суперкласса. Например, класс Car расширяет класс Vehicle, и следовательно не может расширять ни один другой класс. Но Car может реализовывать множественные интерфейсы (продолжая при этом наследовать от класса Vehicle.) Например, Car может реализовать интерфейсы типа IDrivable (автомобиль можно водить), IManufacturable (можно производить), ISellable (можно продать).

Создание интерфейса

Рассмотрим пример объявления и определения интерфейса. Вы уже знаете синтаксис и структуру классов, так что нового здесь будет совсем немного.

Декларация (объявление) интерфейса выглядят почти идентично декларации класса. Единственное различие в том, что при объявлении интерфейса используется ключевое слово interface, вместо ключевого слова class. Например:

В интерфейсе можно только объявлять методы, но не реализовывать их. Реализовываться методы будут в классах, реализующих интерфейс. В интерфейсе нельзя также объявлять свойства. Еще раз кратко перечислим то, что может и должно содержаться в интерфейсе:

• Имя метода;
• Имя и тип ожидаемого параметра;
• Объявление публичных методов;
• Тип возвращаемого значения.

Вот пример готового интерфейса IMoveable:

Как и классы, интерфейсы удобно хранить в пакетах. Например, можно упаковать IMoveable в пакет com.person13. В декларации интерфейса это выглядит вот так:

И также, как и классы, интерфейсы могут расширять друг друга Например, IDrivable может расширять IMoveable, вот как будет при этом выглядеть код:

Реализация интерфейса

После определения интерфейса можно указать, что некий класс реализует этот интерфейс. Для этого используется ключевое слово implements, за которым будет следовать список разделенных запятыми реализуемых интерфейсов. Например, если класс Vehicle реализует интерфейс IMoveable, то начало объявления класса будет выглядеть так:

Конечно, при этом можно пользоваться импортом (как и с классами):

А вот класс Car реализует интерфейсы IDrivable, IManufacturable, и ISellable:

Когда класс реализует интерфейс, Flash будет проверять правильность этой реализации во время компиляции. И если какой-то метод пропущен или объявлен неверно, не так, как в интерфейсе, то Flash выдаст сообщение об ошибке.

Вывод

Вот и разобрались. Комментарии приветствуются как никогда. Спасибо :]