Les bases de l'ActionScript 3 » POO http://www.bases-as3.fr Appréhender facilement la programmation en ActionScript 3. Thu, 28 Jul 2011 11:38:00 +0000 fr hourly 1 http://wordpress.org/?v=3.2.1 La programmation orientée objet : héritage, polymorphisme et interface http://www.bases-as3.fr/poo-heritage-polymorphisme-interface http://www.bases-as3.fr/poo-heritage-polymorphisme-interface#comments Thu, 11 Feb 2010 12:58:36 +0000 tannoy http://www.bases-as3.fr/?p=193 Introduction

Cet article fait suite à la 1ère partie intitulée : La programmation orientée objet.

Il décrit les principes d'héritage, de polymorphisme et l'utilisation des interfaces.

L’héritage

L’héritage est une forme de réutilisation du code qui permet aux programmeurs de développer de nouvelles classes à partir de classes existantes.

La classe existante est appelée classe de base ou classe mère, la nouvelle classe est appelée classe dérivée ou classe fille.

L’un des principaux avantages de l’héritage est qu’il permet de réutiliser le code d’une classe de base sans modifier le code existant. De plus, l’héritage ne nécessite pas de modifier les modes d’interaction des autres classes avec la classe de base. Plutôt que de modifier une classe existante, qui est peut-être soigneusement testée et déjà utilisée, l’héritage permet de traiter cette classe comme un module intégré qui peut être étendu à l’aide de propriétés et de méthodes supplémentaires.

Une classe ne peut pas hériter de plusieurs classes.

Création d’une sous-classe

On utilise le mot clé extends pour indiquer que notre classe est une sous-classe d’une autre.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Voiture extends Vehicule
  5.     {
  6.         public function Voiture()
  7.         {
  8.             super();
  9.         }
  10.  
  11.     }
  12. }
  13. <p>

L’instruction super() ; permet d’appeler le constructeur de la classe mère et donc dans certains cas, d’initialiser les paramètres.

Dans la mesure où chaque classe définit un type de données, l'utilisation de l'héritage crée une relation spéciale entre une classe de base et une classe qui l'étend. Une sous-classe possède obligatoirement toutes les propriétés de sa classe de base, ce qui signifie qu'il est toujours possible de substituer une instance d'une sous-classe à une instance de la classe de base.

Par exemple, si une méthode définit un paramètre du type Vehicule, il est parfaitement autorisé de lui passer un argument du type Voiture, car Voiture étend Vehicule, comme on le voit ci-dessous :

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Garage
  5.     {
  6.         public function Garage()
  7.         {
  8.         }
  9.  
  10.         public function faireLaVidange(vehicule:Vehicule):void
  11.         {
  12.             trace(vehicule)
  13.         }
  14.  
  15.     }
  16. }
  17. <p>

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy
  3. {
  4.     import fr.tannoy.garage.Garage;
  5.     import fr.tannoy.garage.Vehicule;
  6.     import fr.tannoy.garage.Voiture;
  7.  
  8.     public class Main
  9.     {
  10.         public function Main()
  11.         {
  12.             var garage:Garage = new Garage();
  13.             garage.faireLaVidange(new Voiture());
  14.             garage.faireLaVidange(new Vehicule());
  15.         }
  16.  
  17.     }
  18. }
  19. <p>

Les caractéristiques de la sous-classe

Grâce au concept d'héritage, cet objet Vehicule va pouvoir donner naissance à un ou des descendants. Ces descendants vont tous bénéficier des caractéristiques propres de leur ancêtre, à savoir ses propriétés et méthodes.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Vehicule
  5.     {
  6.         public function Vehicule()
  7.         {
  8.         }
  9.  
  10.         private var _marque:String;
  11.         public function get marque():String
  12.         {
  13.             return _marque;
  14.         }
  15.         public function set marque(value:String):void
  16.         {
  17.             _marque = value;
  18.         }
  19.     }
  20. }
  21.  
  22. package fr.tannoy.garage
  23. {
  24.     public class Voiture extends Vehicule
  25.     {
  26.         public function Voiture()
  27.         {
  28.             super();
  29.         }
  30.  
  31.     }
  32. }
  33.  
  34. package fr.tannoy.garage
  35. {
  36.     public class Moto extends Vehicule
  37.     {
  38.         public function Moto()
  39.         {
  40.             super();
  41.         }
  42.  
  43.     }
  44. }
  45.  
  46. package fr.tannoy
  47. {
  48.     import fr.tannoy.garage.Moto;
  49.     import fr.tannoy.garage.Voiture;
  50.  
  51.     public class Main
  52.     {
  53.         public function Main()
  54.         {
  55.             var voiture:Voiture = new Voiture();
  56.             voiture.marque = "Renault";
  57.             trace(voiture.marque);
  58.             var moto:Moto = new Moto();
  59.             moto.marque = "Honda";
  60.             trace(moto.marque);
  61.         }
  62.  
  63.     }
  64. }
  65. <p>

