Apache Adobe Flex TutorialTutoriaux Adobe Flex & AIR en Français

21sept/082

Flex ActionScript – Méthodes en ActionScript 3

Une méthode est un moyen de regrouper des instructions, de donner à ce groupe un nom et de reporter l'exécution des ces instructions jusqu'à ce que la méthode soit appelée par son nom. Toutes les définitions de méthodes doivent être placées dans le corps de la classe, et elles utilisent le mot-clé function suivi par le nom de la méthode. Après le nom de la méthode, on trouve des parenthèses ouvrantes/fermantes avec à l'intérieur, les paramètres que la fonction peut accepter. Suivi par (:) et le type retournée par la méthode. Si une fonction ne retourne pas de valeur, le type de retour est void. Après cela, vient la déclaration de la fonction dans des crochets. Voici la déclaration pour une fonction appelée test():

Actionscript:
  1. function test():void{
  2.     // code
  3. }

 La fonction test est déclarée de telle façon qu'elle n'accepte pas de paramètres et qu'elle ne revoie pas de valeur. Avec ce code, la fonction test ne fait rien. On va donc ajouter quelques instructions dans la fonction pour qu'elle fasse quelque chose:

Actionscript:
  1. function test():void{
  2.     var message:String = "fonction message";
  3.     trace (message);
  4. }

Maintenant, la méthode test() déclare une variable appellée message, lui assigne une valeur (fonction message) et fait ensuite un trace() pour envoyer la valeur vers la sortie (la console, ici).Pour appeler une méthode, utiliser le nom de la méthode, suivi par les parenthèses. Par exemple, tu vous voulez appeler la méthode test(), vous utiliserez l'instruction suivante:

test();

Si vous voulez déclarer une méthode pour qu'elle puisse accepter des paramètres, vous devez déclarer ces paramètres dans les parenthèses sous forme de liste délimitée par des virgules. La déclaration de paramètres consiste à indiquer le nom du paramètre suivi de (:) et du type attendu. L'exemple suivant réécrit test() pour qu'elle accepte deux paramètres (a et b):

Actionscript:
  1. function test(a:String, b:String):void{
  2.     trace ("Votre message est " + a + " et " + b);
  3. }

Lorsque vous voulez appeler une méthode avec des paramètres, passez simplement les valeurs dans l'appel de la fonction comme ceci:

Actionscript:
  1. test("un", "deux");

ActionScript n'accepte pas l'overloading. Cela signifie que vous ne pouvez pas avoir deux méthodes avec le même nom et des listes de paramètres différents. Cependant, ActionScript accepte les paramètres "rest". Ces paramètres vous permettent de passer 0 (ou plus) paramètres additionnels de type inconnu à une fonction. Vous devez déclarer les paramètres "rest" en utilisant le nom du paramètre précédé par trois petits points (...). A l'intérieur de la méthode, vous pourrez accéder aux valeurs des paramètres "rest" en tant que tableau (Array).La fonction test() de l'exemple requiert maintenant exactement 2 paramètres (a et b). Vous ne pouvez pas passer moins ou plus de deux paramètres. Si vous voulez passer juste un paramètre (ou 5 paramètres), vous avez besoin des paramètres "rest". Le code suivant réécrit test() pour qu'il requiert au moins 1 paramètre, et il autorise 0 ou plus paramètres additionnels. Par convention, le paramètre rest est appelé "rest":

function test(a:String, ...rest):void{
	var message:String = "Votre message est";
	for (var i:uint = 0;i<rest.length;i++){
		message += " " + rest[i];
	}
	trace (message);
}

Si vous voulez qu'une méthode retourne une valeur, vous avez besoin de faire deux choses: spécifier le type de retour correct et ajouter une instruction return. Quand vous spécifiez un type de retour, vous aurez la vérification (type-checking) à la compilation et l'exécution. Une fonction qui a comme type de retour String doit retourner uen chaîne de caractères, et pas un nombre, une date, un tableau ou tout autre type. Une instruction return quitte immédiatement la fonction et renvoie la valeur spécifiée.Voici la version de test() qui renvoie une String:

function test(a:String, ...rest):String{
	var message:String = "Votre message est";
	for (var i:uint = 0;i<rest.length;i++){
		message += " " + rest[i];
	}
	return message;
}

Les méthodes utilisent les mêmes modifiers que les propriétés public, private, protected, internal et static. Si vous oubliez le modifier comme dans les exemples précédents, Flex va assumer que la méthode est internal. L'exemple suivant déclare deux méthodes, une public et une public et static:

Actionscript:
  1. package com.exemple{
  2.     import flash.net.URLLoader;
  3.     import flash.net.URLRequest;
  4.     public class Exemple {
  5.         private var _loader:URLLoader;
  6.         static private var _instance:Exemple;
  7.         static public const TEST:String = "test constante";
  8.         public function traceMessage(message:String):void{
  9.             trace ("Votre message est " + message);
  10.         }
  11.         static public function getInstance():Exemple{
  12.             if (_instance == null){
  13.             _instance = new Exemple();
  14.             }
  15.             return _instance;
  16.         }
  17.     }
  18. }

Contrairement aux propriétés, il est commun et acceptable de déclarer les méthodes public.

Les classes peuvent et doivent avoir un type spécial de méthode appelé constructeur. La méthode contructeur doit suivre plusieurs règles:

  • Le nom de la méthode doit être le même que celui de la classe
  • Cette méthode doit être déclarée comme public
  • Cette méthode ne doit pas retourner un valeur ou être déclarée avec un type de return

Le constructeur suivant assigne une nouvelle valeur à la propriété _loader:

Actionscript:
  1. package com.exemple{
  2.     import flash.net.URLLoader;
  3.     import flash.net.URLRequest;
  4.     public class Exemple {
  5.         private var _loader:URLLoader;
  6.         static private var _instance:Exemple;
  7.         static public const TEST:String = "test constante";
  8.         public function Exemple():void{
  9.             _loader = new URLLoader();
  10.         }
  11.         public function traceMessage(message:String):void{
  12.             trace ("Votre message est " + message);
  13.         }
  14.         static public function getInstance():Exemple{
  15.             if (_instance == null){
  16.             _instance = new Exemple();
  17.             }
  18.             return _instance;
  19.         }
  20.     }
  21. }

Articles similaires

Commentaires (2) Trackbacks (0)
  1. Bonjour,
    Super site, et super tuto. Franchement bravo, je débute le flex, mais pas la programmation et je trouve les explications claires et concices.
    Par contre n'y a t'il pas une erreur?

    Ne faut il pas mettre plutôt:

    Actionscript:
    1. static private var _instance:Exemple;
    2. static public function getInstance():Exemple{
    3.             if (_instance == null){
    4.                 _instance = new Exemple();
    5.             }
    6.             return _instance;
    7.         }

    car un coup il y a le _ un coup non.
    Bonne continuation.

  2. Effectivement, c'est un oubli. C'est corrigé merci :)


Leave a comment

(required)

Aucun trackbacks pour l'instant