Eléments de programmation orientée objet
Programmation orientée objet
* Modélisation orientée objet
* Modélisation = représentation simplifiée d'un système
* Modélisation reposant sur les concepts du paradigme objet
* Un formalisme universel: UML
* Modélisation orientée objet utile dans un projet Flash
* Permet d'identifier les composants d'une animation
* Permet de déterminer les interactions entre ces composants
* ActionScript est un langage orienté objet
* Programmation orientée objet
* Programmation intégrant les concepts du paradigme objet
* Langages généralistes orientés objet: C++, Java, C#...
* Pour le Web: ECMAScript et PHP intègrent des concepts objet
Définitions
* Un objet est une entité
* Chose concrète ou abstraite
* Ayant un intérêt pour l'étude
* Pouvant être reconnu distinctement
* Exemple: une voiture Clio 2 DCI, un stylo bleu...
* Classe = objets d'un même type
* Décrit un ensemble d'objets similaires
* Exemple
* Classe = voiture
* Objets = Clio 2 DCI, Punto S55...
Membres d'une classe
* Une classe possède des "membres"
* Des attributs
* Des méthodes
* Attributs = état
* Caractéristiques de l'objet
* Exemple: la couleur de la voiture
* couleur sera un attribut de la classe voiture
* bleu sera la valeur de cet attribut pour un objet précis
* Ensemble des valeurs des attributs = état de l'objet
* Programmation: attribut = variable propre à l'objet
* Méthodes = comportement
* Fonctionnalités de l'objet
* Exemple: la voiture accélère
* accélérer sera une méthode de la classe voiture
* Une méthode permet de changer l'état de l'objet
* Programmation: méthode = fonction propre à l'objet
Les principes fondateurs (1/3)
* Encapsulation
* Variables et fonctions réunies dans une même entité: la classe
* L'accès à ces éléments peut être contrôlé
* Permet de masquer les détails non nécessaires à l'utilisation
* Exemple
* Eléments nécessaires pour dessiner une forme géométrique
* Des coordonnées et une couleur
* Une fonction qui permet de tracer la forme
* Définition d'une classe "Forme"
* Trois variables: x, y et couleur
* Une fonction: tracer
Les principes fondateurs (2/3)
* Héritage
* Permet de définir une hiérarchie entre classes
* Classe fille hérite des variables et fonctions de sa mère
* Classe fille possède ses propres variables et fonctions
* Exemple
* Un rectangle est une forme géométrique
* Définition d'une classe "Rectangle"
* Hérite de la classe "Forme"
* Trois variables: x, y, et couleur
* Une fonction: tracer
* Possède ses propres caractéristiques
* Deux variables: largeur et hauteur
* Une fonction "tracer" différente
Les principes fondateurs (3/3)
* Polymorphisme
* Possibilité pour une fonction de prendre plusieurs formes
* Souvent utilisé en combinaison avec l'héritage
* Possibilité de redéfinir une fonction héritée: "redéfinition"
* Accès par la classe mère ==> polymorphisme
* Exemple
* Un rectangle et un cercle sont des formes géométriques
* Chacun a des variables et fonctions propres
* Fonctions "tracer" différentes
* Manipulation d'une forme par la classe "Forme"
* Que fait l'appel à la fonction "tracer" de la classe mère ?
* Rectangle ==> appel à "tracer" de "Rectangle"
* Cercle ==> appel à "tracer" de "Cercle"
Formalisme UML
* UML = Unified Modeling Language
* Formalisme international pour la modélisation
* Permet de modéliser tout type de système
* Utilisé en particulier pour modéliser des logiciels
* Programmes informatiques
* Bases de données
* Sites Web
* Principaux types de schémas
* Diagramme des cas d'utilisation
* Analyse des besoins
* Diagramme de classes
* Structure statique du système
* Diagramme d'interactions
* Structure dynamique du système
* Pour un projet Flash: utilisation du diagramme de classes
Diagramme de classes
* Représentation d'une classe ==> décrire des objets ayant
* Des propriétés (des attributs) similaires
* Un comportement (des méthodes) commun
* Des relations communes avec d'autres objets
Déclaration d'une classe avec AS (1/2)
public class Voiture {
public var puissance : Number;
public var couleur : String;
public var vitesse : Number;
public function accelerer()
{ this.vitesse += 5; }
public function ralentir()
{ this.vitesse -= 5; }
public function Voiture(p:Number,
c:String)
{
this.puissance = p;
this.couleur = c;
this.vitesse = 0;
}
}
Déclaration d'une classe avec AS (2/2)
* Convention de nommage en ActionScript
* Classe: 1ère lettre en majuscule
* Attribut et méthode: 1ère lettre en minuscule
* Principe d'encapsulation
* Attributs non accessibles sans contrôle
* Attributs cachés avec le mot-clé "protected"
* Des méthodes contrôlent l'accès: les "accesseurs"
* Exemple d'encapsulation
* protected var couleur : String
* public function getCouleur() : String
{ return this.couleur; }
* public function setCouleur(c:String)
{ this.couleur = c; } ? vérification possible
Encapsulation
Mot-clé "this"
* "this" représente l'objet dans lequel on se trouve
* Exécuter une méthode
* Signifie exécuter une fonction sur un objet
* "this" représente l'objet dans cette fonction
* Pas besoin de le passer en paramètre
* Exemple
* public class Pingouin {
protected var nom : String;

public function Pingouin(n:String) { this.nom = n; }

public function danser(p:Pingouin)
{ trace(this.nom + " danse avec " + p.nom); }
}
* var p1 : Pingouin = new Pingouin("Mumble");
var p2 : Pingouin = new Pingouin("Gloria");
* Que signifie "p1.danser(p2)" ?
* Exécution de la fonction "danser" sur l'objet "p1"
* Dans la fonction "danser", "this" représente alors l'objet "p1"
* Résultat: Mumble danse avec Gloria
Utilisation d'une classe avec ActionScript
* Créer un objet à partir d'une classe: l'"instanciation"
* var ma_voiture : Voiture = new Voiture(75,"bleu");
* "new" crée un objet de la classe indiquée
* "new" appelle aussi le constructeur de la classe
* Le constructeur est chargé d'initialiser l'objet
* Classe = modèle pour la création d'objets
* Objet = "instance" d'une classe donnée
* Appeler une méthode ou un attribut d'un objet
* Grâce à l'opérateur "."
* ma_voiture.accelerer();
* var couleur : String = ma_voiture.getCouleur();
* var vitesse : Number = ma_voiture.vitesse;
Envoi de messages
* Un objet peut demander à un autre d'effectuer une action
* Exemple: "alonso" envoie le message "accélérer" à "clio"
* Que se passe-t-il d'un point de vue programmation ?
* Requête auprès du receveur
* Durant l'exécution d'une des méthodes de "alonso"
* Appel à la méthode "accélérer" de "clio"
* Syntaxe employée: clio.accelerer()
* Généralement, exécution synchrone de la requête
* L'objet "alonso" arrête alors son exécution
* L'objet "clio" prend la main le temps d'exécuter "accélérer"
* Similaire à un appel de fonction
Relations entre les classes (1/2)
* Une classe peut être en relation avec d'autres
* Un objet d'une classe peut manipuler un objet d'une autre classe
* Relation d'association
* Exemple: un yéti lance un pingouin (cf. yeti sports)
* Un objet d'une classe peut contenir un objet d'une autre classe
* Relation d'agrégation
* Exemple: un pingouin possède deux ailes
* Une classe peut représenter un sous-ensemble d'objets
d'une autre classe qui sont plus spécifiques
* Relation d'héritage
* Exemple: les pingouins sont des oiseaux (de la famille des alcidés)
Relations entre les classes (2/2)
* Relation d'association
* Une classe B est associée à une classe A
* Relation d'agrégation
* Une classe B possède des objets d'une classe A
* Relation d'héritage
* Une classe B hérite des caractéristiques d'une classe A
Agrégation avec ActionScript
public class Pingouin {
protected var numero : int;
protected var posX : Number;
protected var posY : Number;
public function Pingouin(n:int) {
this.numero = n;
this.posX = 0;
this.posY = 0;
}
public function deplacer(x:Number,
y:Number) {
this.posX = x;
this.posY = y;
}
}
Héritage avec ActionScript (1/2)
public class Forme {
protected var posX : Number;
protected var posY : Number;

public function Forme(x:Number,y:Number)
{ this.posX = x; this.posY = y; }

public function tracer() { /* Vide */ }
}
public class Rectangle extends Forme {
protected var largeur : Number;
protected var hauteur : Number;

public function Rectangle(x:Number,y:Number,l:Number,h:Number)
{ this.posX = x; this.posY = y;
this.largeur = l; this.hauteur = h; }

override public function tracer() { /* Code dessin rectangle */ }
}
* "Rectangle" hérite de tous les membres de "Forme"
* Mot-clé "extends" indique la relation d'héritage
* "Rectangle" redéfinit la méthode "tracer"
* Mot-clé "override" indique la redéfinition
Héritage avec ActionScript (2/2)
* Utilisation des classes "Forme" et "Rectangle"
var f1 : Forme = new Forme(10,10);
var f2 : Forme = new Rectangle(100,100,25,10);
f1.tracer();
f2.tracer();
* "f1" et "f2" sont des objets de la classe "Forme"
* Pourtant leur méthode "tracer" est différente
* La méthode "tracer" prend donc des formes différentes
* C'est ça le polymorphisme !
* Le polymorphisme est indispensable pour l'héritage
* Pour "f1", la méthode "tracer" de "Forme" est appelée
* Pour "f2", la méthode "tracer" de "Rectangle" est appelée
Complément sur les constructeurs
* Contrairement à beaucoup de langages, un seul constructeur est autorisé
* Il faut donc choisir le plus pertinent
* Quel constructeur ?
* public function Forme(x:Number,y:Number)
{ this.posX = x; this.posY = y; }
* public function Forme()
{ this.posX = 0; this.posY = 0; }
* Quelle utilisation ?
* var f = new Forme(10,10);
* var f = new Forme();
* Constructeur sans paramètre = constructeur "par défaut"
* Possibilité d'appeler le constructeur de la classe mère
class Rectangle extends Forme {
...
public function Rectangle(x:Number,y:Number,
l:Number,h:Number)
{ super(x,y); this.largeur = l; this.hauteur = h; }
}