Cependant, les descendants conservent la possibilité de posséder leurs propres propriétés et méthodes. Tout comme un enfant hérite des caractéristiques de ses parents et développe les siennes, un objet peut hériter des caractéristiques de son ancêtre, mais aussi en développer de nouvelles, ou bien encore se spécialiser.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Voiture extends Vehicule
  5.     {
  6.         public function Voiture()
  7.         {
  8.             super();
  9.         }
  10.  
  11.         private var _numPortes:int = 5;
  12.         public function get numPortes():int
  13.         {
  14.             return _numPortes;
  15.         }
  16.         public function set numPortes(value:int):void
  17.         {
  18.             _numPortes = value;
  19.         }
  20.  
  21.         public function ouvrirVitres():void
  22.         {
  23.             trace("Les vitres sont ouvertes");
  24.         }
  25.     }
  26. }
  27.  
  28. package fr.tannoy
  29. {
  30.     import fr.tannoy.garage.Moto;
  31.     import fr.tannoy.garage.Voiture;
  32.  
  33.     public class Main
  34.     {
  35.         public function Main()
  36.         {
  37.             var voiture:Voiture = new Voiture();
  38.             voiture.marque = "Renault";
  39.             trace(voiture.marque);
  40.             var moto:Moto = new Moto();
  41.             moto.marque = "Honda";
  42.             trace(moto.marque);
  43.  
  44.             voiture.numPortes = 3;
  45.             voiture.ouvrirVitres();
  46.         }
  47.  
  48.     }
  49. }
  50. <p>

Notre classe Voiture nous offre donc des services plus évolués. Elle vient compléter la classe Vehicule que l’on pourrait qualifier de squelette.

Ce processus d’héritage ne s’arrête pas à un seul niveau de descendance. Il est tout à fait possible de créer un descendant de la classe Voiture comme par exemple une classe Monospace développant sa spécialisation.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Monospace extends Voiture
  5.     {
  6.         public function Monospace()
  7.         {
  8.             super();
  9.         }
  10.  
  11.         private var _numPlaces:int = 5;
  12.         public function get numPlaces():int
  13.         {
  14.             return _numPlaces;
  15.         }
  16.         public function set numPlaces(value:int):void
  17.         {
  18.             _numPlaces = value;
  19.         }
  20.  
  21.         public function passerEnSeptPlaces():void
  22.         {
  23.  
  24.         }
  25.     }
  26. }
  27.  
  28. package fr.tannoy
  29. {
  30.     import fr.tannoy.garage.Monospace;
  31.     import fr.tannoy.garage.Moto;
  32.     import fr.tannoy.garage.Voiture;
  33.  
  34.     public class Main
  35.     {
  36.         public function Main()
  37.         {
  38.             var voiture:Voiture = new Voiture();
  39.             voiture.marque = "Renault";
  40.             trace(voiture.marque);
  41.             var moto:Moto = new Moto();
  42.             moto.marque = "Honda";
  43.             trace(moto.marque);
  44.  
  45.             voiture.numPortes = 3;
  46.             voiture.ouvrirVitres();
  47.  
  48.             var monospace:Monospace = new Monospace();
  49.             monospace.marque = "Opel";
  50.             monospace.numPlaces = 7;
  51.             monospace.passerEnSeptPlaces();
  52.         }
  53.  
  54.     }
  55. }
  56. <p>

Empêcher l’héritage

Dans certains cas, il peut-être utile qu’une classe ne puisse être étendue. On utilisera alors l’attribut d’accès final.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public final class Monospace extends Voiture
  5.     {
  6.         public function Monospace()
  7.         {
  8.             super();
  9.         }
  10.  
  11.         private var _numPlaces:int = 5;
  12.         public function get numPlaces():int
  13.         {
  14.             return _numPlaces;
  15.         }
  16.         public function set numPlaces(value:int):void
  17.         {
  18.             _numPlaces = value;
  19.         }
  20.  
  21.         public function passerEnSeptPlaces():void
  22.         {
  23.  
  24.         }
  25.     }
  26. }
  27. <p>

