Tematy zaawansowane

Ponieważ język ActionScript 3.0 jest oparty na poprzednich wersjach języka ActionScript, warto przyjrzeć się ewolucji modelu obiektowego w kolejnych wersjach języka. ActionScript był początkowo prostym mechanizmem skryptowym współpracującym z wczesnymi wersjami programu Flash Professional. Z czasem programiści zaczęli budować z jego pomocą coraz bardziej złożone aplikacje. W odpowiedzi na potrzeby takich programistów w kolejnych wersjach wprowadzano elementy języka usprawniające tworzenie skomplikowanych aplikacji.

ActionScript 1.0

ActionScript 1.0 to wersja języka używana w programie Flash Player 6 i wcześniejszych wersjach. Nawet na tym wczesnym etapie rozwoju model obiektowy języka ActionScript był oparty na koncepcji obiektu jako fundamentalnego typu danych. Obiekt w języku ActionScript jest złożonym typem danym składającym się z grupy właściwości . Przy omawianiu modelu obiektowego termin właściwość oznacza wszystkie elementy skojarzone z obiektem, takie jak zmienne, funkcje i metody.

Mimo że w pierwszej generacji języka ActionScript nie było możliwe definiowanie klas za pomocą słowa kluczowego class , można było definiować klasy przy użyciu specjalnego rodzaju obiektu, tzw. obiektu prototypowego. W językach opartych na klasach, takich jak Java i C++, programista za pomocą słowa kluczowego class tworzy abstrakcyjną definicję klasy, a następnie tworzy konkretne obiekty będące instancjami tej klasy. Natomiast w językach opartych na prototypach, takich jak ActionScript 1.0, używa się istniejącego obiektu jako modelu (prototypu) dla innych obiektów. Podczas gdy obiekty w języku opartym na klasach modą wskazywać klasę będącą ich szablonem, obiekty w języku opartym na prototypach wskazują na inny obiekt, prototyp, pełniący rolę takiego szablonu.

Aby utworzyć klasę w języku ActionScript 1.0 należy zdefiniować funkcję będącą konstruktorem tej klasy. W język ActionScript funkcje są faktycznie obiektami, a nie tylko abstrakcyjnymi definicjami. Utworzony konstruktor pełni rolę obiektu prototypowego dla instancji tej klasy. W poniższym kodzie utworzono klasę o nazwie Shape i zdefiniowano jedną właściwość o nazwie visible , która domyślnie przyjmuje wartość true :

// base class 
function Shape() {} 
// Create a property named visible. 
Shape.prototype.visible = true;

Ten konstruktor definiuje klasę Shape, której instancje można tworzyć za pomocą operatora new , w następujący sposób:

myShape = new Shape();

Obiekt funkcji-konstruktora Shape() jest prototypem instancji klasy Shape, ale może także pełnić rolę prototypu podklas klasy Shape — tj. innych klas rozszerzających klasę Shape.

Tworzenie podklasy klasy Shape przebiega dwuetapowo. Najpierw należy utworzyć klasę, definiując jej konstruktor, w następujący sposób:

// child class 
function Circle(id, radius) 
{ 
this.id = id; 
this.radius = radius; 
}

Następnie za pomocą operatora new należy zadeklarować, że klasa Shape jest prototypem klasy Circle. Domyślnie prototypem każdej tworzonej kasy jest klasa Object, co oznacza, że właściwość Circle.prototype zawiera obecnie obiekt ogólny (instancję klasy Object). Aby wskazać, że prototypem klasy Circle jest klasa Shape, a nie Object, należy za pomocą poniższego kodu zmienić wartość właściwości Circle.prototype , tak aby zawierała obiekt Shape, a nie obiekt ogólny:

// Make Circle a subclass of Shape. 
Circle.prototype = new Shape();

Klasa Shape jest teraz powiązana z klasą Circle relacja dziedziczenia nazywaną łańcuchem prototypów . Poniższy diagram ilustruje relacje w łańcuchu prototypów:

