ActionScript 3.0 comporte quatre attributs spéciaux qui contrôlent l’accès aux propriétés définies au sein d’une classe : public, private, protected et internal.

Avec l’attribut public, une propriété est visible de n’importe quel point du script. Par exemple, si vous souhaitez qu’une méthode soit disponible pour du code externe au package, vous devez la déclarer avec l’attribut public. Ceci est valable pour toute propriété, qu’elle soit déclarée à l’aide des mots-clés var, const ou function.

Avec l’attribut private, une propriété n’est visible qu’à partir de la classe où cette propriété est définie. Ce comportement est différent de celui de l’attribut privé en ActionScript 2.0, où une sous-classe pouvait accéder à une propriété déclarée private d’une superclasse. L’accès en cours d’exécution constitue aussi un changement radical de comportement. En ActionScript 2.0, la restriction d’accès introduite par le mot-clé private ne portait que sur la compilation et il était facile de la contourner lors de l’exécution. Cette situation n’existe plus en ActionScript 3.0. Les propriétés désignées comme private sont indisponibles, aussi bien au cours de la compilation que de l’exécution.

Par exemple, le code ci-dessous crée une classe simple appelée PrivateExample pourvue d’une variable privée. Elle tente ensuite d’accéder à cette variable depuis un emplacement hors de la classe.

class PrivateExample 
{ 
    private var privVar:String = "private variable"; 
} 
 
var myExample:PrivateExample = new PrivateExample(); 
trace(myExample.privVar);// compile-time error in strict mode 
trace(myExample["privVar"]); // ActionScript 2.0 allows access, but in ActionScript 3.0, this is a run-time error. 

En ActionScript 3.0, toute tentative d’accéder à une propriété private à l’aide de l’opérateur point (myExample.privVar) déclenche une erreur de compilation en mode strict. Autrement, l’erreur est signalée à l’exécution, tout comme lors de l’utilisation de l’opérateur d’accès à la propriété (myExample["privVar"]).

Le tableau suivant présente les divers résultats d’une tentative d’accès à une propriété déclarée comme privée qui appartient à une classe scellée (non dynamique) :

Dans les classes déclarées avec un attribut dynamic, les tentatives d’accès à une variable privée ne provoquent pas d’erreur d’exécution. La variable n’est simplement pas visible, de sorte que la valeur undefined est renvoyée. Une erreur à la compilation survient néanmoins si vous utilisez l’opérateur point en mode strict. L’exemple suivant est identique au précédent si ce n’est que la classe PrivateExample est déclarée en tant que classe dynamique :

dynamic class PrivateExample 
{ 
    private var privVar:String = "private variable"; 
} 
 
var myExample:PrivateExample = new PrivateExample(); 
trace(myExample.privVar);// compile-time error in strict mode 
trace(myExample["privVar"]); // output: undefined

Les classes dynamiques renvoient le plus souvent la valeur undefined plutôt que de générer une erreur lorsque du code, extérieur à une classe, tente d’accéder à une classe déclarée comme propriété privée. Le tableau suivant montre qu’une erreur est générée uniquement lorsque l’opérateur point est utilisé pour accéder à une propriété privée en mode strict :

Avec l’attribut protected, nouveau en ActionScript 3.0, une propriété n’est visible qu’à partir de sa propre classe ou d’une sous-classe de celle-ci. Autrement dit, une propriété déclarée protected n’est disponible qu’à partir de sa propre classe ou des classes qui lui sont inférieures dans sa hiérarchie d’héritage, que la sous-classe se trouve dans le même package ou dans un autre.

Pour les programmeurs qui connaissent ActionScript 2.0, cette fonctionnalité est semblable à l’attribut private de ce langage. L’attribut protected d’ActionScript 3.0 est également semblable à l’attribut protected de Java, à la différence près que la version de Java autorise également l’accès à partir d’un même package. L’attribut protected est utile pour créer une variable ou une méthode nécessaire aux sous-classes, mais qui ne doit pas être visible à partir du code extérieur à la hiérarchie d’héritage.

Avec l’attribut interne qui apparaît avec ActionScript 3.0, une propriété n’est visible qu’à partir de son propre package. Il s’agit de l’attribut par défaut pour du code dans un package et il s’applique à toute propriété dépourvue de l’un quelconque des attributs suivants :

• public

• private

• protected

