Attributs de propriété de classe -- Flash CS3

Dans le cadre du modèle d'objet ActionScript, le terme propriété représente tout ce qui peut être membre d'une classe : variables, constantes et méthodes. Ce terme n'est pas utilisé dans le même sens dans le manuel Référence du langage et des composants ActionScript 3.0, où il est utilisé avec un sens plus étroit et ne désigne alors que les membres d'une classe qui soit sont des variables, soit sont définis par une méthode de lecture/définition. En ActionScript 3.0, un jeu d'attributs peut être utilisé avec n'importe quelle propriété d'une classe. Le tableau suivant présente ce jeu d'attributs.

Attribut	Définition
`internal` (par défaut)	Visible pour les références à partir du paquet actuel.
`private`	Visible pour les références à partir de la même classe.
`protected`	Visible pour les références à partir de la même classe et des classes dérivées.
`public`	Visible pour les références à partir de n'importe quel point du code.
`static`	Spécifie qu'une propriété appartient à la classe, et non pas aux instances de celle-ci.
`UserDefinedNamespace`	Nom d'espace de nom défini par l'utilisateur.

Sous-rubriques

Attributs d'espace de nom pour le contrôle d'accès

ActionScript 3.0 comporte quatre attributs spéciaux qui contrôlent l'accès aux propriétés définies dans 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 paquet, vous devez la déclarer avec l'attribut public. Ceci est vrai pour toutes les propriétés, qu'elles soient déclarées à 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 private en ActionScript 2.0, où une sous-classe pouvait accéder à une propriété déclarée private d'une super-classe. Le comportement lors de l'exécution présente un autre changement important. 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. Ce n'est plus le cas en ActionScript 3.0. Les propriétés marquées comme private sont indisponibles aussi bien à l'exécution qu'à la compilation.

Par exemple, le code ci-dessous crée une classe simple nommée PrivateExample avec une variable ayant l'attribut private, puis tente d'accéder à cette variable à partir de l'extérieur de cette classe. En ActionScript 2.0, l'accès à cette variable était interdit lors de la compilation, mais il était facile de contourner cette restriction à l'aide de l'opérateur d'accès aux propriétés ([]), qui recherche celles-ci lors de l'exécution, et non pas lors de la compilation.

class PrivateExample
{
    private var privVar:String = "private variable";
}

var myExample:PrivateExample = new PrivateExample();
trace(myExample.privVar);    // erreur de compilation en mode strict
trace(myExample["privVar"]); // ActionScript 2.0 autorise l'accès, mais ActionScript 3.0 déclenche une erreur d'exécution.

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. Sinon, l'erreur est signalée lors de l'exécution, tout comme lors de l'utilisation de l'opérateur d'accès aux propriétés (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, appartenant à une classe scellée (non dynamique) :

	Mode strict	Mode standard
opérateur point (`.`)	erreur de compilation	erreur d'exécution
opérateur crochets (`[]`)	erreur d'exécution	erreur d'exécution

Dans les classes déclarées avec l'attribut dynamic, une tentative d'accéder à une variable private ne provoquera pas d'erreur d'exécution. Cette variable ne sera simplement pas visible, si bien que Flash Player renverra la valeur undefined. Une erreur de compilation se produit toutefois si vous utilisez l'opérateur point en mode strict. L'exemple suivant est identique à l'exemple précédent, si ce n'est que cette fois la classe PrivateExample est déclarée comme classe dynamique :

dynamic class PrivateExample
{
    private var privVar:String = "private variable";
}

var myExample:PrivateExample = new PrivateExample();
trace(myExample.privVar);    // erreur de compilation en mode strict
trace(myExample["privVar"]); // résultat : undefined

En général, lorsque du code extérieur à une classe tente d'accéder à une propriété déclarée comme private, les classes dynamiques renvoient la valeur undefined au lieu de générer une erreur. Le tableau suivant montre qu'une erreur n'est générée que lorsque l'opérateur point est utilisé pour accéder à une propriété privée en mode strict :

	Mode strict	Mode standard
opérateur point (`.`)	erreur de compilation	`undefined`
opérateur crochets (`[]`)	`undefined`	`undefined`

Avec l'attribut protected, qui apparaît avec 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 paquet ou dans un autre.

Pour les programmeurs familiers d'ActionScript 2.0, cette fonctionnalité est similaire à l'attribut private en ActionScript 2.0. En ActionScript 3.0, l'attribut protected est également similaire à l'attribut protected en Java, à la différence près que la version Java autorise également l'accès à partir du même paquet. 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 internal, qui apparaît avec ActionScript 3.0, une propriété n'est visible qu'à partir de son propre paquet. C'est l'attribut par défaut du code contenu par un paquet, et il s'applique à toute propriété n'ayant pas l'un des attributs suivants :

L'attribut internal est similaire au contrôle d'accès par défaut en Java, bien que dans ce dernier langage ce niveau d'accès ne porte pas de nom explicite et ne puisse être obtenu qu'en omettant de déclarer un autre modificateur d'accès. Avec l'attribut internal, qui apparaît avec ActionScript 3.0, il est possible de signifier explicitement votre intention de ne rendre une propriété visible qu'à partir de son propre paquet.

Attribut static

L'attribut static, qui peut être utilisé avec les propriétés déclarées à l'aide des mots-clés var, const ou function, il est possible d'affecter une propriété à la classe elle-même, plutôt qu'à ses instances. 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 instance.

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 méthode ou une variable statique ne peuvent pas être utilisées sans référencer la classer dans laquelle elles ont été définies. Pour plus d'informations, consultez la section Propriétés statiques non héritées.

Attributs d'espace de nom définis par l'utilisateur

À la place des attributs de contrôle d'accès prédéfinis, vous pouvez créer un espace de nom personnalisé pour l'utiliser comme attribut. Un seul attribut d'espace de nom peut être utilisé par définition, et il est impossible d'utiliser un attribut d'espace de nom en combinaison avec l'un des attributs de contrôle d'accès (public, private, protected, internal). Pour plus d'informations sur l'utilisation des espaces de nom, consultez la section Espaces de noms.