Le polymorphisme

Le nom de polymorphisme vient du grec et signifie qui peut prendre plusieurs formes. Cette caractéristique est un des concepts essentiels de la programmation orientée objet. Dans un arbre d’héritage, une méthode polymorphe est une méthode qui a plusieurs formes en fonction de la classe dans laquelle elle se situe.

Redéfinition des méthodes

Dans notre exemple, notre classe de base Vehicule possède une méthode vidange(). Tous nos véhicules pourront donc être vidangés.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Vehicule
  5.     {
  6.         public function Vehicule()
  7.         {
  8.         }
  9.  
  10.         private var _marque:String;
  11.         public function get marque():String
  12.         {
  13.             return _marque;
  14.         }
  15.         public function set marque(value:String):void
  16.         {
  17.             _marque = value;
  18.         }
  19.  
  20.         public function vidange():void
  21.         {
  22.             trace("Vidange d'un véhicule de marque : " + marque);
  23.         }
  24.     }
  25. }
  26.  
  27. package fr.tannoy
  28. {
  29.     import fr.tannoy.garage.Garage;
  30.     import fr.tannoy.garage.Monospace;
  31.     import fr.tannoy.garage.Moto;
  32.     import fr.tannoy.garage.Voiture;
  33.  
  34.     public class Main
  35.     {
  36.         public function Main()
  37.         {
  38.             var voiture:Voiture = new Voiture();
  39.             voiture.marque = "Renault";
  40.             var moto:Moto = new Moto();
  41.             moto.marque = "Honda";
  42.             voiture.vidange();
  43.             moto.vidange();
  44.         }
  45.     }
  46. }
  47. <p>

Cependant, nous souhaitons redéfinir la façon dont on réalise la vidange d’une moto. Nous allons donc donner une nouvelle forme à la méthode vidange() dans la classe Moto.

Les méthodes statiques ne sont pas héritées et ne peuvent donc pas être redéfinies. Toutefois, les sous-classes héritent des méthodes d'instance et il est donc possible de redéfinir celles-ci sous réserve de deux conditions :

  • la méthode d'instance ne doit pas être déclarée avec le mot-clé final dans la classe de base. Lorsqu'il est utilisé avec une méthode d'instance, le mot-clé final indique que l’on souhaite empêcher les sous-classes de redéfinir cette méthode.
  • la méthode d'instance ne doit pas être déclarée avec le spécificateur de contrôle d'accès private dans la classe de base. Si une méthode est marquée comme private dans la classe de base, il n'est pas nécessaire d'utiliser le mot-clé override lors de la définition d'une méthode portant le même nom dans la sous-classe, puisque la méthode de la classe de base n'est pas visible à partir de la sous-classe.

Pour redéfinir une méthode d'instance correspondant à ces critères, la définition de la méthode dans la sous-classe doit utiliser le mot-clé override et correspondre comme défini ci-dessous à la version de cette méthode dans la super-classe :

  • la méthode de redéfinition doit avoir le même niveau de contrôle d'accès que celle de la classe de base. Les méthodes définies comme internes doivent avoir le même niveau de contrôle d'accès que celles qui n'ont pas de spécificateur de contrôle d'accès.
  • la méthode de redéfinition doit avoir le même nombre de paramètres que celle de la classe de base.
  • les paramètres de la méthode de redéfinition doivent avoir les mêmes annotations de type de données que ceux de la méthode de la classe de base.
  • la méthode de redéfinition doit avoir le même type de renvoi que celle de la classe de base.

Toutefois, il n'est pas nécessaire que les noms des paramètres de la méthode de redéfinition correspondent à ceux des paramètres de la classe de base, tant que le nombre de paramètres et leurs types de données correspondent.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Moto extends Vehicule
  5.     {
  6.         public function Moto()
  7.         {
  8.             super();
  9.         }
  10.  
  11.         override public function vidange():void
  12.         {
  13.             trace("Vidange de la moto : " + marque);
  14.             trace("Vérification de la transmission");
  15.         }
  16.     }
  17. }
  18. <p>

L'instruction super

