Kapitel 16 ActionScript 2.0

Von ActionScript auf ActionScript 2.0 umsteigen

ActionScript und ActionScript 2.0 unterscheiden sich viel weniger, als es der Anschein vermuten lässt. Und gerade für Entwickler, die ActionScript neu erlernen möchten, gestaltet sich der Einstieg in ActionScript 2.0 viel einfach als noch bei ActionScript.

04_Fortgeschritten\ActionScript 2.0

Die Programmierung von Flash ist für Ein- und Umsteiger oft eine große Herausforderung. Doch wer bereits mit Java und ähnlichen Sprachen arbeitet, für den ist der Einstieg in Flash dank des neuen, auf ECMAScript 4 (http://www.mozilla.org/js/language/es4) basierenden ActionScript 2.0 kein großes Problem mehr; zumindest sofern eine Version von Flash MX 2004 möglichst in der Professional-Version vorhanden ist!

Und auch wer sich vorher eher mit Skriptsprachen wie JavaScript und Co. beschäftigt hat, der findet sich mit der zweiten Version von ActionScript schneller in Flash zurecht als vielleicht vermutet. Gerade aus diesem Grund enthalten einige Kapitel zu Beginn oft noch einmal ein Beispiel in ActionScript 1 – schließlich sollen Umsteiger und Einsteiger bemerken, wie einfach alles mit ActionScript 2.0 geht.

16.0.1 Der wesentliche Unterschied 

Aber die Unterschiede zwischen den beiden »Dialekten« sind geringer, als man denkt: Im Wesentlichen bestehen sie darin, dass sich ActionScript 2.0 ausschließlich auf externe Dateien beschränkt, die automatisch von Flash als Vorlagen (Klassen) für Objekte verwendet werden (dies ist, wie sich später zeigen wird, ein großer Vorteil). Dafür gibt es eine Hand voll zusätzlicher Schlüsselwörter kombiniert mit den bereits im herkömmlichen ActionScript erlaubten Anweisungen.

Letztendlich war es das auch weitestgehend! Schließlich muss die Kompatibilität mit dem Flash Player gewährleistet bleiben, indem beide Programmierarten in denselben Bytecode (SWF) verwandelt werden: ActionScript 2.0 funktioniert bereits ab dem Flash Player 6. Aus diesem Grund ist beispielsweise die neue Typisierung nur mäßig hilfreich, da die Bestimmung des Typs nur während der Erzeugung des Bytecodes überprüft wird (also bei der »Kompilierung«). Zur Laufzeit ist also alles so wie immer …

16.1 Klassen 

Zum Vergleich: ActionScript 1

Angenommen Sie benötigen ein Objekt, dann ist der herkömmliche Weg, dass Sie eine Instanz vom generischen Objekt erzeugen:

// ActionScript 1-Code!

04_Fortgeschritten\ActionScript 2.0\Klassen

// Erzeuge Instanz
meineFreundin = new Object();
// Definiere Eigenschaft
meineFreundin.kreativ = true;
// Definiere Fähigkeit
meineFreundin.tanze = function () {
   trace("yippi!");
}

Mehr über die Idee der Objekterstellung erfahren Sie im Kapitel 13.

Für den Fall, dass mehrere Instanzen benötigt werden, erstellen Sie mit Hilfe einer Funktion den Prototypen für alle Instanzen wie im Kapitel »Objekterstellung« erklärt. Die Funktion übernimmt dabei die Aufgabe einer Klasse und des Konstruktors. Eigenschaften und Fähigkeiten weisen Sie entweder jeder Instanz innerhalb der Funktion zu, oder Sie bringen der gesamten Klasse diese Dinge einmalig über die Prototyp-Eigenschaft der Funktion bei:

// ActionScript 1-Code!
function Freundin() {
   // Definiere Eigenschaft
   this.kreativ = true;
}
// Definiere Fähigkeit
Freundin.prototype.tanze = function() {
   trace("yippi!");
};
// Erzeuge Instanzen
meineFreundin = new Freundin();
meineGeliebte = new Freundin();

Jetzt müssen Sie nur noch sicherstellen, dass die Klasse global zur Verfügung steht und in Flash im allerersten Schlüsselbild (also so früh wie möglich) deklariert wird, damit überall eine Instanz erzeugt werden kann:

// ActionScript 1-Code!
// Inline-Schreibweise für den Prototypen, um diesen global zu
deklarieren
_global.Freundin = function() {
   // Definiere Eigenschaft
   this.kreativ = true;
}
// Erzeuge Instanzen an beliebiger Stelle
meineFreundin = new Freundin();
meineGeliebte = new Freundin();

16.1.1 class 

ActionScript 2.0

Verglichen mit ActionScript 1 ist der Code für selbst definierte Klassen dank ActionScript 2.0 nun deutlich besser lesbar. Eine Klasse wird dabei von dem class-Schlüsselwort gefolgt von dem Klassennamen in einer eigenen Datei beschrieben:

class Klassenname {
}

Die entsprechende Klassen-Datei klassenname.as bindet Flash automatisch in die fertige SWF-Datei ohne weiteres Zutun global und (sofern Sie keine weiteren Angaben gemacht haben) von Anfang an ein, sobald diese verwendet wird.

Konstruktor

Optional dürfen Sie die Klasse mit einem Konstruktor versehen, der wie bereits bei ActionScript 1 jedes Mal ausgeführt wird, wenn eine neue Instanz der Klasse erzeugt wird. Dieser Konstruktor benötigt den gleichen Namen wie die Klasse:

class Klassenname {
   function Klassenname() {
   }
}

Weitere Methoden legen Sie wie den Konstruktor innerhalb der Klassenbeschreibung an:

class Klassenname {
   function Klassenname() {
   }
   function methode() {
   }
}

Eigenschaften

Eigenschaften sind ebenfalls erlaubt und werden mit dem Schlüsselwort var angegeben:

class Klassenname {
   var eigenschaft;
   function Klassenname() {
   }
   function methode() {
   }
}

Für das Beispiel einer Freundin reicht es aus, dass Sie eine ActionScript 2.0-Datei mit dem folgenden Code erstellen und diese im selben Verzeichnis wie die Flash-Datei ablegen:

class Freundin {
   // Definiere Eigenschaft
   var kreativ;
   // Konstruktor (optional)
   function Freundin() {
      // Setze Eigenschaft
      kreativ = true;
   }
   // Definiere Fähigkeit
   function tanze() {
      trace("yippi!");
   }

Erzeugen einer neuen Instanz

}

Sofern alles richtig angelegt ist, reicht zum Erzeugen einer neuen Instanz ab dann die Angabe von

meineFreundin = new Freundin();

Gültigkeitsbereich

In ActionScript 1 ist innerhalb von Methoden und Konstruktormethoden eines Prototypens das Schlüsselwort this wichtig, da es eine Referenz auf die aktuelle Instanz der Klasse enthält. Andernfalls würden die Anweisungen in den Methoden nicht die jeweiligen Instanzen, sondern das Objekt beeinflussen, in dem die Methoden geschrieben sind.

In ActionScript 2.0 gibt es diese Unterscheidung zwischen dem Ort, an dem das Skript geschrieben steht, und dem Ort, an dem das Skript ausgeführt wird, nicht mehr in dieser Form. Aus diesem Grund kann auf this in den meisten Fällen verzichtet werden, da sich ohnehin alle Anweisungen auf die zugehörige Instanz beziehen. Nur wenn Sie mit Methoden arbeiten, die es schon als Aktionen in älteren Flash-Versionen gab, dann sollten Sie lieber nicht auf this verzichten, da sonst der Compiler durcheinander gerät (z.  B. bei Aktionen wie stop oder gotoAndPlay).

16.1.2 Technisch gesehen 

ActionScript 2.0 ist im Wesentlichen nur eine andere Schreibweise für die objektorientierte Programmierung in Flash. Zur Laufzeit werden ActionScript 1 und 2.0 gleich behandelt! Denn zur Laufzeit stehen die Klassen genauso im Arbeitsspeicher zur Verfügung wie bei ActionScript 1. Dies bedeutet, dass auch ActionScript 2.0-Klassen direkt über den Klassennamen ansprechbar und über die Eigenschaft prototype zur Laufzeit erweiterbar sind.

Die folgende Klasse zum Beispiel bietet noch keine Funktionalität:

ActionScript 2.0\technisch gesehen

// ActionScript 2.0-Code in Klassendatei
class Freundin {
}

Innerhalb einer Flash-Anwendung werden wie bei der prototypbasierten Programmierung Methoden und Eigenschaften mit ActionScript 1 hinzugefügt, obwohl es sich bei der eigentlichen Klasse um ActionScript 2.0 handelt:

// ActionScript 1-Code!
Freundin.prototype.tanze = function() {
   trace("yippi!");
};
meineFreundin = new Freundin();
meineFreundin.tanze();
Freundin.prototype.tanze = function() {
   trace("mag nicht!");
};

Siehe Kapitel »Vererbung«, Seite 350

meineFreundin.tanze();

Was für die Klasse gilt, gilt auch für die Instanzen einer Klasse. Denn jede Instanz einer Klasse – egal ob ActionScript 1 oder 2.0 – verfügt über eine __proto__-Eigenschaft, mit deren Hilfe zur Laufzeit auf den Prototypen der zugehörigen Klasse zugegriffen werden kann.

Angenommen Sie haben eine Klasse Loewe, die von der Klasse Katze erbt:

class Katze {
  function sprich() {
    trace("Miau!");
  }
}

class Loewe extends Katze {
  function sprich() {
    trace("Roarrr!");
  }
}

Und nun stellt sich die Anforderung, dass eine Instanz der Klasse Loewe aus unerfindlichen Gründen plötzlich wie eine Katze sprechen soll, dann erreichen Sie dies über die Eigenschaft __proto__:

// ActionScript 1-Code!
sensiblerLoewe = new Loewe();
// Gibt "Roarr!" aus (Instanz)
sensiblerLoewe.sprich();
// Gibt "Roarr!" aus (Prototyp Loewe)
sensiblerLoewe.__proto__.sprich();
// Gibt "Miau!" aus (Prototyp Katze)
sensiblerLoewe.__proto__.__proto__.sprich();

Aber sowohl das direkte Ansprechen des Prototypen als auch die Verwendung von __proto__ sollten unbedingt vermieden werden, da dies den Code schwer lesbar und fehleranfällig macht!

Modularer Aufbau der Klassen

16.1.3 Klassenpfade 

ActionScript 2.0 erlaubt einen saubereren und modulareren Aufbau der Klassen, sofern Sie die beiden wichtigsten Regeln beachten:

Der Name von ActionScript 2-Dateien muss inklusive der Groß- und Kleinschreibung mit dem Klassennamen übereinstimmen.

ActionScript 2-Dateien müssen entweder im selben Verzeichnis wie die Flash-Datei liegen, oder Sie geben den Klassenpfad an, indem Sie mit dem Menü Bearbeiten • Voreinstellungen in das Register ActionScript wechseln und dort die Schaltfläche ActionScript 2.0-Einstellungen klicken. Ebenfalls sind in Unterverzeichnissen abgelegte Klassenansammlungen (Packages) erlaubt, die auch über den Import-Befehl eingelesen werden können.

Aufgrund der dateibasierten Struktur von Klassen lassen sich diese in beliebigen anderen Anwendungen (meist) ohne weiteres Zutun einsetzen. Die erzwungene dateibasierte Modularität trägt zu einer enormen Verbesserungen im Workflow bei: Zum Beispiel können Komponenten nun ohne weiteres direkt mit ActionScript 2.0-Klassen verbunden werden (siehe Kapitel »Komponenten«, Seite 426).

Hier klicken, um das Bild zu Vergrößern

Abbildung 16.1   Den Ort häufig gebrauchter Klassen legen Sie in Flash innerhalb der ActionScript 2.0-Einstellungen fest.

Normalerweise stehen alle verwendeten ActionScript 2.0-Klasen in einer Flash-Anwendung von Anfang an zur Verfügung. Möchten Sie das Ladeverhalten einer Flash-Anwendung dadurch beeinflussen, dass ActionScipt 2.0-Klassen nicht von Anfang an, sondern erst später verfügbar sind, dann gelingt dies, indem Sie in das Menü Datei • Einstellungen für Veröffentlichungen wechseln, dort in das Register Flash gehen und die Schaltfläche Einstellungen klicken. Im anschließenden Dialogfenster dürfen Sie die Klassenpfade für die aktuelle Flash-Datei einstellen. Außerdem legen Sie fest, ab welchem Bild die ActionScript 2.0-Klassen verfügbar sind.

Klassenpfade

In Flash gibt es zwei Abkürzungen für die Angabe von Klassenpfaden in den ActionScript 2.0-Einstellungen. Zum einen ist dies »$(LocalData)/Classes« für das Klassenverzeichnis im Konfigurationsordner von Flash (siehe Seite 99). Diesen Pfad sollten Sie immer angaben, da Flash sonst auch nicht die bereits in Flash eingebauten Klassen erkennt. Und zum anderen geben Sie mit dem Punkt ».« das Verzeichnis der aktuellen FLA-Datei als möglichen Klassenpfad vor.

16.1.4 ASO (ActionScript Objekt) 

Flash erzeugt beim Kompilieren aus den Klassen ActionScript-Objekte (ASO), die eine kompilierte Version der Klassen enthalten. Das Format der ASO-Dateien ist nicht dokumentiert und in Flash nur für interne Zwecke gedacht!

Die zugehörigen ASO-Dateien legt Flash in dem Standardverzeichnis für globale Klassen ab: Unter Windows XP finden Sie diese Datei meist unter C:\Dokumente und Einstellungen\[Benutzer]\Lokale Einstellungen\Anwendungsdaten\Macromedia\Flash MX 2004\[Sprache]\Configuration\Classes im Ordner aso.

Einschränkungen

Für ASO-Dateien und damit auch für Klassen bestehen dabei die folgenden Einschränkungen:

Nicht mehr als 69 Zeichen: Leider dürfen die Namen von Klassen inklusive der Angabe des zugehörigen Packages nicht mehr als 69 Zeichen haben. Andernfalls kann Flash diese Klassen nicht mehr korrekt als ActionScript-Objekte speichern (ASO) und in Flash einbinden. Flash meldet bei längeren vollständig qualifizierten Klassenbezeichnern keinen Fehler!

Nicht mehr als 1500 Codezeilen: Der Bytecode einer kompilierten Klasse darf nicht mehr als 32767 Bytes umfassen, was in der Praxis ungefähr 1500 Codezeilen entspricht. Andernfalls zeigt Flash einen Fehler an. Verteilen Sie den Programmcode in diesem Fall auf mehrere kleine Klassen, was ohnehin die bessere Vorgehensweise ist.

Flash nutzt ASO-Dateien quasi als eine Art Cache, um bereits kompilierte und unveränderte Klassen nicht erneut kompilieren zu müssen. Dies beschleunigt die Erstellung von SWF-Dateien. Sollte Flash dabei einmal eine veränderte Klasse nicht erneut kompilieren, dann erzwingen Sie dies, indem Sie die zugehörige ASO-Datei manuell löschen. Unter http://www.macromedia.com/cfusion/exchange/index.cfm?extid=1016963&view=sn111 erhalten Sie direkt bei Macromedia eine Erweiterung für Flash MX 2004, die das Löschen der ASO-Dateien automatisiert.