info@a-coding-project.de

JScript.net: Arbeiten mit Klassen

Klassen sind ein neuer wichtiger Bestandteil von JScript.NET - im vorherigen Kapitel wurde mehrmals kurz darauf eingegangen. Eine Klasse kann man sich - wie erwähnt - als eine Art Schablone vorstellen, die als Vorlage für neue Objekte dienen kann.

Eine Klasse erstellen

Eine Klassendefinition wird immer durch das Wort class eingeleitet. Diesem folgt der Name der Klasse und ein Anweisungsblock. Innerhalb des Blocks können dann sämtliche Eigenschaften, Methoden und Konstruktoren (etc.) dieser Klasse definiert werden. Eigenschaften werden definiert, indem eine Variable innerhalb der Klasse erstellt wird - Methoden werden einfach durch eine Funktion innerhalb der Klasse ausgedrückt. Ebenso können auch Konstanten als Eigenschaften der Klasse definiert werden. Eine Methode kann dabei auf die Eigenschaften der Klasse über den Namen der jeweiligen Eigenschaft zugreifen. Beispiel:

class Person
{
 var Name : String;
 var Alter : int;
 var Jahr : int;
 var Anschrift : String;
 function sagName() { print(Name); }
}
var michael : Person = new Person;
michael.Name = 'Michael';
michael.Alter = 32;
//...

Im Beispiel wird eine relativ simple Klasse Namens Person definiert. Innerhalb des Blocks werden dann die Eigenschaften - hier Name, Alter, Jahr und Anschrift - und Methode/n (sagName) definiert. Anschließend wird eine Variable michael von eben diesem Typ erstellt und zugleich initialisiert. Auf die Eigenschaften von michael kann nun wie bei einem normalen Objekt zugegriffen werden.

Konstruktoren von Klassen

Ein Konstruktor (engl. constructor) ist nichts anderes als eine Funktion, die ein Objekt einer bestimmten Klasse erstellt. Diese Funktion wird automatisch beim Erstellen eines Objektes dieser Klasse aufgerufen und kann so z.B. bestimmte Eigenschaften mit Werten belegen. Eine solche Funktion muss immer innerhalb der Klassendefinition notiert werden für die sie verwendet werden soll und muss dazu noch den Namen der Klasse tragen. Beispiel:

class Person
{
 var Name : String;
 var Alter : int;
 var Jahr : int;
 var Anschrift : String; 
 function sagName() { print(Name); }

 function Person()
 {
  Name = 'Klaus';
  Alter = 22;
 }
 
 function Person(n:String, a:int)
 {
  Name = n;
  Alter = a;
 }
}

var x : Person = new Person;
var y : Person = new Person();
var z : Person = new Person('Max Mustermann',45);
print(x.Name); // gibt Klaus aus
print(y.Name); // gibt Klaus aus
print(z.Name); // gibt Max Mustermann aus

Wie im Beispiel ersichtlich können auch mehrere Konstruktoren für eine Klasse definiert werden sofern sich ihre Parameter unterscheiden - hier sind es die zwei Funktionen Person die einmal ohne Parameter und einmal mit den Parametern n und a aufgerufen werden kann.

Getter und Setter

Wie schon in JavaScript 1.5 und den Planungen für 2.0 eingebunden, gibt es nun auch in JScript.NET Getter und Setter. Diese werden wie im JavaScript Version 2.0 Proposal vorgeschlagen mit der Syntax ...

function get Variablenname [: Typ] ([Parameter]){...}

... und ...

function set Variablenname [: Typ] ([Parameter]){...}

... notiert. Wichtig dabei: Eine Getter- bzw. Setter-Funktion erstellt quasi eine neue Variable. Nehmen wir an, es soll eine Eigenschaft x geben. Dann kann es eine Funktion get x() : Typ {...} und eine Funktion set x(Wert : Typ) { ... } geben - es darf jedoch keinen Aufruf var x : Typ geben da dieser sich mit den Funktionen überschneiden würde. Ebenfalls überaus wichtig: Getter und Setter dürfen nur innerhalb von Klassendefinitionen verwendet werden um auf eine Eigenschaft zuzugreifen oder diese zu schreiben. Beispiel:

class Person
{
 var Name : String;
 var Alter : int;
 //Variable Jahr wird ersetzt durch eine neue 
 //quasi-Variable Jahr (Getter & Setter)
 //var Jahr : int;
 var Anschrift : String; 
 function sagName() { print(Name); }