Klasą bazową na końcu każdego łańcucha prototypów jest zawsze klasa Object. Klasa Object zawiera właściwość statyczną o nazwie Object.prototype , która wskazuje na bazowy obiekt prototypowy wszystkich obiektów tworzonych w języku ActionScript 1.0. Następnym obiektem w przykładowym łańcuchu prototypów jest obiekt Shape. Wynika to z faktu, że właściwości Shape.prototype nigdy w sposób jawny nie przypisano wartości, a więc nadal zawiera ona obiekt ogólny (instancję klasy Object). Ostatnim ogniwem tego łańcucha jest klasa Circle powiązana ze swoim prototypem, klasą Shape (właściwość Circle.prototype zawiera obiekt Shape).

Jeśli utworzymy instancję klasy Circle, tak jak w poniższym przykładzie, instancja odziedziczy łańcuch prototypów klasy Circle:

// Create an instance of the Circle class. 
myCircle = new Circle();

Przypominamy, że w przykładzie występowała właściwość o nazwie visible jako element klasy Shape. W tym przykładzie właściwość visible nie istnieje jako element obiektu myCircle , lecz jako element obiektu Shape, a mimo to następujący wiersz kodu daje w wyniku wartość true :

trace(myCircle.visible); // output: true

Środowisko wykonawcze, analizując łańcuch prototypów, jest w stanie ustalić, że obiekt myCircle dziedziczy właściwość visible . Podczas wykonywania tego kodu środowisko wykonawcze we właściwościach obiektu myCircle poszukuje właściwości o nazwie visible , ale takiej właściwości nie znajduje. Następnie szuka właściwości w obiekcie Circle.prototype , ale nadal nie znajduje tam właściwości o nazwie visible . Przechodząc coraz wyżej w łańcuchu prototypów, znajduje właściwość visible zdefiniowaną w obiekcie Shape.prototype i wyświetla wartość tej właściwości.

W celu zapewnienia prostoty wiele szczegółów i zawiłości łańcucha prototypów zostało pominiętych. Celem jest udostępnienie takiej ilości informacji, która umożliwia zrozumienie działania modelu obiektów ActionScript 3.0.

// base class 
class Shape 
{ 
var visible:Boolean = true; 
}

// child class 
class Circle extends Shape 
{ 
    var id:Number; 
    var radius:Number; 
    function Circle(id, radius) 
    { 
        this.id = id; 
        this.radius = radius; 
        } 
}

W powszechnie spotykanym modelu programowania zorientowanego obiektowo, zwykle kojarzonym z językami Java i C++, do definiowania typów obiektów używa się klas. W językach programowania opartych na tym modelu z reguły klasy służą także do budowania instancji typów danych definiowanych przez te klasy. W języku ActionScript klasy mają oba te zastosowania, ale ponieważ język wywodzi się z modelu opartego na prototypach, ma pewne interesujące cechy. W języku ActionScript definicja każdej klasy jest specjalnym obiektem klasy, który może udostępniać zarówno zachowania, jak i określone stany. Jednak dla wielu programistów korzystających z języka ActionScript to rozróżnienie nie ma praktycznego znaczenia. Język ActionScript 3.0 zaprojektowano w taki sposób, aby umożliwiał tworzenie zaawansowanych aplikacji zorientowanych obiektowo bez konieczności używania tych specjalnych obiektów klas, a nawet bez świadomości ich istnienia.

Poniższy schemat ilustruje strukturę obiektu klasy reprezentującego prostą klasę A zdefiniowaną za pomocą instrukcji class A {} :

Powiększ obraz

Każdy prostokąt na diagramie reprezentuje jeden obiekt. Każdy obiekt na diagramie ma indeks A oznaczający, że należy on do klasy A. Obiekt klasy (CA) zawiera odwołania do szeregu innych ważnych obiektów. Obiekt cech instancji (TA) zawiera właściwości instancji zdefiniowane w definicji klasy. Obiekt cech klasy (TCA) reprezentuje wewnętrzny typ klasy i zawiera właściwości statyczne definiowane przez klasę (indeks C to skrót od słowa „class”). Obiekt prototypowy (PA) zawsze oznacza obiekt klasy, z którym był pierwotnie skojarzony, za pośrednictwem właściwości constructor .