Il arrive fréquemment que nous souhaitions compléter le comportement de la méthode de super-classe que nous redéfinissons, plutôt que remplacer ce comportement. Il est donc nécessaire de disposer d'un mécanisme permettant à une méthode d'une sous-classe d'appeler sa « méthode mère » dans la super-classe. Ce mécanisme est assuré par l'instruction super, qui contient une référence à la super-classe immédiate.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Voiture extends Vehicule
  5.     {
  6.         public function Voiture()
  7.         {
  8.             super();
  9.         }
  10.  
  11.         private var _numPortes:int = 5;
  12.         public function get numPortes():int
  13.         {
  14.             return _numPortes;
  15.         }
  16.         public function set numPortes(value:int):void
  17.         {
  18.             _numPortes = value;
  19.         }
  20.  
  21.         public function ouvrirVitres():void
  22.         {
  23.             trace("Les vitres sont ouvertes");
  24.         }
  25.  
  26.         override public function vidange():void
  27.         {
  28.             super.vidange();
  29.             trace("Changement du filtre à gasoil pour une voiture diesel");
  30.         }
  31.     }
  32. }
  33. <p>

Redéfinition des getters et setters

Bien qu'il soit impossible de redéfinir les variables définies dans une super-classe, il est possible de redéfinir les méthodes de lecture et de définition.

Le code suivant redéfinit la méthode de lecture nommée marque.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public final class Monospace extends Voiture
  5.     {
  6.         public function Monospace()
  7.         {
  8.             super();
  9.         }
  10.  
  11.         private var _numPlaces:int = 5;
  12.         public function get numPlaces():int
  13.         {
  14.             return _numPlaces;
  15.         }
  16.         public function set numPlaces(value:int):void
  17.         {
  18.             _numPlaces = value;
  19.         }
  20.  
  21.         public function passerEnSeptPlaces():void
  22.         {
  23.  
  24.         }
  25.  
  26.         override public function get marque():String
  27.         {
  28.             return super.marque.toUpperCase();
  29.         }
  30.     }
  31. }
  32. <p>

Interface

Une interface est une définition fonctionnelle d’un type de donnée.

Les interfaces sont basées sur la distinction entre l'interface d'une méthode et l'implémentation de celle-ci. L'interface d'une méthode comprend toutes les informations nécessaires pour appeler cette méthode (le nom de la méthode, l'ensemble des paramètres qu'elle reçoit et le type de données qu'elle renvoie). L'implémentation d'une méthode comprend non seulement les informations de l'interface, mais aussi les instructions exécutables qui caractérisent le comportement de la méthode. La définition d'une interface ne contient que les interfaces de la méthode, et toute classe qui implémente l'interface doit donc définir les implémentations de la méthode.

Il est aussi possible de décrire une interface en disant qu'elle définit un type de données, au même titre qu'une classe. En conséquence, une interface peut être utilisée comme annotation de type, tout comme une classe. En tant que type de données, une interface peut également être utilisée avec des opérateurs, par exemple les opérateurs is et as, qui nécessitent un type de données. Toutefois, à l'inverse d'une classe, il n'est pas possible d'instancier une interface. C'est en raison de cette distinction que l’on voit les interfaces comme des types de données abstraites et les classes comme des types de données concrètes.

La définition d'une interface

La structure de la définition d'une interface est similaire à celle de la définition d'une classe, à ceci près qu'une interface ne peut pas contenir les corps des méthodes. Les interfaces ne peuvent pas comporter des variables ou des constantes, mais elles peuvent contenir des méthodes de lecture et de définition. Pour définir une interface, on utilise le mot-clé interface.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public interface IVidangable
  5.     {
  6.  
  7.     }
  8. }
  9. <p>

Prenons le cas de notre garage, il doit vidanger des voitures, des motos mais aussi des tondeuses. Les voitures et les motos sont bien des véhicules et possède bien une méthode vidange() mais pas les tondeuses. Notre garage doit pourtant appeler la méthode vidange sur chaque élément qu’il doit vidanger. Nous allons donc créer une interface IVidangable contenant la description de la méthode vidange (). Nos classes Vehicule et Tondeuse implementerons cette interface nous garantissant la présence de la méthode vidange.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public interface IVidangable
  5.     {
  6.         function vidange();
  7.     }
  8. }
  9. <p>