 function Person() { Name = 'Klaus'; Alter = 22; }
 function Person(n:String, a:int) { Name = n; Alter = a; }

 function get Jahr():int
 {
  var d : Date = new Date();
  return( d.getYear()-Alter );
 }
 
 function set Jahr(i:int) 
 {
  var d : Date = new Date();
  Alter = d.getYear()-i;
 }
}

var a : Person = new Person('Hans',45);
print(a.Jahr); // im Jahr 2003 wird 1958 ausgegeben
a.Jahr = 1983;
print(a.Alter); // im Jahr 2003 wird 20 ausgegeben

Im Beispiel wird die bereits oben definierte Klasse etwas erweitert. Die Eigenschaft Jahr wird durch eine quasi-Eigenschaft ersetzt, die durch Getter- und Setter-Funktionen definiert wird. Wird der Wert für diese Eigenschaft geschrieben, so berechnet JScript ein neues Alter der Person aus dem übergebenen Geburtsdatum und dem aktuellen Jahr. Umgekehrt ist es, wenn die Eigenschaft gelesen wird: Hier wird aus dem Alter und dem aktuellen Jahr das dementsprechende Geburtsjahr berechnet.
Bitte beachten Sie, dass es nicht Pflicht ist, beide Funktionen zu definieren. Vielmehr ist es auch möglich Eigenschaften zu erstellen, die nur gelesen oder geschrieben werden können.

Sichtbarkeit bestimmen

Unter Sichtbarkeit einer Klasse, Eigenschaft oder Methode versteht man, in wie fern das betreffende "Ding" für andere Klassen, Objekte oder Variablen (etc.) sichtbar ist - damit also, in wie weit es von diesen verwendet werden kann. Zum Beispiel dient eine unsichtbare Klasse lediglich internen Zwecken und kann nicht von anderen Bereichen verwendet werden um daraus ein Objekt abzuleiten. JScript.NET unterscheidet in 4 verschiedene Stufen der Sichtbarkeit: internal, privat, protected und public. Diese Worte werden Modifizierer genannt.
Grundsätzlich werden alle gleich notiert. Soll eine Klasse damit beschreiben werden, so wird der entsprechende Modifizierer vor dem Wort class notiert. Bei Eigenschaften und Methoden wird gleich verfahren: Hier steht der Modifizierer eben vor var, const bzw. function.

internal

Mit internal definierte Klassen, Eigenschaften oder Methoden sind nur innerhalb (internal ~ engl. intern) des aktuellen Paketes sichtbar. Code außerhalb des Paketes kann nicht auf diese zugreifen. Wird eine globale Klasse oder eine Eigenschaft oder Methode einer globalen Klasse mit diesem Modifizierer deklariert, so entspricht dies der Verwendung des public-Modifizierers. Dieser Modifizierer darf nicht mit einer der drei anderen kombiniert werden.
Hinweis: Globale Klassen sind Klassen, die nicht innerhalb eines Paketes definiert werden. Sie stehen allgemein im gesamten Code zur Verfügung.

privat

Eine mit dem Modifizierer privat erstellte Eigenschaft oder Methode ist nur innerhalb dieser Klasse sichtbar - nicht aber nach Außen hin. Auch Klassen, die von dieser Klasse abgeleitet werden können nicht auf diese Eigenschaft oder Methode zugreifen. Eigenschaften und Methoden globaler Klassen können nicht mit diesem Modifizierer beschrieben werden. Bitte beachten Sie, dass mit diesem Modifizierer nur Eigenschaften und Methoden beschrieben werden können aber keine Klassen selbst. Diese können nur dann damit definiert werden, sofern es sich um eine geschachtelte Klasse (Klassendefinition innerhalb einer Klasse) handelt.

protected

Mit dem protected-Modifizierer können Eigenschaften und Methoden einer Klasse geschützt werden. Diese sind nach außen hin unsichtbar und können nur innerhalb der Klasse oder von abgeleiteten Klassen verwendet werden. Eigenschaften und Methoden globaler Klassen können nicht mit diesem Modifizierer beschrieben werden. Bitte beachten Sie, dass mit diesem Modifizierer nur Eigenschaften und Methoden beschrieben werden können aber keine Klassen selbst. Diese können nur dann damit definiert werden, sofern es sich um eine geschachtelte Klasse handelt. Bitte beachten Sie außerdem, dass dieser Modifizierer nicht kombiniert werden darf.

public