Obiekt cech, który jest nowym elementem środowiska ActionScript 3.0, to rozwiązanie wprowadzone z myślą o wydajności działania kodu. W poprzednich wersjach środowiska ActionScript wyszukiwanie nazw było potencjalnie czasochłonne, ponieważ program Flash Player sprawdzał kolejne ogniwa łańcucha prototypów. W środowisku ActionScript 3.0 wyszukiwanie nazw przebiega znacznie wydajniej i szybciej, ponieważ właściwości dziedziczone są kopiowane z nadklas do obiektów cech podklas.

Obiekt cech nie jest bezpośrednio dostępny dla kodu pisanego przez programistę, ale jego obecność ujawnia się pośrednio poprzez większą szybkość działania kodu i optymalizację zużycia pamięci. Obiekt cech dostarcza maszynie AVM2 szczegółowych informacji o strukturze i zawartości klasy. Na podstawie tych informacji maszyna AVM2 jest w stanie znacznie przyspieszyć wykonywanie kodu, ponieważ często możliwe jest wygenerowanie instrukcji maszynowych uzyskujących dostęp do właściwości lub bezpośrednie wywoływanie metod bez czasochłonnego wyszukiwania nazw.

Dzięki obiektom cech obiekty aplikacji zajmują znacznie mniej miejsca w pamięci niż ich odpowiedniki w starszych wersjach środowiska ActionScript. Na przykład, jeśli klasa jest zapieczętowana (tj. nie jest zadeklarowana jako dynamiczna), to instancja tej klasy nie musi zawierać tabeli mieszania dla dynamicznie dodawanych właściwości, a obiekt tej klasy zajmuje niewiele więcej miejsca niż wskaźnik do obiektu cech i pola na właściwości ustalone zdefiniowane w klasie. W rezultacie obiekt, który w środowisku ActionScript 2.0 zajmował 100 bajtów pamięci, w środowisku ActionScript 3.0 zajmuje zaledwie 20 bajtów.

Każdy obiekt klasy w języku ActionScript ma właściwość prototype , która zawiera odwołanie do obiektu prototypowego klasy. Obiekt prototypowy jest zaszłością wywodzącą się z korzeni ActionScript jako języka opartego na prototypach. Więcej informacji zawiera dokumentacja Historia elementów programowania zorientowanego obiektowo w języku ActionScript .

Właściwość prototype jest przeznaczona tylko do odczytu, co oznacza, że nie można jej zmodyfikować tak, aby wskazywała na inne obiekty. Zachowuje się zatem inaczej niż właściwość prototype klas w poprzednich wersjach języka ActionScript, które umożliwiały zmianę przypisania prototypu tak, aby właściwość ta wskazywała na inna klasę. Mimo że właściwość prototype jest przeznaczona tylko do odczytu, obiekt prototypowy, do którego ta właściwość się odwołuje, może być modyfikowany. Innymi słowy, do obiektu prototypowego można dodawać nowe właściwości. Właściwości dodawane do obiektu prototypowego są wspólne dla wszystkich instancji klasy.

Łańcuch prototypów, który w poprzednich wersjach języka ActionScript był jedynym mechanizmem dziedziczenia, pełni w języku ActionScript 3.0 jedynie drugorzędną rolę. Podstawowy mechanizm dziedziczenia, tj. dziedziczenie właściwości ustalonych, jest realizowany wewnętrzne przez obiekty cech. Właściwość ustalona do zmienna lub metoda zdefiniowana jako element definicji klasy. Dziedziczenie właściwości ustalonych nazywane jest także dziedziczeniem klas, ponieważ ten właśnie mechanizm dziedziczenia jest powiązany z takimi słowami kluczowymi, jak class , extends i override .