Une interface définissant un type de données, nous allons donc modifier la méthode faireLaVidange de notre classe Garage afin qu’elle prenne en paramètre non plus un objet Vehicule mais un objet de type IVidangable. A partir de cet objet, nous pourrons appeler sa méthode vidange().

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Garage
  5.     {
  6.         public function Garage()
  7.         {
  8.         }
  9.  
  10.         public function faireLaVidange(engin:IVidangable):void
  11.         {
  12.             engin.vidange();
  13.         }
  14.  
  15.     }
  16. }
  17. <p>

Implémentation d'une interface dans une classe

La classe est le seul élément du langage ActionScript 3.0 qui puisse implémenter une interface. Pour implémenter une ou plusieurs interfaces, on utilise le mot-clé implements dans une déclaration de classe.

Dans une classe qui implémente une interface, les méthodes implémentées doivent :

  • utiliser l'identificateur de contrôle d'accès public,
  • utiliser le même nom que la méthode de l'interface,
  • avoir le même nombre de paramètres, chacun étant du type de données correspondant au type de données du paramètre équivalent dans la méthode de l'interface,
  • utiliser le même type de retour.

Nous allons donc implémenter l’interface IVidangable dans la classe Vehicule et dans la classe Tondeuse en définissant le comportement de la méthode.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy.garage
  3. {
  4.     public class Vehicule implements IVidangable
  5.     {
  6.         public function Vehicule()
  7.         {
  8.         }
  9.  
  10.         private var _marque:String;
  11.         public function get marque():String
  12.         {
  13.             return _marque;
  14.         }
  15.         public function set marque(value:String):void
  16.         {
  17.             _marque = value;
  18.         }
  19.  
  20.         public function vidange():void
  21.         {
  22.             trace("Vidange d'un véhicule de marque : " + marque);
  23.         }
  24.     }
  25. }
  26.  
  27. package fr.tannoy.garage
  28. {
  29.     public class Tondeuse implements IVidangable
  30.     {
  31.         public function Tondeuse()
  32.         {
  33.         }
  34.  
  35.         public function vidange():void
  36.         {
  37.             trace("Vidange d'une tondeuse");
  38.         }
  39.  
  40.     }
  41. }
  42. <p>

Notre garage pourra donc faire la vidange de ces trois engins en utilisant la même méthode à chaque fois.

COPIER-COLLER
Actionscript:
  1. </p>
  2. package fr.tannoy
  3. {
  4.     import fr.tannoy.garage.Garage;
  5.     import fr.tannoy.garage.Moto;
  6.     import fr.tannoy.garage.Tondeuse;
  7.     import fr.tannoy.garage.Voiture;
  8.  
  9.     public class Main
  10.     {
  11.         public function Main()
  12.         {
  13.             var voiture:Voiture = new Voiture();
  14.             voiture.marque = "Renault";
  15.  
  16.             var moto:Moto = new Moto();
  17.             moto.marque = "Honda";
  18.  
  19.             var tondeuse:Tondeuse = new Tondeuse();
  20.  
  21.             var garage:Garage = new Garage();
  22.             garage.faireLaVidange(voiture);
  23.             garage.faireLaVidange(moto);
  24.             garage.faireLaVidange(tondeuse);
  25.         }
  26.     }
  27. }
  28. <p>

package fr.tannoy.garage

{

public class Voiture extends Vehicule

{

public function Voiture()

{

super();

}

}

}

]]> http://www.bases-as3.fr/poo-heritage-polymorphisme-interface/feed 8 La programmation orientée objet : 1ère partie http://www.bases-as3.fr/as-programmation-objet http://www.bases-as3.fr/as-programmation-objet#comments Fri, 10 Oct 2008 00:57:14 +0000 tannoy http://www.bases-as3.fr/?p=121 La programmation orientée objet (POO) en ActionScript 3

Introduction

Avec Flash, il existe une méthode de programmation connue de beaucoup, la programmation procédurale. Cette méthode utilise les images clés pour la saisie du code et est basée sur l'utilisation de fonctions qui s'exécutent dans un ordre précis et qui assurent le bon fonctionnement du programme.

Sur un programme assez important, cela peut devenir difficile à maintenir car les comportements ne sont pas isolés.

La seconde méthode, la programmation orientée objet, va permettre de séparer les tâches d'une application

La programmation orientée objet propose une nouvelle façon de concevoir et de développer des applications, de manière à améliorer :

  • La structuration du code, afin de mieux pouvoir le comprendre
  • La réutilisabilité du code, afin de réduire les coûts de développement
  • La robustesse du code, afin de réduire les bugs et les arrêts brutaux des logiciels