Der public-Modifizierer deklariert eine Klasse, Eigenschaft oder Methode als sichtbar ohne gewisse Einschränkungen die die anderen Modifizierer mit sich bringen würden. Generell sind alle Klassen, Eigenschaften und Methoden, die nicht mit einer dieser Modifizierer beschrieben wurden, als public definiert. Dieser Modifizierer darf nicht mit einer der drei anderen kombiniert werden.
Ein Beispiel dazu:

public class Person
{
 public var Name : String;
 public var Alter : int;
 //Variable Jahr wird ersetzt durch eine neue 
 //quasi-Variable Jahr (Getter & Setter)
 //var Jahr : int;
 protected var Anschrift : String; 
 public function sagName() { print(Name); }

 function Person() { Name = 'Klaus'; Alter = 22; }
 function Person(n:String, a:int) { Name = n; Alter = a; }

 function get Jahr():int
 {
  var d : Date = new Date();
  return( d.getYear()-Alter );
 }
 
 function set Jahr(i:int) 
 {
  var d : Date = new Date();
  Alter = d.getYear()-i;
 }
}

var a : Person = new Person;
a.Anschrift = 'Musterstraße 13, 56789 Musterstadt';
//erzeugt einen Fehler beim Kompilieren, da Anschrift 
//mit protected definiert wurde

Klassen erweitern

Wie es bisher auch möglich war, können Objekttypen von anderen Objekttypen her abgeleitet werden. Abgeleitet Typen erben die Eigenschaften und Methoden des Quelltyps und können diese durch neue ergänzen. Bei Klassen ist gleiches ebenso möglich und noch mehr. Für die Erweiterung von Klassen wurden zwei neue Wörter eingeführt: extends und implements.
Bei der Definition einer neuen Klasse, die von einer Basisklasse Eigenschaften und Methoden erben soll, wird dazu das Wort extends (engl. erweitern) nach dem Klassennamen aufgeführt. Danach folgt der Name der Basisklasse von der aus erweitert werden soll. Letztlich folgt nach dieser Definition der weitere Aufbau der Klasse. Beispiel:

public class Mensch
{
 enum eGeschlecht {Mann, Frau};
 var Geschlecht: eGeschlecht;
}

public class Person extends Mensch
{
 public var Name : String;
 public var Alter : int;
 protected var Anschrift : String; 
 function sagName() { print(Name); }

 function Person() { Name = 'Klaus'; Alter = 22; }
 function Person(n:String, a:int) { Name = n; Alter = a; }
 function get Jahr():int 
 { var d : Date = new Date(); return( d.getYear()-Alter ); }
 function set Jahr(i:int) 
 { var d : Date = new Date(); Alter = d.getYear()-i; }
}

var a : Person = new Person;
a.Geschlecht = Mensch.eGeschlecht.Mann;
print(a.Geschlecht); //gibt Mann aus

Die bereits bekannte Klasse Person wird hier durch die Klasse Mensch erweitert. Man kann das in etwa wie eine Vererbung ansehen: Person erbt alle Eigenschaften und Methoden von Mensch (sofern sie nicht als unsichtbar deklariert wurden).
Ebenso wie Klassen von anderen Klassen erweitert werden können, können Klassen auch von Interfaces (Schnittstellen; dazu in einem späteren Kapitel mehr) erweitert werden. Dazu wird nach dem Klassennamen und der eventuellen extends-Definition das Wort implements notiert. Diesem folgt eine durch Kommata getrennte Liste von Interfacenamen. Innerhalb der Klasse können die Funktionen des Interfaces dann aufgegriffen und mit Code belegt werden. Beispiel:

public interface Lebewesen
{
 enum eLebewesen {Mensch, Tier};
 function get Typ():eLebewesen;
}

public class Mensch implements Lebewesen
{
 enum eGeschlecht {Mann, Frau};
 var Geschlecht: eGeschlecht;
 function get Typ():Lebewesen.eLebewesen
 {return(Lebewesen.eLebewesen.Mensch);}
}

public class Tier implements Lebewesen
{
 function get Typ():Lebewesen.eLebewesen
 {return(Lebewesen.eLebewesen.Tier);}
}

public class Person extends Mensch
{
 //...
}

var a : Mensch = new Mensch;
var b : Tier = new Tier;
print(a.Typ); //gibt Mensch aus
print(b.Typ); //gibt Tier aus

