Notions de programmation orientée objet

Transcription

Génie logiciel – Programmation orientée objet © 2005-2007 Renaud Marlet
1
Génie Logiciel
Notions de programmation
orientée objet
Renaud Marlet
LaBRI / INRIA
http://www.labri.fr/~marlet
màj 19/04/2007
Les données d'abord (1)
Important résultat de l'expérience :
–
Le plus souvent, il vaut mieux organiser un système
autour des données qu'autour des fonctions
–
Et ce d'autant plus que les données sont complexes
–
Mais si les données sont simples et les traitements
complexes, OK pour organiser le système autour
des fonctions
●
ex. bibliothèque de fonctions trigonométriques
2
Les données d'abord (2)
Important résultat de l'expérience :
–
Le plus souvent, il vaut mieux organiser un système
autour des données qu'autour des fonctions
→ Importance du lien avec le modèle conceptuel
–
objets, attributs, opérations pour les manipuler
→ Programmation Orientée Objet (OO)
3
Notions de programmation objet
●
Nécessite un cours complet (!)
–
principes
–
méthodologie
–
langages : Java, C++, Eiffel, ...
→ Juste quelques notions ici
–
idées les plus importantes
–
exemples en Java
–
comment faire de la programmation objet en C
4
Programmation objet :
classe et instance
●
Classe
= type d'objet (données + opérations pour les manipuler)
–
–
●
ex. : classe « point » dans le plan (c.-à-d. en dim 2)
●
données = deux coordonnées cartésiennes (x,y)
●
opérations = déplacer, calculer la norme (distance à (0,0)), ...
en général : 1 fichier ~ 1 classe
Instance
= exemplaire de la classe
–
ex. : un point en (3,5), un en (-2,7), un autre en (3,5) ...
5
champ et méthode
●
Champ
= attribut de l'objet
–
ex. : coordonnée x, coordonnée y
(on dit aussi « variable d'instance »)
●
Méthode
= opération pour manipuler les données (~ fonction)
–
ex. : déplacer(dx,dy), norme()
6
Exemple en Java : classe Point
class Point {
double x, y; // valeur 0 par défaut
double norme() { return Math.sqrt(x*x+y*y); }
void déplacer(double dx, double dy) {
x += dx; y += dy;
}
}
Point pt = new Point();
pt.déplacer(3.0,4.0);
double nm = pt.norme(); //→ 5.0
7
Exemple en Java : classe Point
classe
définition de champs
définition de méthodes
class Point {
double x, y; // valeur 0 par défaut
double norme() { return Math.sqrt(x*x+y*y); }
void déplacer(double dx, double dy) {
x += dx; y += dy;
}
}
fabrication d'une instance
appel de méthodes
double nm = pt.norme(); //→ 5.0
8
Exemple en Java : instances
class Point {
...
double distance(Point pt) {
double dx = x-pt.x; double dy = y-pt.y;
return Math.sqrt(dx*dx+dy*dy); }
}
Point pt1 = new Point().déplacer(7.0,3.0);
Point pt2 = new Point().déplacer(4.0,-1.0);
double dist = pt1.distance(pt2); //→ 5.0
9
Exemple en Java : instances
définition de classe
définition de méthode
class Point {
...
double distance(Point pt) {
double dx = x-pt.x; double dy = y-pt.y;
return Math.sqrt(dx*dx+dy*dy); }
}
fabrication d'instances
Point pt1 = new Point().déplacer(7.0,3.0);
Point pt2 = new Point().déplacer(4.0,-1.0);
appel de méthodes
10
constructeur
●
Constructeur
–
sorte de méthode
–
initialise les champs de l'objet lors de sa création
–
créations/initialisations plus lisibles
–
permet des initialisations toujours cohérentes
11
12
Exemple en Java : constructeur
class Point {
double x, y;
// initialisés par défaut à 0
Point(double u, double v) {
x = u; y = v;
}
...
}
Point pt1 = new Point(7.0,3.0);
Point pt2 = new Point(4.0,-1.0);
Exemple en Java : constructeur
classe
constructeur
champs
class Point {
double x, y;
// initialisés par défaut à 0
Point(double u, double v) {
x = u; y = v;
}
...
}
instances
Point pt1 = new Point(7.0,3.0);
Point pt2 = new Point(4.0,-1.0);
13
extension de classe et héritage
●
Extension de classe
–
version spécialisée d'une classe existante
–
héritage des champs et méthodes de cette classe
–
champs et méthodes additionnels
–
vocabulaire :
●
sous-classe : la classe étendue
●
super classe : la classe que l'on étend
14
15
Exemple en Java : extension
class PointColoré extends Point {
Couleur couleur;
PointColoré(double u, double v, Couleur coul){
x = u; y = v; couleur = coul; }
boolean mêmeCouleur(PointColoré pt) {
return couleur.equals(pt.couleur); }
}
Couleur rouge = new Couleur(255,0,0);
PointColoré ptRouge = new PointColoré(3,4,rouge);
double nm = ptRouge.norme();
//→ 5.0
Exemple en Java : extension
constructeur
sous-classe
champ ajouté
méthode ajoutée
super classe
class PointColoré extends Point {
Couleur couleur;
PointColoré(double u, double v, Couleur coul){
x = u; y = v; couleur = coul; }
boolean mêmeCouleur(PointColoré pt) {
return couleur.equals(pt.couleur); }
}
champs hérités
méthode héritée
instances
Couleur rouge = new Couleur(255,0,0);
PointColoré ptRouge = new PointColoré(3,4,rouge);
double nm = ptRouge.norme();
//→ 5.0
16
masquage de l'information
●
17
Masquage de l'information
–
s'applique à : classes, champs et méthodes
–
visibilité (scope)
●
public : visible par toutes les classes
●
private : visible seulement dans la classe
●
protected : visible seulement par les classes étendues
●
(package : visible seulement des classes du même package)
→ Type abstrait
–
on peut changer le contenu privé de la classe sans
changer ses utilisations publiques
18
Exemple en Java : visibilité
public class Point {
private double x, y;
public void déplacer(double dx, double dy) {
x += dx; y += dy;
}
}
pt.x = 3.0; pt.y = 4.0; // Erreur à la compilation
// OK
Exemple en Java : visibilité
classe
champs invisibles en dehors de Point
19
seul moyen de changer les coordonnées
public class Point {
private double x, y;
public void déplacer(double dx, double dy) {
x += dx; y += dy;
}
}
fabrication d'instance
pt.x = 3.0; pt.y = 4.0; // Erreur à la compilation
// OK
champs invisibles en dehors de Point
interface
●
20
Interface
~ squelette d'une classe, sans implémentation
●
méthodes d'interface : sans corps (abstraites)
●
pas de champs d'interface
–
plusieurs classes peuvent implémenter une même
interface
–
une interface peut étendre plusieurs autres interfaces
☛ Type abstrait (...→)
–
on peut changer la classe sans changer les utilisations
de l'interface
Exemple en Java : interface (1)
interface Point2D {
double norme();
void déplacer(double dx, double dy);
}
class PointCartésien implements Point2D { ... }
class PointPolaire implements Point2D {
double rayon, angle;
double norme() { return rayon; }
void déplacer(double dx, double dy) { ... }
}
21
définition d'interface
implémentations d'interface
interface Point2D {
double norme();
méthodes interface
}
définition de classes qui implémentent cette interface
class PointCartésien implements Point2D { ... }
class PointPolaire implements Point2D {
double rayon, angle;
double norme() { return rayon; }
void déplacer(double dx, double dy) { ... }
}
méthodes de classe qui implémentent les méthodes d'interface
22
23
interface Point2D {
double norme();
}
Point2D pt1 = new PointCartésien(1.0, -2.0);
Point2D pt2 = new PointPolaire(4.0, 0.7854);
pt1.déplacer(2.0, 6.0);
double nm1 = pt1.norme();
//→ 5.0
//~ 5.0
interface
interface Point2D {
double norme();
méthodes interface
}
appel de constructeurs spécifiques à chaque classe
Point2D pt1 = new PointCartésien(1.0, -2.0);
Point2D pt2 = new PointPolaire(4.0, 0.7854);
appels des méthodes d'interface
//→ 5.0
//~ 5.0
24
25
Et aussi...
●
Notion de package (paquetage)
–
●
Héritage multiple
–
●
espace de nommage
extension de plusieurs classes
Classes abstraites
~ classes incomplètes
●
Variables de classes
~ globales
●
...
Programmation objet et langage C
●
●
Langage C
–
programmation impérative (effets de bord)
–
variables, fonctions, types structurés
–
pas de notions d'objet (classe, méthode, ...)
Extensions objet à C
–
●
langages : C++, Objective C
Programmation objet en langage C
–
style de programmation particulier (→)
26
Programmation objet en langage C :
classe, champ, instance
●
●
Déclaration de classe (type d'objet)
–
déclaration de structure
–
déclaration d'un type pointeur vers cette structure
Champ de classe (attribut)
–
●
champ de structure
Création d'instance (objet) :
–
définition d'entités du type structure
–
allocation dynamique et cast vers le type pointeur
27
Exemple en C : classe et instance
déclaration de structure
champs
« classe » = pointeur sur la structure
struct str_pt {
double x, y;
};
typedef struct str_pt *point;
/* Allocation statique */
struct str_pt orig = { 0.0, 0.0 };
point origine = &orig;
/* Allocation dynamique */
allocation
point pt = (point) malloc(sizeof(struct str_pt));
cast en pointeur sur la structure
28
Programmation objet en langage C :
constructeur, méthode
●
Constructeur (création d'objet)
–
●
fonction qui alloue dynamiquement une structure et
retourne un pointeur vers la structure
Méthode (opération) :
–
fonction qui prend comme premier argument un
type pointeur vers la structure
29
30
Exemple en C : constructeur
typedef struct str_pt {
double x, y;
} *point ;
point nouveauPoint(double x, double y) {
pt->x = x; pt->y = y;
return pt;
}
point pt1 = nouveauPoint(3.0, 4.0);
point pt2 = nouveauPoint(4.0, -1.0);
Exemple en C : constructeur
« classe » = pointeur vers struct
champs
31
« constructeur » = fonction qui alloue une struct
typedef struct str_pt {
double x, y;
} *point ;
point nouveauPoint(double x, double y) {
pt->x = x; pt->y = y;
return pt;
}
appels du « constructeur »
Exemple en C : méthodes
double norme(point pt){
return sqrt(pt->x * pt->x + pt->y * pt->y);
}
void déplacer(point pt, double dx, double dy){
pt->x += dx; pt->y += dy;
}
double distance(point pt1, point pt2) {
double dx = pt1->x – pt2->x;
double dy = pt1->y – pt2->y;
return sqrt(dx*dx+dy*dy); }
32
Exemple en C : méthodes
« méthodes » = fonction avec objet comme premier argument
double norme(point pt){
return sqrt(pt->x * pt->x + pt->y * pt->y);
}
void déplacer(point pt, double dx, double dy){
pt->x += dx; pt->y += dy;
}
double distance(point pt1, point pt2) {
double dx = pt1->x – pt2->x;
double dy = pt1->y – pt2->y;
return sqrt(dx*dx+dy*dy); }
33
Programmation C :
déclaration et définition
Déclaration :
–
suposition d'existence (dans un autre fichier), typage
–
ex. extern int x;
extern int f(char, struct str);
Définition
–
lieu d'existence (ce fichier), rappel du typage
–
ex. int x;
int f(char c, struct str mystr) { ... }
(→ contrôle possible par rapport à des déclarations)
34
Programmation objet en C :
masquage de l'information
●
35
Visibilité des entités (variables, fonctions)
–
modifieur « extern »
●
déclaration d'une entité visible à l'extérieur du fichier
→ variables et fonctions publiques (déclaration)
–
modifieur « static »
●
définition d'une entité locale au fichier (invisible à l'extérieur)
→ variables et fonctions privées
–
sans modifieur
●
définition d'une entité visible à l'extérieur du fichier
(il suffit pour ça qu'on l'y déclare « extern »)
→ variables et fonctions publiques (définition)
Programmation objet en C :
interface
●
Interface
–
●
●
fichier « .h »
●
déclarations de type (structure et pointeur sur structure)
●
déclarations de fonctions (extern)
Classe qui implémente l'interface
–
inclusion du fichier « .h » (#include)
–
définition des fonctions correspondantes
Classe qui utilise l'interface
–
inclusion du fichier « .h » (#include)
–
appel des fonctions déclarées
36
Exemple en C :
fichier d'interface (point.h)
// Classe
// Constructeur
extern point nouveauPoint(double x, double y);
// Méthodes
extern double norme(point pt);
extern void déplacer(point pt, double dx, double dy);
extern double distance(point pt1, point pt2);
37
Exemple en C :
fichier d'interface (point.h)
// Classe
// Constructeur
extern point nouveauPoint(double x, double y);
// Méthodes
extern double norme(point pt);
extern void déplacer(point pt, double dx, double dy);
extern double distance(point pt1, point pt2);
38
Exemple en C :
implémentation de l'interface (point.c)
// Inclusion de l'interface
#include "point.h"
// Définition du type
typedef struct str_pt { double x, y; } *point;
// Définition des constructeurs et méthodes
static double normeXY(double x, double y) {
return sqrt(x*x+y*y); }
extern double norme(point pt) {
return normeXY(pt->x, pt->y); }
extern double distance(point pt1, point pt2) {
return normeXY(pt1->x - pt2->x, pt1->y – pt2->y); }
39
Exemple en C :
implémentation de l'interface (point.c)
#include "point.h"
// Définition du type
typedef struct str_pt { double x, y; } *point;
// Définition des constructeurs et méthodes
static double normeXY(double x, double y) {
return sqrt(x*x+y*y); }
extern double norme(point pt) {
return normeXY(pt->x, pt->y); }
extern double distance(point pt1, point pt2) {
return normeXY(pt1->x - pt2->x, pt1->y – pt2->y); }
40
Exemple en C :
utilisation via l'interface (use.c)
#include "point.h"
// Utilisation via l'interface
void use() {
printf("norm = %d\n", norme(pt1));
printf("dist = %d\n", distance(pt1,pt2));
int u = pt1->x;
/* Erreur à la compilation */
int v = normeXY(3.0,4.0); /* Erreur à la compilation */
}
41
Exemple en C :
utilisation via l'interface (use.c)
#include "point.h"
// Utilisation via l'interface
void use() {
printf("norm = %d\n", norme(pt1));
printf("dist = %d\n", distance(pt1,pt2));
int u = pt1->x;
/* Erreur à la compilation */
int v = normeXY(3.0,4.0); /* Erreur à la compilation */
}
42
Limitations de
la programmation objet en C
●
Interface seulement pour masquer
–
●
structure dans structure
Héritage plus lourd (explicite)
–
●
Pas de multiple implémentation (dans un même binaire)
Extension plus lourde
–
●
43
« cast » de type (de la sous-classe vers la superclasse)
Moins de contrôles du compilateur
–
pas de contrôle de la légalité des casts
Programmation objet en C
☛ Suivre l'esprit, pas la lettre (!)
–
s'adapter au problème : ne pas aveuglément tout
traiter avec des « objets à la C » (pointeurs vers
structure et fonctions associées)
–
aide à l'organisation des déclarations et définitions
44
45
À retenir
●
Organisation du système autour de :
–
fonctions si pas d'objets ou objets simples (ex.
scalaires)
–
données si des objets complexes
●
Lien avec le modèle conceptuel
●
Concepts de la programmation objet
–
●
classe, instance, champ, méthode, constructeur,
interface, héritage, extension
Masquage de l'information et types abstraits

Notions de programmation orientée objet

Transcription

Documents pareils

Soirée Comm Animale

Définition des Besoins

Jean François Renaud Associé et co-fondateur Adviso

Monsieur Claude RENAUD

Antoine Chance « Fou » Lana Del Rey « Ultraviolence » Sia « 1000

CONCERT : RENAUD - le 2 décembre 2016

Annuaire entreprise Elsa Renaud

Institut Supérieur Aquitain du Bâtiment et des Travaux Publics

ski club de ski club de besse - CLERMONT SKI NORDIQUE, Ski de