Les méthodes -- Flash CS3

Les méthodes sont des fonctions associées à la définition d'une classe. Lorsqu'une instance de la classe est créée, une méthode est liée à cette instance. Contrairement aux fonctions déclarées hors d'une classe, les méthodes ne peuvent pas être utilisées en dehors de l'instance à laquelle elles sont affectées.

Pour déclarer une méthode, utilisez le mot-clé function. Vous pouvez utiliser une instruction function comme ci-dessous :

public function sampleFunction():String {}

Vous pouvez aussi utiliser une variable à laquelle vous affecterez ensuite une expression de fonction, comme ci-dessous :

public var sampleFunction:Function = function () {}

Dans la plupart des cas, il est préférable d'utiliser une instruction function au lieu d'une expression de fonction pour les raisons suivantes :

Il existe toutefois un cas dans lequel une expression de fonction doit être utilisée : si vous choisissez d'affecter une fonction à l'objet prototype. Pour plus d'informations, consultez la section L'objet prototype.

Sous-rubriques

Les méthodes constructeur

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 figurant dans une méthode constructeur est executé lorsqu'une instance de la classe est créée à l'aide du mot-clé new. Par exemple, le code suivant définit une classe simple nommée Example et contenant une seule propriété, nommé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); // résultat : initialisation

Les méthodes constructeur sont obligatoirement publiques, mais l'attribut public est facultatif. Il est impossible d'utiliser l'un des autres spécificateurs de contrôle d'accès (private, protected ou internal) avec un constructeur. De même, il est impossible d'utiliser avec un constructeur un espace de nom défini par l'utilisateur.

Un constructeur peut appeler explicitement le constructeur de sa super-classe directe, à l'aide de l'instruction super(). Si le constructeur de la super-classe n'est pas explicitement appelé, le compilateur insère automatiquement un appel avant la première instruction dans le corps du constructeur. Vous pouvez aussi appeler des méthodes de la super-classe à l'aide du préfixe super en référence à la super-classe. Si vous choisissez d'utiliser à la fois super() et super dans le corps du même constructeur, veillez à appeler d'abord super(). Sinon, la référence super ne fonctionnera pas comme prévu. Le constructeur super() doit également être appelé avant toute instruction throw ou return.

L'exemple suivant montre ce qui se produit si vous tentez d'utiliser la référence super avant d'avoir appelé 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(); // résultat : null

Bien qu'il soit permis d'utiliser l'instruction return dans un constructeur, il n'est pas possible de lui faire renvoyer une valeur. Autrement dit, aucune expression ou valeur ne peut être associée à l'instruction return. En conséquence, les constructeurs ne peuvent pas renvoyer de 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 votre classe, le compilateur crée automatiquement un constructeur vide. Si votre classe étend une autre classe, le compilateur insère un appel super() dans le constructeur qu'il génère.

Les méthodes statiques

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 instance de classe. Elles permettent d'encapsuler des fonctionnalités qui ont une portée plus étendue que l'état d'une instance individuelle. Comme les méthodes statiques sont affectées à une classe en tant que telle, elles ne sont accessibles que via une classe, et non pas par une instance de la classe.

Les méthodes statiques permettent d'encapsuler des fonctionnalités qui ne sont pas limitées à la modification d'état des instances de classe. Ainsi, une méthode doit être statique si elle offre des fonctionnalités qui n'affectent pas directement la valeur d'une instance de classe. Par exemple, la classe Date possède une méthode statique nommée parse(), qui reçoit une chaîne et la convertit en nombre. Cette méthode est statique parce qu'elle n'affecte pas une instance 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'instance, puisqu'il n'y aurait aucun intérêt à l'appliquer à une instance de la classe Date.

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

Dans la mesure où les méthodes statiques ne sont pas liées à des instances individuelles, il n'est pas possible d'utiliser les mots-clés this ou super dans le corps d'une méthode statique. Les références this et super n'ont de signification que dans le contexte d'une méthode d'instance.

À l'inverse d'autres langages de programmation basés sur des classes, en ActionScript 3.0 les méthodes statiques ne sont pas héritées. Pour plus d'informations, consultez la section Propriétés statiques non héritées.

Les méthodes d'instance

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