Im Beispiel wird das Interface Lebewesen definiert. Die Klassen Mensch und Tier verwenden die Schnittstelle nun als Grundlage und werden so indirekt erweitert und (viel wichtiger) standardisiert auf die verwendete Schnittstelle.

Instanzen beschreiben

Eine Instanz einer Klasse ist ein Objekt, das von dieser Klasse abgeleitet wird. Da es mit unter notwendig sein kann, dass aus manchen Klassen kein Objekt erzeugt werden kann oder das ein abgeleitetes Objekt nur bestimmte Eigenschaften und Methoden besitzt obwohl in der Klasse mehr definiert werden, stellt JScript.NET bestimmte Modifizierer zur Verfügung, die es erlauben die Instanzierung von Klassen und deren Eigenschaften und Methoden zu beschreiben. Die dazu notwendigen Modifizierer sind abstract, final und static.

abstract

Aus einer abstrakten Klasse können keine Objekte direkt erstellt werden. Sie wird für Klassen verwendet, die keine Implementierung besitzen, oder für solche Klassen die abstrakte Methoden enthalten. Eigenschaften können damit nicht direkt gekennzeichnet werden - es können nur solche beschrieben werden, die durch Getter bzw. Setter definiert werden. Wird der abstract-Modifizierer verwendet, bedeutet das für die beschriebene Klasse, dass sie abgeleitet (siehe extends) werden muss um verwendet werden zu können. Wird mit diesem Modifizierer eine Methode gekennzeichnet, so darf diese in der Klassendefinition keinen Funktionskörper besitzen (alles zwischen { und }) und muss entsprechend in einer abgeleiteten Klasse erneut definiert werden. Dieser Modifizierer kann nicht mit den beiden anderen genannten kombiniert werden.

public abstract class Lebewesen
{
 enum eLebewesen {Mensch, Tier};
 abstract function get Typ():eLebewesen;
}

public class Mensch extends Lebewesen
{
 enum eGeschlecht {Mann, Frau};
 var Geschlecht: eGeschlecht;
 function get Typ():Lebewesen.eLebewesen
 {return(Lebewesen.eLebewesen.Mensch);}
}

public class Tier extends Lebewesen
{
 function get Typ():Lebewesen.eLebewesen
 {return(Lebewesen.eLebewesen.Tier);}
}

//... Definition der Klasse Person wurde entfernt ...

var a : Mensch = new Mensch;
var b : Tier = new Tier;
print(a.Typ); //gibt Mensch aus
print(b.Typ); //gibt Tier aus

Das vorhergehende Beispiel wird hier wieder aufgegriffen. Aus dem Interface Lebewesen wird nun eine abstrakte Klasse gemacht. Die Klasse muss zum einen als abstract deklariert werden, da sie eine abstrakte Funktion enthält und zum anderen da sie nicht direkt als Objekt verwendet werden soll. Von der Klasse Lebewesen kann nur abgeleitet werden.

final

Mit dem Modifizierer final gekennzeichnete Klassen gelten als unableitbar. Ebenso können auch Methoden oder durch Getter bzw. Setter definierte Eigenschaften damit beschrieben werden. So definierte Klassen können nicht abgeleitet werden und entsprechende Methoden und Eigenschaften können nicht überschrieben werden. Dieser Modifizierer darf nicht mit den beiden anderen genannten Modifizierern kombiniert werden. Beispiel:

public abstract class Lebewesen
{ /*...zur besseren Übersicht entfernt ...*/ }

public class Mensch extends Lebewesen
{ /*...zur besseren Übersicht entfernt ...*/ }

public class Tier extends Lebewesen
{ /*...zur besseren Übersicht entfernt ...*/ }

public final class Person extends Mensch
{ /*...zur besseren Übersicht entfernt ...*/ }

// diese Klasse gibt einen Fehler aus, da Person bereits als 
// final beschrieben wurde und damit nicht mehr abgeleitet 
// werden kann
public class Mann extends Person

 // Eigenschaften und Methoden
}

Auch hier wird wieder das bestehende Beispiel aufgegriffen. Die Klasse Person wird jetzt als final deklariert. Aufgrund dessen kann keine abgeleitete Klasse Mann gebildet werden - es tritt also ein Fehler bei dieser Zeile auf.

static