Programmer de manière objet, consiste à abstraire les personnes et objets du monde qui nous entoure, de manière à pouvoir les recréer sous forme d'objet dans la mémoire d'un ordinateur. Chaque objet possède des données propres et des données partagées avec d'autres objets de même nature, et offre des services aux autres objets

Voici un exemple de programmation orientée objet :

  • porte.ouvrir()
  • ampoule.allumer()

Les tâches courantes

La programmation orientée objet va engendrer la réalisation de tâches fréquentes :

  • Définition des classes
  • Création de propriétés, méthodes et accesseurs de lecture et de définition (méthodes accesseurs)
  • Contrôle de l'accès aux classes, propriétés, méthodes et accesseurs
  • Création de propriétés et de méthodes statiques
  • Création de structures d'énumération
  • Définition et utilisation d'interfaces
  • Utilisation de l'héritage, y compris lors de la redéfinition des éléments des classes

Les classes

Une classe est une représentation abstraite d'un objet.
Une classe est assimilée à :

  • Un moule
  • Un modèle

Une classe conserve des informations sur les types de données contenues par un objet et sur les comportements possibles de cet objet.
Une classe est un type de données, et permet de créer des objets. Une classe est un fichier avec l'extension .as.
Toute classe dérive (soit directement, soit indirectement de la classe Object)
Autopsie d'une classe :

La notion de package

Les packages permettent dans un premier temps d'organiser les classes en indiquant dans quel répertoire est située une classe.

Le compilateur trouvera la classe selon le chemin renseigné par lepackage, afin de définir un paquetage nous utilisons le mot clé package.

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.poo
  2. {
  3.  
  4. }

Le package correspond à l'arborescence des répertoires.

Définition d'une classe

La syntaxe d'une définition de classe utilise le mot-clé class suivi du nom de la classe. Une classe est enregistré dans un fichier portant le même nom que la classe et avec l'extension .as.

Le corps de la définition de classe est inséré entre des accolades ({}) après le nom de la classe.

Le nom de la classe commence par une majuscule.

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.poo
  2. {
  3. public class Voiture
  4. {
  5. public function Voiture()
  6. {
  7.  
  8. }
  9. }
  10. }

Afin de pouvoir instancier notre classe depuis l'extérieur nous devons utiliser l'attribut de classe public.

Attributs d'une classe

ActionScript 3 propose 4 attributs pour les classes :

  • internal(par défaut)
    Visible uniquement dans le package dans lequel elle se trouve
  • public
    visible par tous
  • final
    La classe ne peut pas être étendue par une autre
  • dynamic
    Permet d'ajouter des propriétés aux instances lors de l'exécution.

Les attributs final et dynamic se combinent avec les attributs d'accès internal et public :

  • public final class Voiture
  • public dynamic class Voiture
  • internal dynamic class Voiture
Créer une instance de la classe

Pour pouvoir utiliser une classe, nous spécifierons son chemin au compilateur en utilisant l'instruction import.

COPIER-COLLER
Actionscript:
  1. import fr.as3.bases.poo.Voiture;

Pour pouvoir créer une instance de notre classe, nous utiliserons le mot clé new.

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.vues
  2. {
  3. import flash.display.MovieClip;
  4. import fr.as3.bases.poo.Voiture;
  5.  
  6. public class Main extends MovieClip
  7. {
  8. public function Main()
  9. {
  10. var voiture:Voiture = new Voiture("Renault", "Grise");
  11. }
  12.  
  13. }
  14. }

Les propriétés (attributs)

Sémantiquement parlant, les propriétés ou membres d'un objet sont l'ensemble de ses attributs et méthodes. Un abus de langage quasi-systématique consiste à appeler "propriétés" uniquement les attributs de l'objet.

Adobe ayant opté pour cette option, nous utiliserons aussi le terme de propriétés pour définir les attributs d'une classe.

Les propriétés d'un objet décrivent ses caractéristiques. Elles sont utilisées comme conteneur de données.

Généralement, les propriétés d'une classe sont définies juste en dessous de la définition de la classe.

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.poo
  2. {
  3. public class Voiture
  4. {
  5. var marque:String;
  6. var couleur:String;
  7.  
  8. public function Voiture()
  9. {
  10. <h5>}
  11. }
  12. }

Les attributs des propriétés