• un espace de noms défini par l’utilisateur

L’attribut internal est semblable au contrôle d’accès par défaut de Java quoiqu’en Java il n’existe pas de nom explicite pour ce niveau d’accès ; il ne peut être obtenu que par l’omission de tout autre modificateur d’accès. Avec l’attribut internal, qui apparaît avec ActionScript 3.0, il est possible d’indiquer explicitement votre intention de ne rendre une propriété visible qu’à partir de son propre package.

L’attribut static, qui peut être utilisé avec des propriétés déclarées à l’aide des mots-clés var, const ou function, vous permet d’associer une propriété à la classe elle-même plutôt qu’à ses occurrences. Le code externe à cette classe doit appeler les propriétés statiques à l’aide du nom de la classe et non pas à partir du nom d’une occurrence.

Les sous-classes n’héritent pas des propriétés statiques ; ces dernières font partie de leur chaîne de portée. En d’autres termes, dans le corps d’une sous-classe, une variable ou une méthode statique peut être utilisée sans faire référence à la classe dans laquelle elle a été définie.

Comme solution de rechange aux attributs de contrôle d’accès prédéfinis, vous pouvez créer un espace de noms personnalisé pour l’utiliser comme attribut. Il ne peut exister qu’un seul attribut d’espace de noms par définition et vous ne pouvez pas associer cet attribut à tout attribut de contrôle d’accès (public, private, protected, internal).

Les méthodes constructeur, parfois appelées simplement constructeurs, sont des fonctions qui portent le nom de la classe dans laquelle elles sont définies. Tout code qui figure dans une méthode constructeur est exécuté toutes les fois qu’une occurrence de la classe est créée à l’aide du mot-clé new. Par exemple, le code suivant définit une classe simple appelée Example qui contient une propriété unique appelée status. La valeur initiale de la variable status est fixée dans la fonction constructeur.

class Example 
{ 
    public var status:String; 
    public function Example() 
    { 
        status = "initialized"; 
    } 
} 
 
var myExample:Example = new Example(); 
trace(myExample.status); // output: initialized

Les méthodes constructeur ne peuvent être que publiques, mais l’utilisation de l’attribut public est facultative. Il est impossible d’utiliser l’un des autres spécificateurs de contrôle d’accès, y compris private, protected ou internal avec un constructeur. De même qu’il est impossible d’utiliser non plus, avec un constructeur, un espace de noms défini par l’utilisateur.

Un constructeur peut appeler explicitement le constructeur de sa superclasse directe, à l’aide de l’instruction super(). Si le constructeur de la superclasse n’est pas explicitement appelé, le compilateur insère automatiquement un appel devant la première instruction dans le corps du constructeur. Vous pouvez aussi appeler des méthodes de la superclasse à l’aide du préfixe super en référence à la superclasse. Si vous décidez d’utiliser à la fois super() et super dans le corps du même constructeur, veillez à appeler super() en premier. Sinon, la référence super n’a pas le comportement prévu. Le constructeur super() devrait également être appelé avant toute instruction throw ou return.

L’exemple suivant décrit ce qui se passe si vous tentez d’utiliser la référence super avant d’appeler le constructeur super(). Une nouvelle classe, ExampleEx, étend la classe Example. Le constructeur ExampleEx tente d’accéder à la variable d’état définie dans sa super classe, mais avant un appel à super(). L’instruction trace() du constructeur ExampleEx produit la valeur null car la variable status n’est pas disponible tant que le constructeur super() n’a pas été exécuté.

class ExampleEx extends Example 
{ 
    public function ExampleEx() 
    { 
        trace(super.status); 
        super(); 
    } 
} 
 
var mySample:ExampleEx = new ExampleEx(); // output: null

Bien que l’utilisation de l’instruction return au sein d’un constructeur soit autorisée, il n’est pas permis de renvoyer une valeur. En d’autres termes, aucune expression ou valeur ne peut être associée à l’instruction return. Par conséquent, les méthodes constructeur ne sont pas autorisées à renvoyer des valeurs, ce qui signifie qu’aucun type de valeur renvoyée ne peut être spécifié.

Si vous ne définissez pas de méthode constructeur dans la classe, le compilateur crée automatiquement un constructeur vide. Si la classe en étend une autre, le compilateur insère un appel super() dans le constructeur qu’il génère.

