class //className// extends //otherClassName// {}
interface //interfaceName// extends //otherInterfaceName// {}

Définit une classe qui est une sous-classe d’une autre classe, cette dernière formant la superclasse. La sous-classe hérite de toutes les méthodes, propriétés, fonctions, etc. qui sont définies dans la superclasse.

Les interfaces peuvent également être développées avec le mot clé extends. Une interface qui développe une autre interface reprend toutes les déclarations de méthode de l’interface d’origine.

Disponibilité : Flash Player 6 ; ActionScript 2,0

className:String - Nom de la classe en cours de définition.

Dans l’exemple suivant, la classe Car étend la classe Vehicle de manière à ce que toutes ses méthodes, propriétés et fonctions soient héritées. Si votre script instancie un objet Car, les méthodes de la classe Car et de la classe Vehicle peuvent être utilisées.

L’exemple suivant affiche le contenu d’un fichier intitulé Vehicle.as, qui définit la classe Vehicle :

class Vehicle { 
 var numDoors:Number; 
 var color:String; 
 function Vehicle(param_numDoors:Number, param_color:String) { 
 this.numDoors = param_numDoors; 
 this.color = param_color; 
 } 
 function start():Void { 
 trace("[Vehicle] start"); 
 } 
 function stop():Void { 
 trace("[Vehicle] stop"); 
 } 
 function reverse():Void { 
 trace("[Vehicle] reverse"); 
 } 
}

L’exemple suivant affiche un deuxième fichier AS, intitulé Car.as, dans le même répertoire. Cette classe étend la classe Vehicle, la modifiant de trois façons. D’abord, la classe Car ajoute une variable fullSizeSpare afin de déterminer si, oui ou non, l’objet car est doté d’un pneu de secours de taille normale. Ensuite, elle ajoute une nouvelle méthode spécifique aux voitures, activateCarAlarm(), permettant d’activer l’alarme antivol de la voiture. Enfin, elle remplace la fonction stop() pour spécifier que la classe Car utilise un système de frein antiblocage pour s’arrêter.

class Car extends Vehicle { 
 var fullSizeSpare:Boolean; 
 function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) { 
 this.numDoors = param_numDoors; 
 this.color = param_color; 
 this.fullSizeSpare = param_fullSizeSpare; 
 } 
 function activateCarAlarm():Void { 
 trace("[Car] activateCarAlarm"); 
 } 
 function stop():Void { 
 trace("[Car] stop with anti-lock brakes"); 
 } 
}

L’exemple suivant instancie un objet Car, appelle une méthode définie dans la classe Vehicle (start()), puis celle remplacée par la classe Car (stop()) ; il appelle enfin une méthode de la classe Car (activateCarAlarm()) :

var myNewCar:Car = new Car(2, "Red", true); 
myNewCar.start(); // output: [Vehicle] start 
myNewCar.stop(); // output: [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // output: [Car] activateCarAlarm

Une sous-classe de la classe Vehicle peut également être écrite à l’aide du mot-clé super que la sous-classe peut utiliser pour accéder aux propriétés et méthodes de la superclasse. L’exemple suivant affiche un troisième fichier AS, intitulé Truck.as, une fois encore dans le même répertoire. La classe Truck utilise le mot-clé super dans le constructeur et, de nouveau, dans la fonction reverse() remplacée.

class Truck extends Vehicle {
 var numWheels:Number;
 function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) { 
 super(param_numDoors, param_color); 
 this.numWheels = param_numWheels; 
 } 
 function reverse():Void { 
 beep(); 
 super.reverse(); 
 } 
 function beep():Void { 
 trace("[Truck] make beeping sound"); 
 } 
}

L’exemple suivant instancie un objet Truck, appelle une méthode remplacée par la classe Truck (reverse()), puis une méthode définie dans la classe Vehicle (stop()) :

var myTruck:Truck = new Truck(2, "White", 18); 
myTruck.reverse(); // output: [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // output: [Vehicle] stop

Instruction class