Les propriétés peuvent utiliser un des 5 attributs suivants :

  • internal (par défaut) :
    Par défaut, le membre est accessible uniquement depuis le paquetage en cours.
  • public :
    Accessible depuis n'importe quelle partie du code.
  • private :
    Le membre n'est accessible que depuis la même classe. Les sous-classes n'ont pas accès au membre.
  • protected :
    Le membre est accessible depuis la même classe, et les sous-classes.
  • static :
    Le membre est accessible uniquement depuis la classe, non depuis les instances.

Les méthodes

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.

Pour déclarer une méthode, utilisez le mot-clé function.

COPIER-COLLER
Actionscript:
  1. function fonctionExample() :void
  2. {
  3. <h5>}

Les attributs d'accès aux méthodes

Les propriétés peuvent utiliser un des 5 attributs suivants :

  • internal (par défaut) :
    Par défaut, le membre est accessible uniquement depuis le paquetage en cours.
  • public :
    Accessible depuis n'importe quelle partie du code.
  • private :
    Le membre n'est accessible que depuis la même classe. Les sous-classes n'ont pas accès au membre.
  • protected :
    Le membre est accessible depuis la même classe, et les sous-classes.
  • static :
    Le membre est accessible uniquement depuis la classe, non depuis les instances.

La méthode constructeur

La méthode constructeur, parfois appelées simplement constructeur, est une fonction qui porte le nom de la classe dans laquelle elle est définie. Tout code figurant dans une méthode constructeur est exécuté lorsqu'une instance de la classe est créée à l'aide du mot-clé new.

La méthode constructeur est obligatoirement publique, 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.

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.poo
  2. {
  3. public class Voiture
  4. {
  5. var marque:String;
  6. var couleur:String;
  7.  
  8. public function Voiture()
  9. {
  10.  
  11. }
  12. }
  13. }

Le constructeur peut-être utilisé pour initialiser les propriétés de l'objet. Dans ce cas, le constructeur possède des paramètres et ces paramètres sont utilisés pour valoriser les propriétés de l'objet.

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.poo
  2. {
  3. public class Voiture
  4. {
  5. var marque:String;
  6. var couleur:String;
  7.  
  8. public function Voiture(valMarque:String, valCouleur:String)
  9. {
  10. marque = valMarque;
  11. couleur = valCouleur;
  12. }
  13. }
  14. }

Les paramètres peuvent être facultatifs. On leur donne donc une valeur initiale qui sera utilisé si le paramètre n'est pas utilisé.

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.poo
  2. {
  3. public class Voiture
  4. {
  5. var marque:String;
  6. var couleur:String;
  7.  
  8. public function Voiture(valMarque:String, valCouleur:String = "blanche")
  9. {
  10. marque = valMarque;
  11. couleur = valCouleur;
  12. }
  13. }
  14. }

L'encapsulation

En programmation orienté objet, l'encapsulation est l'idée de cacher l'information contenue dans un objet et de ne proposer que des méthodes de manipulation de cet objet.

L'objet est ainsi vu de l'extérieur comme une boîte noire ayant certaines propriétés et ayant un comportement spécifié.

Pour manipuler notre objet et modifier certaines de ses caractéristiques, nous utiliserons des méthodes spécifiques, appelées accesseurs.

Les Accesseurs

Les méthodes accesseurs de lecture et de définition, également appelées getters et setters, permettent d'adhérer aux principes 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.

Nous allons définir nos propriétés comme étant privés. Elles ne seront pas accessibles directement par les développeurs qui utilisent notre classe.

Par convention, nous utilisons l'underscore pour débuter le nom de la propriété. Les conventions d'écritures proposées par Adobe sont traitées dans un autre sujet.

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.poo
  2. {
  3. public class Voiture
  4. {
  5. private var _marque:String;
  6. private var _couleur:String;
  7.  
  8. public function Voiture()
  9. {
  10.  
  11. }
  12. }
  13. }

Afin de définir les accesseurs, nous utilisons 2 mots clés :

  • get : définit une méthode de lecture
  • set : définit une méthode d'écriture

Le nom de l'accesseur sera celui de la propriété sans l'underscore.

La méthode de lecture : getter

Un getter utilise la syntaxe suivante :

COPIER-COLLER
Actionscript:
  1. public function get maPropriete() :type
  2. {
  3. return _maPropriete ;
  4. }