Les méthodes statiques, également appelées parfois méthodes de classe, sont déclarées avec le mot-clé static. Les méthodes statiques sont affectées à une classe plutôt qu’à une occurrence de classe. Elles permettent d’encapsuler des fonctionnalités qui ont une portée plus étendue que l’état d’une occurrence individuelle. Comme les méthodes statiques sont associées à l’intégralité d’une classe, on peut accéder à des méthodes statiques uniquement par une classe et pas du tout par une occurrence de classe.

Les méthodes statiques permettent d’encapsuler des fonctionnalités qui ne se bornent pas à la modification d’état des occurrences de classe. Autrement dit, une méthode devrait être statique si elle offre des fonctionnalités qui n’affectent pas directement la valeur d’une occurrence de classe. Par exemple, la classe Date possède une méthode statique appelée parse() qui reçoit une chaîne et la convertit en nombre. La méthode est statique parce qu’elle n’affecte pas une occurrence individuelle de sa classe. La méthode parse(), reçoit une chaîne représentant une valeur de date, l’analyse et renvoie un nombre dans un format compatible avec la représentation interne d’un objet Date. Cette méthode n’est pas une méthode d’occurrence, puisqu’il n’y aurait aucun intérêt à l’appliquer à une occurrence de la classe Date.

Comparons la méthode statique parse() à l’une des méthodes d’occurrence de la classe Date, comme getMonth(). La méthode getMonth() est une méthode d’occurrence parce qu’elle agit directement sur la valeur d’une occurrence en récupérant un composant spécifique, le mois, d’une occurrence de Date.

Comme les méthodes statiques ne sont pas liées à des occurrences individuelles, vous ne pouvez pas utiliser les mots-clés this ou super dans le corps d’une méthode statique. Les deux références this et super n’ont de sens que dans le contexte d’une méthode d’occurrence.

Contrairement à d’autres langages de programmation basés sur des classes, les méthodes statiques en ActionScript 3.0 ne sont pas héritées.

Les méthodes d’occurrence sont déclarées sans le mot-clé static. Les méthodes d’occurrence, qui sont affectées aux occurrences d’une classe et non pas à la classe elle-même, permettent d’implémenter des fonctionnalités qui affectent des occurrences individuelles d’une classe. Par exemple, la classe Array contient une méthode d’occurrence appelée sort() qui opère directement sur des occurrences Array.

Dans le corps d’une méthode d’occurrence, les variables statiques et d’occurrence sont de même portée ; ce qui signifie que les variables définies dans la même classe peuvent être référencées à l’aide d’un identificateur simple. Par exemple, la classe suivante, CustomArray, étend la classe Array. La classe CustomArray définit une variable statique appelée arrayCountTotal destinée à contenir le nombre total d’occurrences de la classe, une variable d’occurrence appelée arrayNumber qui enregistre l’ordre dans lequel les occurrences ont été créées et une méthode d’occurrence appelée getPosition() qui renvoie les valeurs de ces variables.

public class CustomArray extends Array 
{ 
    public static var arrayCountTotal:int = 0; 
    public var arrayNumber:int; 
 
    public function CustomArray() 
    { 
        arrayNumber = ++arrayCountTotal; 
    } 
     
    public function getArrayPosition():String 
    { 
         return ("Array " + arrayNumber + " of " + arrayCountTotal); 
    } 
}

Pour accéder à la variable statique arrayCountTotal, du code externe à cette classe doit passer par l’objet class utilisant CustomArray.arrayCountTotal ; mais le code qui réside dans le corps de la méthode getPosition() peut faire référence directement à la variable statique arrayCountTotal. C’est également le cas pour les variables statiques dans les superclasses. Bien que les propriétés statiques ne soient pas héritées en ActionScript 3.0, les propriétés statiques des superclasses sont dans la portée. Par exemple, la classe Array possède quelques variables statiques, dont l’une est une constante appelée DESCENDING. Le code qui réside dans une sous-classe d’Array peut accéder à la constante statique DESCENDING à l’aide d’un identifiant simple :

public class CustomArray extends Array 
{ 
    public function testStatic():void 
    { 
        trace(DESCENDING); // output: 2 
    } 
}

La valeur de la référence this dans le corps d’une méthode d’occurrence est une référence à l’occurrence à laquelle la méthode est affectée. Le code suivant montre que la référence this pointe sur l’occurrence qui contient la méthode :

