Eine Instanzeigenschaft wird von allen Unterklassen geerbt, unabhängig davon, ob sie mit dem Schlüsselwort function, var oder const definiert wurde, solange die Eigenschaft in der Basisklasse nicht mit dem Attribut private deklariert wurde. Beispielsweise hat die Event-Klasse in ActionScript 3.0 eine Reihe von Unterklassen, die Eigenschaften erben, die alle Ereignisobjekte gemeinsam haben.

Für einige Ereignistypen enthält die Event-Klasse alle Eigenschaften, die zur Definition des Ereignisses erforderlich sind. Diese Ereignistypen benötigen keine Instanzeigenschaften über die Eigenschaften hinaus, die in der Event-Klasse definiert sind. Beispiele dieser Ereignisse sind complete, das nach dem erfolgreichen Laden von Daten eintritt, und connect, das nach dem erfolgreichen Herstellen einer Netzwerkverbindung eintritt.

Das folgende Beispiel ist ein Auszug der Event-Klasse, in dem einige der Eigenschaften und Methoden gezeigt werden, die von Unterklassen geerbt werden. Da diese Eigenschaften geerbt sind, kann jede Instanz einer Unterklasse darauf zugreifen.

public class Event 
{ 
    public function get type():String; 
    public function get bubbles():Boolean; 
    ... 
 
    public function stopPropagation():void {} 
    public function stopImmediatePropagation():void {} 
    public function preventDefault():void {} 
    public function isDefaultPrevented():Boolean {} 
    ... 
}

Andere Ereignistypen erfordern eindeutige Ereignisse, die in der Event-Klasse nicht zur Verfügung stehen. Diese Ereignisse werden mit Unterklassen der Event-Klasse definiert, sodass den bereits in der Event-Klasse definierten Eigenschaften neue hinzugefügt werden können. Ein Beispiel einer solchen Unterklasse ist die MouseEvent-Klasse, die Ereignisse hinzufügt, die nur für Mausbewegungen oder Mausklicks gelten, z. B. die Ereignisse mouseMove und click. Das folgende Beispiel ist ein Auszug der MouseEvent-Klasse, in dem die Definition der Eigenschaften dargestellt ist, die in der Unterklasse, jedoch nicht in der Basisklasse vorhanden sind:

public class MouseEvent extends Event 
{ 
    public static const CLICK:String= "click"; 
    public static const MOUSE_MOVE:String = "mouseMove"; 
    ... 
 
    public function get stageX():Number {} 
    public function get stageY():Number {} 
    ... 
}

// Base.as in a folder named foo 
package foo 
{ 
    public class Base 
    { 
        public var str:String = "hello"; // change public on this line 
    } 
} 
 
// Extender.as in a folder named bar 
package bar 
{ 
    import foo.Base; 
    public class Extender extends Base 
    { 
        public function getString():String { 
            return str; 
        } 
    } 
} 
 
// main application class in file named AccessControl.as 
package 
{ 
    import flash.display.MovieClip; 
    import bar.Extender; 
    public class AccessControl extends MovieClip 
    { 
        public function AccessControl() 
        { 
            var myExt:Extender = new Extender(); 
            trace(myExt.str);// error if str is not public 
            trace(myExt.getString()); // error if str is private or internal 
        } 
    } 
}

trace(myExt.str);// error if str is not public

Überschreiben einer Methode bedeutet, das Verhalten einer geerbten Methode neu zu definieren. Statische Methoden werden nicht geerbt und können nicht überschrieben werden. Andererseits werden die Instanzmethoden von Unterklassen geerbt und können überschrieben werden, solange die beiden folgenden Kriterien erfüllt sind:

• Die Instanzmethode wurde in der Basisklasse nicht mit dem Schlüsselwort final deklariert. Wurde das Schlüsselwort final mit einer Instanzmethode verwendet, möchte der Programmierer verhindern, dass die Methode von Unterklassen überschrieben wird.

• Die Instanzmethode wurde in der Basisklasse nicht mit dem Zugriffskontrollbezeichner private deklariert. Wurde eine Methode in der Basisklasse als private deklariert, muss bei der Definition einer Methode gleichen Namens in der Unterklasse das override-Schlüsselwort nicht verwendet werden, da die Basisklassenmethode für die Unterklasse nicht sichtbar ist.

  Um eine Instanzmethode zu überschreiben, die diese Kriterien erfüllt, muss die Methodendefinition in der Unterklasse das Schlüsselwort override verwenden und der Methode in der übergeordneten Klasse hinsichtlich Folgendem entsprechen:

• Die überschreibende Methode muss über die gleiche Zugriffskontrollebene wie die Basisklassenmethode verfügen. Als „internal“ deklarierte Methoden haben die gleiche Zugriffskontrollebene wie Methoden, die über keinen Zugriffskontrollbezeichner verfügen.

• Die überschreibende Methode muss über die gleiche Anzahl an Parametern wie die Basisklassenmethode verfügen.

• Die Parameter der überschreibenden Methode müssen die gleichen Datentypanmerkungen wie die Parameter der Basisklassenmethode aufweisen.

• Die überschreibende Methode muss über den gleichen Rückgabetyp wie die Basisklassenmethode verfügen.