Il ne doit posséder aucun paramètre et renvoyer la valeur de la propriété.

La méthode d'écriture : setter

Un setter utilise la syntaxe suivante :

COPIER-COLLER
Actionscript:
  1. public function set maPropriete(nouvelleValeur :type) :void
  2. {
  3. _maPropriete = nouvelleValeur ;
  4. }

Il doit posséder au moins un paramètre et ne retourner aucune valeur (void).

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.poo
  2. {
  3. public class Voiture
  4. {
  5. private var _marque:String;
  6. private var _couleur:String;
  7.  
  8. public function Voiture(valMarque:String, valCouleur:String)
  9. {
  10. marque = valMarque;
  11. couleur = valCouleur;
  12. }
  13.  
  14. public function get marque():String
  15. {
  16. return _marque;
  17. }
  18.  
  19. public function set marque(value:String):void
  20. {
  21. _marque = value;
  22. }
  23.  
  24. public function get couleur():String
  25. {
  26. return _couleur;
  27. }
  28.  
  29. public function set couleur(value:String):void
  30. {
  31. _couleur = value;
  32. }
  33. }
  34. }

Les accesseurs avec une syntaxe Java

Tout comme en Java, il nous est possible d'utiliser des méthodes en tant qu'accesseurs.

COPIER-COLLER
Actionscript:
  1. public function getCouleur():String
  2. {
  3. return _couleur;
  4. }
  5.  
  6. public function setCouleur(value:String):void
  7. {
  8. _couleur = value;
  9. }

Les contrôles sur les propriétés

Un autre intérêt de l'encapsulation est de pouvoir contrôler l'affectation de valeurs aux propriétés. Avec un accès direct aux propriétés, il nous serait par exemple impossible de formater la marque du véhicule en majuscules.

Le setter va nous permettre ce formatage.

COPIER-COLLER
Actionscript:
  1. public function set marque(value:String):void
  2. {
  3. marque = value.toUpperCase();
  4. }

Les méthodes d'instance
Les méthodes d'une classe définissent les actions, les capacités d'une classe. Les noms des méthodes sont des verbes à l'infinitif, car ils désignent des actions.
Les méthodes d'instance sont affectées à une instance et non à la classe elle-même.

COPIER-COLLER
Actionscript:
  1. public function toString():String
  2. {
  3. return "Voiture " + _marque + " de couleur " + _couleur;
  4. }

COPIER-COLLER
Actionscript:
  1. var voiture:Voiture = new Voiture("Renault", "Grise");
  2. trace(voiture.toString()); //affiche Voiture RENAULT de couleur Grise

Les méthodes statiques

Les méthodes statiques, également appelées méthodes de classe, sont déclarées avec le motclé 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.

Dans une méthode statique, on ne peut accéder qu'à des membres statiques.

COPIER-COLLER
Actionscript:
  1. package fr.as3.bases.poo
  2. {
  3. public class Voiture
  4. {
  5. private var _marque:String;
  6. private var _couleur:String;
  7. private static var _nombreVoitures:int;
  8. public function Voiture(valMarque:String, valCouleur:String)
  9. {
  10. marque = valMarque;
  11. couleur = valCouleur;
  12. _nombreVoitures++;
  13.  
  14. }
  15.  
  16. public function get marque():String
  17. {
  18. return _marque;
  19. }
  20.  
  21. public function set marque(value:String):void
  22. {
  23. _marque = value;
  24. }
  25.  
  26. public function get couleur():String
  27. {
  28. return _couleur;
  29. }
  30.  
  31. public function set couleur(value:String):void
  32. {
  33. _couleur = value;
  34. }
  35. public function toString():String
  36. {
  37. return "Voiture " + _marque + " de couleur " + _couleur;
  38. }
  39.  
  40. public static function getNombreVoitures():int
  41. {
  42. return _nombreVoitures;
  43. }
  44. }
  45. }

COPIER-COLLER
Actionscript:
  1. var voiture:Voiture = new Voiture("Renault", "Grise");
  2. trace(voiture.toString()); //affiche Voiture RENAULT de couleur Grise
  3. var voiture3:Voiture = new Voiture("Opel", "Noire");
  4. trace(Voiture.getNombreVoitures());//affiche 2

La suite

Dans une seconde partie, nous étudierons d'autres fonctions : héritage, polymorphisme, interface...

]]> http://www.bases-as3.fr/as-programmation-objet/feed 13