class ThisTest 
{ 
    function thisValue():ThisTest 
    { 
        return this; 
    } 
} 
 
var myTest:ThisTest = new ThisTest(); 
trace(myTest.thisValue() == myTest); // output: true

Il est possible de contrôler l’héritage des méthodes d’occurrence à l’aide des mots-clés override et final. Vous pouvez utiliser l’attribut override pour redéfinir une méthode héritée et l’attribut final pour empêcher les sous-classes de redéfinir une méthode.

Les fonctions d’accesseur de lecture et de définition, appelées aussi accesseurs Get et Set, vous permettent de suivre les principes de programmation sur le masquage et l’encapsulation des informations tout en offrant une interface de programmation conviviale pour les classes que vous créez. Les fonctions de lecture et de définition (get et set) permettent de garder privées les propriétés d’une classe. Par contre, elles permettent à des utilisateurs de votre classe d’accéder à ces propriétés comme s’ils accédaient à une variable de classe au lieu d’appeler une méthode de classe.

L’avantage de cette approche est qu’elle permet d’éviter les fonctions d’accesseur traditionnelles aux noms compliqués, comme getPropertyName() et setPropertyName(). Leur autre avantage est qu’elles évitent d’avoir deux fonctions exposées publiquement pour chaque propriété accessible en lecture et en écriture.

Dans l’exemple suivant, la classe appelée GetSet, possède des fonctions accesseurs de lecture et de définition appelées publicAccess() qui permettent d’accéder à la variable privée appelée privateProperty :

class GetSet 
{ 
    private var privateProperty:String; 
     
    public function get publicAccess():String 
    { 
        return privateProperty; 
    } 
     
    public function set publicAccess(setValue:String):void 
    { 
        privateProperty = setValue; 
    } 
}

Si vous tentez d’accéder directement à la propriété privateProperty, une erreur se produit :

var myGetSet:GetSet = new GetSet(); 
trace(myGetSet.privateProperty); // error occurs

En revanche, si vous utilisez la classe GetSet, vous faites appel à ce qui paraît être une propriété appelée publicAccess, mais qui correspond, en fait, à une paire de fonctions accesseurs de lecture et de définition intervenant sur la propriété privée appelée privateProperty. L’exemple suivant instancie la classe GetSet, puis définit la valeur de la propriété privateProperty à l’aide de l’accesseur public appelé publicAccess :

var myGetSet:GetSet = new GetSet(); 
trace(myGetSet.publicAccess); // output: null 
myGetSet.publicAccess = "hello"; 
trace(myGetSet.publicAccess); // output: hello

Les fonctions d’accesseur Get et Set permettent également de redéfinir des propriétés héritées d’une superclasse, ce qui n’est pas possible avec des variables régulières membres de classes. Les variables des membres de la classe qui sont déclarées à l’aide du mot-clé var ne peuvent pas être redéfinies dans une sous-classe. Toutefois, cette restriction ne concerne pas les propriétés créées à l’aide des fonctions d’accesseur Get et Set. Vous pouvez utiliser l’attribut override sur des fonctions d’accesseur Get et Set héritées d’une superclasse.

Une méthode liée, parfois appelée fermeture de méthode, est tout simplement une méthode extraite de son occurrence. On peut citer comme exemples les méthodes passées en arguments à une fonction ou renvoyées comme valeurs par une fonction. La méthode liée, qui est une nouveauté d’ActionScript 3.0, est semblable à une fermeture de fonction dans la mesure où elle conserve son environnement lexical, même après avoir été extraite de son occurrence. Toutefois, la différence entre une méthode liée et une fermeture de fonction réside dans le fait que la référence this d’une méthode liée reste liée à l’occurrence qui implémente cette méthode. Autrement dit, la référence this d’une méthode liée pointe toujours sur l’objet original qui a implémenté la méthode. Pour les fermetures de fonction, la référence this est générique, ce qui signifie qu’elle pointe sur l’objet auquel est associée la fonction lorsqu’elle est appelée.