Die Namen der Parameter in der überschreibenden Methode müssen jedoch nicht mit den Namen der Parameter in der Basisklasse übereinstimmen, solange die Anzahl der Parameter und der Datentyp jedes Parameters übereinstimmen.

package { 
    import flash.display.MovieClip; 
    public class SuperExample extends MovieClip 
    { 
        public function SuperExample() 
        { 
            var myExt:Extender = new Extender() 
            trace(myExt.thanks()); // output: Mahalo nui loa 
        } 
    } 
} 
 
class Base { 
    public function thanks():String 
    { 
        return "Mahalo"; 
    } 
} 
 
class Extender extends Base 
{ 
    override public function thanks():String 
    { 
        return super.thanks() + " nui loa"; 
    } 
}

package 
{ 
    import flash.display.MovieClip; 
    public class OverrideExample extends MovieClip 
    { 
        public function OverrideExample() 
        { 
            trace(currentLabel) 
        } 
        override public function get currentLabel():String 
        { 
            var str:String = "Override: "; 
            str += super.currentLabel; 
            return str; 
        } 
    } 
}

Statische Eigenschaften werden von Unterklassen nicht geerbt. Dies bedeutet, dass über die Instanz einer Unterklasse nicht auf statische Eigenschaften zugegriffen werden kann. Der Zugriff auf eine statische Eigenschaft ist nur über das Klassenobjekt möglich, in dem sie definiert wurde. Im folgenden Beispielcode werden eine Basisklasse namens „Base“ sowie eine Unterklasse mit der Bezeichnung „Extender“ definiert, welche die Base-Klasse erweitert. In der Base-Klasse ist eine statische Variable namens test definiert. Der Code im folgenden Auszug kann nicht im strikten Modus kompiliert werden und erzeugt im Standardmodus einen Laufzeitfehler.

package { 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
            trace(myExt.test);// error 
        } 
    } 
} 
 
class Base { 
    public static var test:String = "static"; 
} 
 
class Extender extends Base { }

Die einzige Möglichkeit, auf die statische Variable test zuzugreifen, ist über das Klassenobjekt. Dies wird im folgenden Code gezeigt:

Base.test;

Es ist jedoch auch zulässig, eine Instanzeigenschaft mit dem gleichen Namen wie eine statische Eigenschaft zu definieren. Eine solche Instanzeigenschaft kann in der gleichen Klasse wie die statische Eigenschaft oder in einer Unterklasse definiert werden. So kann die Base-Klasse aus dem vorangegangenen Beispiel eine Instanzeigenschaft namens test aufweisen. Der folgende Beispielcode wird kompiliert und ausgeführt, da die Instanzeigenschaft von der Extender-Klasse geerbt wird. Der Code ließe sich auch dann kompilieren und ausführen, wenn die Definition der Instanzvariablen „test“ in die Extender-Klasse verschoben wird, jedoch nicht, wenn sie dorthin kopiert wird.

package 
{ 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
            trace(myExt.test);// output: instance 
        } 
    } 
} 
 
class Base 
{ 
    public static var test:String = "static"; 
    public var test:String = "instance"; 
} 
 
class Extender extends Base {}

Obwohl statische Eigenschaften nicht geerbt werden, befinden sie sich in der Gültigkeitsbereichskette der Klasse, in der sie definiert wurden, sowie in allen Unterklassen dieser Klasse. Anders ausgedrückt, statische Eigenschaften befinden sich im Gültigkeitsbereich der Klasse, in der sie definiert wurden, sowie in allen Unterklassen. Dies bedeutet, dass auf eine statische Eigenschaft direkt aus dem Klassenrumpf zugegriffen werden kann, in dem sie definiert wird, sowie aus allen Unterklassen dieser Klasse.

Im folgenden Beispielcode werden die im vorangegangenen Beispiel definierten Klassen modifiziert, um zu zeigen, dass sich die in der Base-Klasse definierte statische Variable test auch im Gültigkeitsbereich der Extender-Klasse befindet. Anders ausgedrückt, die Extender-Klasse kann auf die Variable test zugreifen, ohne ihr den Namen der Klasse voranzustellen, in der test definiert ist.

package 
{ 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
        } 
    } 
} 
 
class Base { 
    public static var test:String = "static"; 
} 
 
class Extender extends Base 
{ 
    public function Extender() 
    { 
        trace(test); // output: static 
    } 
     
}

Wenn eine Instanzeigenschaft mit dem gleichen Namen wie eine statische Eigenschaft in der gleichen oder einer übergeordneten Klasse definiert ist, so hat die Instanzeigenschaft eine höhere Rangstufe in der Gültigkeitsbereichskette. Man kann sagen, die Instanzeigenschaft verbirgt die statische Eigenschaft, daher wird der Wert der Instanzeigenschaft anstelle des Werts der statischen Eigenschaft verwendet. Im folgenden Code ist dargestellt, dass bei einer in der Extender-Klasse definierten Instanzvariablen namens test die trace()-Anweisung anstelle des Wertes der statischen Variablen den Wert der Instanzvariablen verwendet:

package 
{ 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
        } 
    } 
} 
 
class Base 
{ 
    public static var test:String = "static"; 
} 
 
class Extender extends Base 
{ 
    public var test:String = "instance"; 
    public function Extender() 
    { 
        trace(test); // output: instance 
    } 
     
}