Les méthodes sont des fonctions qui déterminent le comportement d'une classe. Les méthodes implémentent les tâches des instances d'une classe ou de la classe elle-même.
Pour définir une méthode pour une classe, on utilise le mot function dans une définition de classe:
class nomClasse {
function nomMethode (param1:type, param2:type, ...):typeRetour {
// instructions
}
}
Dans la définition de la méthode, on réfère aux paramètres directement par leur nom:
function carre (x:Number):Number {
return x * x;
}
Les méthodes, tout comme les propriétés, nous offrent la possibilité d'une vérification du typage afin de s'assurer de la validité des données. Dans les méthodes, il est important de spécifier le type de données des paramètres et également du type de renvoi, s'il y a lieu. Si une méthode retourne une valeur à l'aide du mot-clé return, le type de renvoi doit être spécifié. Sinon, on utilisera le type de renvoi Void pour spécifier explicitement qu'aucun renvoi n'est attendu.
Dans une définition de méthode, on veut parfois référer à l'objet duquel la méthode a été invoquée, l'objet courant. Le mot-clé this est utile dans ce cas.
Le mot-clé this est souvent utilisé pour passer l'objet courant à une méthode d'un autre objet, comme ceci:
function uneMethode ():Void {
// Passe this comme un paramètre à un autre objet
unAutreObjet.uneAutreMethode(this);
}
Dans certains cas, une propriété d'instance ou de classe a le même nom que le paramètre d'une méthode. Pour éviter la confusion, on utilisera le mot-clé this encore une fois:
class Boite {
// Propriete d'instance
private var hauteur:Number;
function setHauteur (hauteur:Number):Void {
// Assigne à la propriété (this.hauteur) la valeur
// du paramètre (hauteur)
this.hauteur = hauteur;
}
}
Il est possible, et recommandé, de ne pas utiliser la même appellation pour une propriété et un paramètre. On aurait pu écrire le code comme ceci:
class Boite {
// Propriete d'instance
private var hauteur:Number;
function setHauteur (h:Number):Void {
hauteur = h;
}
}
Comme les propriétés, les attributs public, private et static peuvent être appliqués aux méthodes. Ces attributs déterminent les conditions d'accès aux méthodes.
Une bonne pratique de programmation orientée objet consiste à déclarer les propriétés de classe comme private. Elles ne peuvent alors ni être lues ni être modifiées par un code en dehors de la classe. Cependant, les objets fournissent généralement un moyen accessible pour obtenir et régler les propriétés d'un objet. On définit pour ce faire des méthodes d'obtention ou de réglage (getter et setter).
Une méthode d'obtention ressemble à ceci:
public function getNomPropriete ():typeRetour {
return nomPropriete;
}
Par convention, le nom de la méthode est getNomPropriete, ce qui indique bien qu'on pourra accéder à la propriété spécifiée.
Une méthode de réglage ressemble à ceci:
public function setNomPropriete (param:type):Void {
nomPropriete = param;
}
Quand cette méthode sera invoquée, la propriété prendra la valeur assignée au paramètre.
On a parfois besoin d'une variable temporairement, à l'intérieur d'une méthode. Cette variable sera utilisée à l'intérieur de la méthode et effacée immédiatement après. Pour définir une telle variable locale, il suffit d'utiliser le mot-clé var à l'intérieur d'une définition de méthode, ce qui créera une variable locale, et non une propriété.
function nomMethode ():typeRetour {
var variableLocale:type = valeur;
}
Les variables locales sont utilisées pour la clarité du code et pour améliorer les performances.