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 interactif
* Permet d'identifier les composants animés (les "sprites")
* Permet de déterminer les interactions entre ces composants
* TypeScript 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: TypeScript 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 interactif: 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 TS (1/2)
class Voiture {
public puissance_ : number;
public couleur_ : string;
public vitesse_ : number;
public accelerer()
{ this.vitesse_ += 5; }
public ralentir()
{ this.vitesse_ -= 5; }
public constructor(p : number,
c : string)
{
this.puissance_ = p;
this.couleur_ = c;
this.vitesse_ = 0;
}
}
Déclaration d'une classe avec TS (2/2)
* Convention de nommage
* Classe: 1ère lettre en majuscule
* Attribut et méthode: 1ère lettre en minuscule
* Attribut suivi d'un "_"
* Principe d'encapsulation
* Attributs non accessibles sans contrôle
* Attributs cachés avec le mot-clé "private"
* Des méthodes contrôlent l'accès: les "accesseurs"
* Exemple d'encapsulation
* private couleur_ : string
* public getCouleur() : string
{ return this.couleur_; }
* public setCouleur(c : string)
{ this.couleur_ = c; } ? vérification possible
Encapsulation
Utilisation d'une classe avec TypeScript
* Créer un objet à partir d'une classe: l'"instanciation"
* let 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();
* let couleur : string = ma_voiture.getCouleur();
* let vitesse : number = ma_voiture.vitesse_;
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
* class Pingouin {
private nom_ : string;
public constructor(n : string) { this.nom_ = n; }
public danser(p : Pingouin)
{ console.log(this.nom_ + " danse avec " + p.nom_); }
}
* let p1 : Pingouin = new Pingouin("Mumble");
let 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
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 TypeScript
class Pingouin {
private numero_ : number;
private x_ : number;
private y_ : number;
public constructor(n : number) {
this.numero_ = n;
this.x_ = 0;
this.y_ = 0;
}
public deplacer(x : number,
y : number) {
this.x_ = x;
this.y_ = y;
}
}
Héritage avec TypeScript (1/2)
class Forme {
protected x_ : number;
protected y_ : number;
public constructor(x : number, y : number)
{ this.x_ = x; this.y_ = y; }
public tracer() { /* Vide */ }
}
class Rectangle extends Forme {
private largeur_ : number;
private hauteur_ : number;
public constructor(x : number, y : number, l : number, h : number)
{ this.x_ = x; this.y_ = y;
this.largeur_ = l; this.hauteur_ = h; }
public 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"
* protected = membre accessible à partir des classes filles
Héritage avec TypeScript (2/2)
* Utilisation des classes "Forme" et "Rectangle"
let f : Array<Forme> = new Array<Forme>();
f[0] = new Forme(10,10);
f[1] = new Rectangle(100,100,25,10);
for (let i : number = 0; i < f.length; i++)
{ f[i].tracer(); }
* "f[0]" et "f[1]" 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 "f[0]", la méthode "tracer" de "Forme" est appelée
* Pour "f[1]", la méthode "tracer" de "Rectangle" est appelée
Complément sur les constructeurs (1/2)
* Un seul constructeur autorisé
* Contrairement à d'autres langages
* Il faut donc choisir le plus pertinent
* Quel constructeur ?
* public constructor(x : number, y : number)
{ this.x_ = x; this.y_ = y; }
* public constructor()
{ this.x_ = 0; this.y_ = 0; }
* Quelle utilisation ?
* let f : Forme = new Forme(10,10);
* let f : Forme = new Forme();
Complément sur les constructeurs (2/2)
* Héritage ==> constructions en chaîne
* Appel constructeur classe fille ==> appel constructeur classe mère
* Automatique: construction partie héritée au début du constructeur
* Exemple: construction d'un rectangle
==> Appel constructeur "Forme"
==> Exécution constructeur "Rectangle"
* Appel constructeur classe mère ==> super(arguments)
class Rectangle extends Forme {
...
public constructor(x : number, y : number,
l : number, h : number) {
super(x,y);
this.largeur_ = l; this.hauteur_ = h;
}
}
Héritage et conversion
* Tester l'appartenance d'un objet à une classe
* if (f[i] instanceof Rectangle) ...
* Conversion ascendante: fille ==> mère
* let r : Rectangle = new Rectangle(...);
* let f : Forme = r;
* Toujours possible
* Conversion descendante: mère ==> fille
* let f : Forme = new Rectangle(...);
* let r : Rectangle = f;
* Nécessite une vérification
* Toute conversion descendante doit être explicitée
* let r : Rectangle = <Rectangle>f;
* Conversion impossible ==> r = null