Il est important de comprendre les méthodes liées pour utiliser le mot-clé this à bon escient. N’oubliez pas que this représente une référence à l’objet parent d’une méthode. La plupart des programmeurs en ActionScript s’attendent à ce que le mot-clé this représente toujours l’objet ou la classe qui contient la définition d’une méthode. Ce n’est pas toujours le cas sans méthode liée. Par exemple, dans les versions précédentes d’ActionScript, la référence this ne pointait pas toujours sur l’occurrence qui implémentait la méthode. En ActionScript 2.0, lorsque les méthodes sont extraites d’une occurrence, non seulement la référence this n’est pas liée à l’occurrence originale, mais les variables et les méthodes de la classe de cette occurrence ne sont pas disponibles. Toutefois, ce problème n’existe plus avec ActionScript 3.0, car les méthodes liées sont automatiquement créées lorsque la méthode est passée en paramètre. Avec les méthodes liées, le mot-clé this fait toujours référence à l’objet ou à la classe dans laquelle la méthode est définie.

Le code suivant définit une classe appelée ThisTest, qui contient une méthode appelée foo() définissant la méthode liée et une méthode appelée bar() qui renvoie cette méthode liée. Le code extérieur à la classe crée une occurrence de la classe ThisTest, appelle la méthode bar() et enregistre la valeur à renvoyer dans la variable myFunc.

class ThisTest 
{ 
    private var num:Number = 3; 
    function foo():void // bound method defined 
    { 
        trace("foo's this: " + this); 
        trace("num: " + num); 
    } 
    function bar():Function 
    { 
        return foo; // bound method returned 
    } 
} 
 
var myTest:ThisTest = new ThisTest(); 
var myFunc:Function = myTest.bar(); 
trace(this); // output: [object global] 
myFunc(); 
/* output:  
foo's this: [object ThisTest] 
output: num: 3 */

Les deux dernières lignes de code montrent que la référence this dans la méthode liée foo() pointe encore sur une occurrence de la classe ThisTest, bien que la référence this de la ligne précédente pointe sur l’objet global. De plus, la méthode liée, stockée dans la variable myFunc, peut encore accéder aux variables membres de la classe ThisTest. Si ce code est exécuté en ActionScript 2.0, les références this seront identiques et la variable num sera undefined.

Les gestionnaires d’événement constituent un domaine dans lequel l’ajout des méthodes liées est le plus notable, car la méthode addEventListener() nécessite de transmettre une fonction ou une méthode en argument.

Pour incorporer un élément, placez-le d’abord dans la bibliothèque d’un fichier FLA. Utilisez ensuite la propriété de liaison de l’élément pour fournir un nom à la classe de l’élément incorporé. S’il n’existe pas de classe de ce nom dans le chemin de classe indiqué, une classe est automatiquement créée. Vous pouvez alors créer une occurrence de la classe d’éléments incorporés et utiliser les propriétés et méthodes définies ou héritées par cette classe. Par exemple, le code suivant permet de lire un son intégré et lié à une classe d’éléments incorporés appelée PianoMusic :

var piano:PianoMusic = new PianoMusic(); 
var sndChannel:SoundChannel = piano.play();

Pour incorporer des actifs dans un projet Flash Professional, vous pouvez aussi utiliser la balise de métadonnées [Embed] (voir ci-après). Dans ce cas, Flash Professional fait appel au compilateur Flex, et non à son propre compilateur, pour compiler le projet.

Lorsque vous utilisez le compilateur Flex, servez-vous de la balise de métadonnées [Embed] pour incorporer un actif dans le code ActionScript. Placez l’actif dans le dossier source principal ou dans un autre dossier qui se trouve dans le chemin de création. Lorsque le compilateur Flex trouve une balise de métadonnées Embed, il crée la classe d’actifs intégrés pour vous. Il est possible d’accéder à la classe par une variable de type de données Class que l’on déclare immédiatement après la balise de métadonnées [Embed]. Par exemple, le code ci-dessous intègre un son appelé sound1.mp3. Il utilise une variable appelée soundCls pour enregistrer une référence à la classe de l’élément intégré associé à ce son. L’exemple crée alors une occurrence de la classe de l’élément intégré et appelle la méthode play() sur cette occurrence :

package 
{ 
    import flash.display.Sprite; 
    import flash.media.SoundChannel; 
    import mx.core.SoundAsset; 
 
    public class SoundAssetExample extends Sprite 
    { 
        [Embed(source="sound1.mp3")] 
        public var soundCls:Class; 
         
        public function SoundAssetExample() 
        { 
            var mySound:SoundAsset = new soundCls() as SoundAsset; 
            var sndChannel:SoundChannel = mySound.play(); 
        } 
    } 
}