Łańcuch prototypów stanowi alternatywny mechanizm dziedziczenia — bardziej dynamiczny niż dziedziczenie właściwości ustalonych. Możliwe jest dodawanie właściwości do obiektu prototypowego klasy nie tylko w definicji klasy, lecz również za pośrednictwem właściwości prototype obiektu klasy. Należy jednak zwrócić uwagę, że w wypadku wybrania trybu ścisłego kompilatora nie będzie możliwe uzyskanie dostępu do właściwości dodanych do obiektu prototypowego, jeśli klasa nie będzie zadeklarowana ze słowem kluczowy dynamic .

Za przykład klasy z wieloma właściwościami powiązanymi z obiektem prototypowym jest klasa Object. Metody toString() i valueOf() klasy Object są w istocie funkcjami przypisanymi właściwościom obiektu prototypowego tej klasy. Poniżej przedstawiono teoretyczną deklarację tych metod (w praktyce deklaracja ta jest nieco inna z uwagi na szczegóły implementacyjne):

public dynamic class Object 
{ 
    prototype.toString = function() 
    { 
        // statements 
    }; 
    prototype.valueOf = function() 
    { 
        // statements 
    }; 
}

Jak już wcześniej wspomniano, możliwe jest powiązanie właściwości z obiektem prototypowym klasy poza definicją klasy. Na przykład metoda toString() mogłaby być zdefiniowana poza definicją klasy Object, w następujący sposób:

Object.prototype.toString = function() 
{ 
    // statements 
};

Jednak w przeciwieństwie do dziedziczenia właściwości ustalonych dziedziczenie oparte na prototypach nie wymaga użycia słowa override przy przesłanianiu metody w podklasie. Na przykład. jeśli chcemy przedefiniować metodą valueOf() w podklasie obiektu Object, mamy do wyboru trzy możliwości. Po pierwsze, możemy zdefiniować metodę valueOf() w obiekcie prototypowym podklasy, wewnątrz definicji tej podklasy. Poniższy kod tworzy podklasę klasy Object o nazwie Foo i zmienia definicję metody valueOf() w obiekcie prototypowym Foo w ramach definicji klasy. Ponieważ każda klasa dziedziczy z klasy Object, nie jest konieczne użycie słowa kluczowego extends .

dynamic class Foo 
{ 
    prototype.valueOf = function() 
    { 
        return "Instance of Foo"; 
    }; 
}

Po drugie, możemy zdefiniować metodę valueOf() w obiekcie prototypowym Foo poza definicją klasy, co ilustruje poniższy kod:

Foo.prototype.valueOf = function() 
{ 
    return "Instance of Foo"; 
};

Po trzecie, możemy zdefiniować ustaloną właściwość o nazwie valueOf() jako element klasy Foo. Ta technika polega na jednoczesnym zastosowaniu dziedziczenia właściwości ustalonych i dziedziczenia opartego na prototypach. W każdej podklasie klasy Foo, w której chcielibyśmy zmienić definicję właściwości valueOf() , musimy użyć słowa kluczowego override . Poniższy kod przedstawia definicję valueOf() jako właściwości ustalonej w klasie Foo:

class Foo 
{ 
    function valueOf():String 
    { 
        return "Instance of Foo"; 
    } 
}

Istnienie dwóch odrębnych mechanizmów dziedziczenia, tj. dziedziczenia właściwości ustalonych i dziedziczenia opartego na prototypach, stwarza pewne potencjalne problemy ze zgodnością właściwości i metod klas podstawowych języka. Robocza specyfikacja ECMAScript, na której oparty jest język ActionScript, zakłada stosowanie dziedziczenia w oparciu o prototypy, co oznacza że właściwości i metody klas podstawowych języka są zdefiniowane w swoich obiektach prototypowych. Z drugiej strony, zgodność z wywołaniami języka ActionScript 3.0, w których stosowane jest dziedziczenie właściwości ustalonych, wymaga zdefiniowania właściwości i metod klas podstawowych za pomocą słów kluczowych const , var i function . Co więcej, użycie klas ustalonych zamiast ich wersji prototypowych może prowadzić do znacznego przyspieszenia wykonywania kodu.

