Les méthodes de 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'aura 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 votre classe, le compilateur créera 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, é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. Pour plus d'informations, consultez la section Propriétés statiques non 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 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 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 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); // 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. Pour plus d'informations, consultez la section Redéfinition des méthodes.

Les fonctions d'accesseur de lecture et de définition, appelées aussi getters et setters, 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 produira :

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

Par contre, si vous utilisez la classe GetSet, vous ferez appel à quelque chose qui paraît être une propriété appelée publicAccess ; mais il s'agit là d'une paire de fonctions accesseurs de lecture et de définition qui opèrent 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 getter et setter 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 getter et setter. Vous pouvez utiliser l'attribut override sur des fonctions getter et setter 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 fasse toujours référence à 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 plus d'informations, consultez la section Fonction d'écouteur définie comme méthode de classe dans Les écouteurs d'événement.