Mit static können nur Eigenschaften oder Methoden - jedoch keine Klassen beschrieben werden. Der Modifizierer gibt an, dass die Eigenschaft oder Methode nicht zu einer Instanz der Klasse sondern zur Klasse selbst gehört. Dementsprechend kann auf so definierte Eigenschaften bzw. Methoden nur über den Klassennamen, nicht aber über ein Objekt zugegriffen werden. Der Modifizierer darf nicht mit den anderen beiden genannten kombiniert werden. Beispiel:

class Klasse
{
 var Eigenschaft1 : String = 'Eigenschaft1';
 static var Eigenschaft2 : String = 'Eigenschaft2';
}

var a:Klasse = new Klasse;
print(a.Eigenschaft1);
print(Klasse.Eigenschaft2);

Die Klasse enthält zwei Eigenschaften, wovon zweitere als static deklariert ist. Somit kann auf diese Eigenschaft nur über den Klassennamen aber nicht über das Objekt a zugegriffen werden.

Überschreiben von Eigenschaften und Methoden

Wird eine Klasse von einer anderen abgeleitet, können Methoden und Eigenschaften überschrieben und durch neue ergänzt werden. Was aber, wenn einem Objekt der abgeleiteten Klasse ein Objekt der Basisklasse zugewiesen wird? Sollen nun die Funktionen der abgeleiteten Klasse verwendet werden - da es sich ja ursprünglich um ebendieses gehandelt hat - oder sollen die Funktionen der Basisklasse verwendet werden - der das Objekt ja nun entspricht? Um diesen Vorgang steuern zu können stellt JScript.NET die zwei Modifizierer hide und override zur Verfügung.

Wird eine Eigenschaft oder eine Methode mit dem Wort hide beschrieben, bedeutet dies, dass die entsprechende Eigenschaft oder Methode der aktuellen Klasse verborgen wird und statt dessen die der Basisklasse verwendet wird. Bitte beachten Sie aber, dass nur Eigenschaften mit hide deklariert werden können, die durch Getter bzw. Setter definiert wurden. Darüber hinaus muss der Funktionskopf der Funktion der abgeleiteten Klasse mit dem der Basisklasse übereinstimmen. Mit dem Kopf function machwas() übereinstimmend ist function machwas() - nicht übereinstimmt sind z.B. function machwas(a:String), function machWas() oder function machwas():String. Dieser Modifizierer darf nicht mit den Modifizierern override und static kombiniert werden.

Mit dem Modifizierer override wird beschrieben, dass eine Funktion einer abgeleiteten Klasse die entsprechende Funktion der Basisklasse mit überschreibt. Die Funktion der Basisklasse muss dazu auch hier über den gleichen Funktionskopf verfügen. Außerdem darf dieser Modifizierer nicht mit den Modifizierern hide und static kombiniert werden.

Nehmen wir nun also das folgende Beispiel:

class Basisklasse
{
 function abc1(){print('Methode 1 der Basisklasse')}
 function abc2(){print('Methode 2 der Basisklasse')}
}

class Ableitung extends Basisklasse
{
 override function abc1(){print('Methode 1 der Ableitung')} 
 hide function abc2(){print('Methode 2 der Ableitung')}
}

var a:Ableitung = new Ableitung;
var b:Basisklasse = a;

b.abc1(); // gib "Methode 1 der Ableitung" aus
b.abc2(); // gib "Methode 2 der Basisklasse" aus

Hier werden zwei Klassen und davon zwei Objekte erstellt. Die Objekte besitzen also die Funktionen der jeweiligen Klasse. Bei der Definition des Objektes b wird diesem das Objekt a übergeben, welches bekanntlich vom Typ der Ableitung ist. Mit den Modifizierern wird nun geregelt, welche Funktionen von b zur Ableitung gehören und welche zur Basisklasse. Die erste Funktion abc1 wurde mit override definiert - es wird also die Funktion der Ableitung verwendet, obwohl es sich hier um ein Objekt der Basisklasse handelt. Zweitere Funktion abc2 wurde mit hide definiert - hier tritt das entsprechende Gegenteil auf: Es wird die Funktion der Basisklasse verwendet.

Dynamische Klassen

Dynamische Klassen sind Klassen, die zur Laufzeit durch weitere Eigenschaften erweitert werden können. Das Prinzip sollte von JavaScript her bekannt sein. Hier war es möglich einfach eine neue Eigenschaft zu erfinden und ihr einen Wert zuzuweisen, obwohl die Objektdefinition diese Eigenschaft gar nicht vorsah. In JavaScript konnte das z.B. so aussehen:

<script language="JavaScript">
<!--
function Person(a,b)
{
 this.vorname = a;
 this.nachname = b;
}