Dans le corps d'une méthode d'instance, les variables statiques et d'instance 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 nommée arrayCountTotal et destinée à contenir le nombre total d'instances de la classe, une variable d'instance nommée arrayNumber qui enregistre l'ordre dans lequel les instances ont été créées, et une méthode d'instance nommé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 faire référence à la variable statique arrayCountTotal, du code externe à cette classe doit passer par l'objet class (CustomArray.arrayCountTotal), mais le code qui réside dans le corps de la méthode getPosition() peut directement faire référence à la variable statique arrayCountTotal. C'est également le cas pour les variables statiques des super-classes. Bien que les propriétés statiques ne soient pas héritées en ActionScript 3.0, les propriétés statiques des super-classes sont dans la portée. Par exemple, la classe Array possède quelques variables statiques, dont l'une est une constante nommée DESCENDING. Le code qui réside dans une sous-classe d'Array peut faire référence à la constante statique DESCENDING à l'aide d'un identificateur simple :

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

Dans le corps d'une méthode d'instance, la valeur de la référence this est une référence à l'instance à laquelle la méthode est affectée. Le code suivant montre que la référence this pointe sur l'instance qui contient la méthode :

class ThisTest
{
    function thisValue():ThisTest
    {
        return this;
    }
}

var myTest:ThisTest = new ThisTest();
trace(myTest.thisValue() == myTest); // résultat : true

Il est possible de contrôler l'héritage des méthodes d'instance à 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. Pour plus d'informations, consultez la section Redéfinition des méthodes.

Les méthodes accesseurs de lecture et de définition

Les méthodes accesseurs de lecture et de définition, également appelées getters et setters, permettent d'adhérer aux principes de programmation du masquage et de l'encapsulation d'informations tout en offrant une interface de programmation d'emploi facile pour vos classes. Les fonctions de lecture et de définition (get et set) permettent de garder privées les propriétés d'une classe, tout en permettant à l'utilisateur de cette 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 traditionnelles fonctions accesseurs aux noms peu maniables, telles que 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 nommée GetSet possède des fonctions accesseurs de lecture et de définition nommées publicAccess() qui permettent d'accéder à la variable privé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 à la propriété privateProperty directement, une erreur se produira :

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

Par contre, si vous utilisez la classe GetSet, vous ferez appel à quelque chose qui semble être une propriété nommée publicAccess, mais il s'agira en réalité d'une paire de fonctions accesseurs de lecture et de définition opérant sur la propriété privée nommé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 nommée publicAccess:

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

Les fonctions de lecture et de définition permettent également de forcer des propriétés héritées d'une super-classe, ce qui n'est pas possible avec des variables régulières membres de classes. Les variables membres de classes qui sont déclarées avec le mot-clé var ne peuvent pas être forcées dans une sous-classe. Toutefois, cette restriction ne concerne pas les propriétés créées à l'aide des fonctions de lecture et de définition. Vous pouvez utiliser l'attribut override sur des fonctions de lecture et de définition héritées d'une super-classe.

Les méthodes liées

Une méthode liée, parfois appelée fermeture de méthode, est tout simplement une méthode extraite de son instance. On peut citer comme exemple 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 instance. 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'instance 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 réfère 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'instance qui implémentait la méthode. En ActionScript 2.0, lorsque les méthodes sont extraites d'une instance, non seulement la référence this n'est pas liée à l'instance originale, mais les variables et les méthodes de la classe de cette instance 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 référence toujours l'objet ou la classe dans laquelle la méthode est définie.

Le code suivant définit une classe nommée ThisTest, qui contient une méthode nommée foo() définissant la méthode liée, et une méthode nommée bar() qui renvoie cette méthode liée. Le code extérieur à la classe crée une instance 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 définition de la méthode liée
    {
        trace("foo's this: " + this);
        trace("num: " + num);
    }
    function bar():Function
    {
        return foo; //renvoi de la méthode liée
    }
}

var myTest:ThisTest = new ThisTest();
var myFunc:Function = myTest.bar();
trace(this); // résultat : [object global]
myFunc();    
/* Sortie : 
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 instance 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 sont un domaine dans lequel l'ajout des méthodes liées est le plus notable, car la méthode addEventListener() nécessite de passer une fonction ou une méthode en argument. Pour plus d'informations, consultez la section Fonction d'écouteur définie comme méthode de classe.