W języku ActionScript 3.0 problem ten rozwiązano, stosując w klasach podstawowych języka zarówno dziedziczenie oparte na prototypach, jak i dziedziczenie właściwości ustalonych. Każda klasa podstawowa języka zawiera dwa zestawy właściwości i metod. Jeden zestaw jest zdefiniowany w obiekcie prototypowym w celu zapewnienia zgodności ze specyfikacją ECMAScript, a drugi zestaw jest zdefiniowany przy użyciu właściwości ustalonych w przestrzeni nazw AS3.0 w celu zapewnienia zgodności z językiem ActionScript 3.0.

Przestrzeń nazw AS3 udostępnia wygodny mechanizm wyboru jednego z tych zestawów właściwości i metod. Jeśli w programie nie jest używana przestrzeń nazw AS3, instancja klasy podstawowej języka dziedziczy właściwości i metody zdefiniowane w obiekcie prototypowym klasy podstawowej. Jeśli przestrzeń nazw AS3 jest używana, instancja klasy podstawowej dziedziczy wersje z tej przestrzeni nazw (AS3), ponieważ właściwości ustalone mają zawsze pierwszeństwo przed prototypowymi. Innymi słowy, gdy tylko dostępna jest właściwość ustalona, jest używana w miejsce właściwości prototypowej o tej samej nazwie.

Możliwe jest selektywne stosowanie właściwości i metod z przestrzeni AS3 poprzez kwalifikowanie nazw przestrzenią AS3. Na przykład w poniższym kodzie zastosowano wersję metody Array.pop() z przestrzeni AS3:

var nums:Array = new Array(1, 2, 3); 
nums.AS3::pop(); 
trace(nums); // output: 1,2

Alternatywnym rozwiązaniem byłoby użycie dyrektywy use namespace w celu otwarcia przestrzeni nazw AS3 dla wszystkich definicji w bloku kodu. Na przykład w poniższym kodzie zastosowano dyrektywę use namespace w celu otwarcia przestrzeni nazw AS3 zarówno dla metody pop() , jak i metody push() :

use namespace AS3; 
 
var nums:Array = new Array(1, 2, 3); 
nums.pop(); 
nums.push(5); 
trace(nums) // output: 1,2,5

Środowisko ActionScript 3.0 udostępnia opcje kompilatora właściwe dla każdego zestawu właściwości, pozwalając na zastosowanie przestrzeni nazw AS3 do całego programu. Opcja kompilatora -as3 oznacza przestrzeń nazw AS3, a opcja kompilatora -es oznacza dziedziczenie w oparciu o prototypów (skrót es pochodzi od nazwy ECMAScript). Aby otworzyć przestrzeń nazw AS3 dla całego programu, należy ustawić opcję kompilatora -as3 na true , a opcję kompilatora -es na false . Aby stosować wersje prototypowe, należy ustawić opcje kompilatora na przeciwne wartości. Domyślna konfiguracja kompilatora w programach Flash Builder i Flash Professional to: -as3 = true oraz -es = false .

Jeśli planowane jest rozszerzanie klas podstawowych języka i przesłanianie metod, należy wziąć pod uwagę wpływ przestrzeni nazw AS3 na wymagany sposób deklarowania metod przesłoniętych. Jeśli używana jest przestrzeń nazw AS3, każda metoda przesłaniająca metodę klasy podstawowej języka musi również deklarować przestrzeni nazw AS3 wraz z atrybutem override . Jeśli przestrzeń nazw AS3 nie jest używana i planowane jest przedefiniowanie metody klasy podstawowej w podklasie, nie należy deklarować przestrzeni nazw AS3 ani słowa kluczowego override .