16.7 Statisch
ActionScript 2.0\Static
Die weitere Variante für die Mitglieder einer Klasse sind statische Elemente (engl. static). Hierbei handelt es sich um Eigenschaften und Methoden, die direkt über die Klassen angesprochen werden. Davon macht unter anderem die vordefinierte Math-Klasse Gebrauch (Klassen sind in der Flash-Welt auch Objekte, darum könnte man hier auch sagen, dass man das Math-Objekt meint). Das Verhalten statischer Eigenschaften und Methoden gibt es bereits im klassischen ActionScript:
Zum Vergleich: ActionScript 1
// ActionScript 1-Code!
function Freundin() {
this.kreativ = true;
}
Freundin.prototype.tanze = function() {
trace("yippi!");
};
// Definiere statische Eigenschaft
Freundin.anzahl = 0;
// Definiere statische Methode
Freundin.lerneKennen = function() {
this.anzahl++;
return new Freundin();
};
// Erzeuge Instanz
neueFreundin = Freundin.lerneKennen();
trace(Freundin.anzahl);
16.7.1 static
ActionScript 2.0 bietet für die Angabe von statischen Eigenschaften und Methoden eine elegante Variante dank des static-Schlüsselwortes. Es reicht aus, dieses Schlüsselwort einer Eigenschaftendeklaration (var) oder einer Funktionsdeklaration (function) voranzustellen.
class Freundin {
static var anzahl = 0;
static function lerneKennen() {
anzahl++;
return new Freundin();
}
// Öffentliche Mitglieder
var kreativ;
function Freundin() {
kreativ = true;
}
function tanze() {
trace("yippi!");
}
}
Der Zugriff auf diese Eigenschaften und Methoden erfolgt wie bereits bei der Variante in ActionScript 1 direkt über die Klasse:
// Erzeuge Instanz
neueFreundin = Freundin.lerneKennen();
trace(Freundin.anzahl);
Factory
Eine statische Methode, die eine Instanz der Klasse erzeugt und als Ergebnis zurückliefert, nennt man auch Factory-Methode (engl. für Fabrik), da diese, wie der Name schon sagt, ja etwas erzeugt.
16.7.2 Öffentlich oder privat
Statische Eigenschaften und Methoden dürfen wie andere Eigenschaften und Methoden sowohl öffentlich als auch privat sein. Sofern Sie nichts weiter angeben, handelt es sich immer um öffentliche Eigenschaften oder Methoden. Optional dürfen Sie public voranstellen, um dies explizit zu kennzeichnen. Den Zugriff von außerhalb verhindern Sie, indem Sie das Schlüsselwort privat verwenden:
// ActionScript 2.0-Code in Klassendatei
class Ich {
// public ist optional
public static var weissJeder:String = "Das weiß Jeder.";
private static var gehtNiemandenWasAn:String = "Das weiß nur ich.";
// public ist optional
public static function tuWas() {
trace("Ich tue was!");
}
private static function tuWasGeheimes() {
trace("Ich tue was Geheimes!");
}
}
Die statische Klasse verwenden Sie wie im Folgenden, wobei die letzten beiden Anweisungen einen Compiler-Fehler ausgeben, da der Zugriff auf private Mitglieder einer Klasse von außen nicht erlaubt ist.
// ActionScript 1-Code!
trace(Ich.weissJeder);
trace(Ich.tuWas());
// Geht nicht, da privat
trace(Ich.gehtNiemandenWasAn);
trace(Ich.tuWasGeheimes());
Innerhalb einer statischen Klasse dürfen Sie natürlich auf die privaten Eigenschaften und Methoden zugreifen, sonst würde das Ganze ja auch keinen Sinn machen. Dabei ist es unerheblich, ob Sie aus einer Instanz der Klasse (bei gemischter Nutzung von statischen und nicht statischen Methoden) oder aus einer statischen Methode auf die privaten Elemente zugreifen.
// ActionScript 2.0-Code in Klassendatei
class Du {
private static var guthaben:Number = 500;
// public ist optional
public static function kaufe(wert:Number):Boolean {
if (wert>guthaben) {
return false;
} else {
guthaben = guthaben-wert;
return true;
}
}
}
// ActionScript 1-Code!
trace(Du.kaufe(199));
// Geht nicht, da privat
trace(Du.guthaben);
Insgesamt haben Sie also jeweils vier Möglichkeiten, Eigenschaften und Methoden zu nutzen. Diese sind in den folgenden Tabellen zusammengefasst.
Tabelle 16.1
Deklaration öffentlicher und privater Eigenschaften
|
öffentlich
|
privat
|
Nicht statisch
|
var eigenschaft:Typ;
|
private var eigenschaft:Typ
|
public var eigenschaft:Typ;
|
Statisch
|
static var eigenschaft:Typ;
|
private static var eigenschaft;
|
public static var eigenschaft;
|
Tabelle 16.2
Deklaration öffentlicher und privater Methoden
|
öffentlich
|
privat
|
Nicht statisch
|
function methode () {}
|
private function methode () {}
|
public function methode () {}
|
Statisch
|
static function methode () {}
|
private static function methode () {}
|
public static function methode () {}
|
16.7.3 Statisch versus Singleton
Klassen mit ausschließlich statischen Eigenschaften und Methoden bezeichnet man als statische Klassen. Um zu verhindern, dass von dieser Klasse Instanzen erzeugt werden, sollte die Konstruktor-Methode als private Methode implementiert werden:
// Von dieser Klasse kann von außen keine Instanz erzeugt werden!
class Freundin {
private function Freundin() {
}
}
Diese kommen meist dann zur Verwendung, wenn nur eine Instanz der Klasse benötigt wird. Populäre Beispiele sind die bereits erwähnte Math-Klasse und die Key-Klasse. Diese Klassen bieten eine Sammlung von Eigenschaften und Methoden, die direkt über die entsprechende Klasse (also Math und Key) Verwendung finden:
trace(Math.sin(Math.PI/2));
trace(Key.isDown(Key.SHIFT));
Für diese Klassen gilt, dass sie von keiner anderen Klasse erben können und dass auch keine andere Klasse von Ihnen erben kann. Denn innerhalb von Flash ist nur das Erben und Vererben von Eigenschaften und Methoden erlaubt, die nicht statisch sind! Außerdem darf es keine Notwendigkeit für eine Initialisierung durch einen Konstruktor geben. Denn auch das ist mit rein statischen Klassen nicht möglich, da es keinen Erzeugungsprozess gibt, bei dem eine Konstruktormethode aufgerufen wird. Somit beschränken sich statische Klasse meist auf eine Sammlung global benötigter Eigenschaften und Methoden, die es auch nur einmal geben kann. Key ist u.a. deshalb statisch, da es nur eine einzige Tastatur gibt, was z.B. auch auf Stage zutrifft (engl. für Bühne).
Eine Alternative zu statischen Klassen bietet das Singleton-Entwurfsmuster, das ebenfalls nur eine Instanz erlaubt. Doch in diesem Fall wird diese Instanz explizit erzeugt und steht nicht wie eine statische Klasse von vornherein global zur Verfügung. Letztendlich ist eine Singleton-Klasse nichts anderes als eine normale Klasse inklusive allen Möglichkeiten wie Vererbung usw., mit dem Unterschied, dass nur eine Instanz erlaubt ist. Beispielsweise benötigen Sie ein einziges Objekt zur Fehlerverwaltung oder zur Kommunikation mit dem Server.
Klasse als Singleton definieren
Flash bietet keine direkte Möglichkeiten, eine Klasse als Singleton zu definieren, so dass dies über die Programmierung sichergestellt werden muss. Zwei Wege sind hier üblich. Der erste erzeugt bei mehr als einer Instanziierung eine Warnmeldung. Die zugehörige Klasse könnte wie folgt aussehen:
// singleton da monogam
class Freundin {
static var anzahl = 0;
function Freundin() {
anzahl++;
if (anzahl>1) {
trace("Fehler! Es darf nur eine Freundin geben.");
// oder Exception mit throw erzeugen
}
}
}
Die Verwendung geschieht wie gewohnt:
meineFreundin = new Freundin();
zweiteFreundin = new Freundin(); // Gibt Fehlermeldung aus
Die zweite Variante für Singleton-Klassen verhindert mehr als eine Instanz, indem diese nur durch eine Factory-Methode generiert werden:
// singleton da monogam (über Factory-Methode)
class Freundin {
private static var instance:Freundin = null;
private function Freundin() {
}
static function lerneKennen() {
if (instance === null) {
instance = new Freundin();
}
return instance;
}
}
Die Verwendung geschieht in diesem Fall ausschließlich über die Factory-Methode:
meineFreundin = Freundin.lerneKennen();
zweiteFreundin = Freundin.lerneKennen(); // Ist identisch mit erster Freundin
Abstrakte Klassen
Das Konzept abstrakter Klassen ist Flash unbekannt. D.h. Sie können in Flash keine Klassen anlegen, von denen es keine Instanz gibt.
Für die Vererbung von Grundfunktionalität sind abstrakte Klassen jedoch nützlich, wie das Beispiel einer abstrakten Schaltfläche zeigt. Diese dient als Grundlage für CheckBoxen und RadioButtons, erzeugt aber selber keine sinnvollen Instanzen.
Um nun sicherzustellen, dass es von einer Klasse keine Instanzen gibt, können Sie leider nicht denselben Trick verwenden wie bei den oben erwähnten Singleton-Klassen. Denn das »Hochzählen der Instanzen« geschieht auch innerhalb der Vererbungskette, da der Konstruktor der abstrakten Klasse in diesem Fall ebenfalls aufgerufen wird. In anderen Programmiersprachen wie Smalltalk verwenden Entwickler in diesem Fall die folgende Vereinbarung: Die Methoden in der abstrakten Klasse, die in der zugehörigen Unterklasse überschrieben werden müssen, erzeugen beim direkten Aufruf eine Fehlermeldung!
|