var p = new Person('Jan','Winkler');
p.datum = '15.07.1983';
alert(p.vorname+' '+p.nachname+'ngeboren am '+p.datum);
//-->
</script>

Gleiches Beispiel würde in JScript.NET wie folgt aussehen:

expando class Person
{
 var vorname : String;
 var nachname : String;
 function Person(a:String, b:String)
 {vorname = a; nachname = b;}
}

var p = new Person('Jan','Winkler');
p["datum"] = '15.07.1983';

print(p.vorname+' '+p.nachname+'ngeboren am '+p["datum"]);

Wie man erkennen kann, gibt es zwei deutliche Unterschiede: Eine Klasse muss explizit als dynamisch erweiterbar ausgezeichnet werden. Dazu dient der expando-Modifizierer. Außerdem kann auf expando-Eigenschaften nicht über die Punktsyntax zugegriffen werden (Objekt.Eigenschaft) - vielmehr muss hier wie bei einem Array verfahren werden indem nach dem Objektnamen zwei eckige Klammern notiert werden. Innerhalb dieser Klammern wird ein String notiert, der den Namen der Eigenschaft enthält.

Auf die Basisklasse zugreifen

Unter Umständen kann es nötig sein, von einer Klasse aus auf die entsprechende Basisklasse zuzugreifen. Hierfür gibt es die super-Anweisung. Sie funktioniert auf zweierlei Möglichkeiten:

Zum Zugriff auf die Eigenschaften und Methoden der Basisklasse wird die super-Anweisung wie ein Objekt behandelt. Das heißt, man notiert das Wort super, einen Punkt und anschließend die jeweilige Eigenschaft oder Methode.

Die andere Möglichkeit ist der Zugriff auf den Konstruktor der Basisklasse. Hierzu wird das Wort super gefolgt von runden Klammern notiert. Innerhalb der Klammern stehen dann die entsprechenden Parameter die der Konstruktor erwartet.
Beispiel:

class Basisklasse
{
 var Text : String = 'Dies ist die Basisklasse';
 var Text2 : String = 'Dies ist Text2 der Basisklasse';
 function Basisklasse(){}
 function Basisklasse(t:String){Text = t;}
}

class Ableitung extends Basisklasse
{
 function Ableitung(){super('Dies ist die Ableitung');}
 function sageText(){ print(super.Text2); }
}

var a : Basisklasse = new Basisklasse;
var b : Ableitung = new Ableitung;
var c : Basisklasse = new Basisklasse;

print(a.Text); // gibt "Dies ist die Basisklasse" aus
print(b.Text); // gibt "Dies ist die Ableitung" aus
print(b.sageText()); // gibt "Dies ist Text2 der Basisklasse" aus

Eine Klasse initialisieren

Verwendet eine Klasse statische Arrays ist es mitunter notwendig, dass diese vor der ersten Verwendung der Klasse initialisiert werden. Da dies nicht wie bei Eigenschaften durch einfache Zuweisung mit dem Wert geschehen kann, muss ein anderer Weg gefunden werden. JScrpt.NET bietet hierfür die static-Anweisung (nicht zu verwechseln mit dem static-Modifizierer). Innerhalb der Klasse wird zur Initialisierung ein Initialisierungsblock eingefügt. Dieser wird durch das Wort static sowie den Klassennamen der aktuellen Klasse eingeleitet. Ihm folgen geschweifte Klammern. Innerhalb dieser Klammern kann nun Code eingefügt werden, der zur Initialisierung der Klasse dient. Beispiel:

class Klasse
{
 static var a : Array = new Array();
 static Klasse
 {
  var i:int = 0;
  for(i=0; i<10; i++)
  {
   a[i] = 'Feld Nr.:'+i;
  }
 }
 
 var Felder : Array = a;
}

var k : Klasse = new Klasse;
print(k.Felder[3]);

Bitte beachten Sie, dass Initialisierungsblocks nur auf statische Eigenschaften angewandt werden können. Deshalb ist in diesem Beispiel auch eine zweite Eigenschaft Felder definiert, über die auch von außen auf die Inhalte des Arrays zugegriffen werden kann.

Weiterlesen: ⯈ Namespaces, Packages und Interfaces

Über uns

Stefan Wienströer

Wir entwickeln Webanwendungen mit viel Leidenschaft. Unser Wissen geben wir dabei gerne weiter. Mehr über a coding project

Auch interessant