Programmation structur´ee COO Relation entre les classes
0-M02 – Introduction ` a la programmation Introduction ` a l’algorithmique
Cours n
◦2 Programmation structur´ ee Introduction ` a la conception orient´ ee objet
Camille Coti
camille.coti@iutv.univ-paris13.fr
IUT de Villetaneuse, d´epartement R&T
2011 – 2012
Programmation structur´ee COO Relation entre les classes
1
Programmation structur´ ee Fonctions
Proc´ edures
Approche descendante R´ ecursivit´ e
2
Conception orient´ ee objet
3
Relation entre les classes H´ eritage
Classes abstraites Interfaces
Port´ ee des attributs et des m´ ethodes
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
D´ ecomposition d’un probl` eme en sous-probl` emes
“... diviser chacune des difficult´ es que j’examinerais en autant de parcelles qu’il se pourrait et qu’il serait requis pour mieux les r´ esoudre.”
Discours de la m´ ethode (1637)
Ren´ e Descartes
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
Fonctions
D´ efinition
Une fonction d´ efinit une action effectu´ ee sur un ensemble de param` etres qui produit un r´ esultat retourn´ e comme valeur de sortie de la fonction.
Elle fournit une abstraction pour cette action vis-` a-vis des algorithmes qui l’appellent.
Analogie avec les fonctions math´ ematiques : f : x 7→ f(x) On d´ efinit la fonction une fois
On l’appelle autant de fois qu’on veut
Avantages : factorisation de code, abstraction pour la conception de
l’algorithme... Permet de se concentrer sur l’algorithme lui-mˆ eme plutˆ ot que
sur les d´ etails.
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
Param` etres et r´ esultat
On donne les param` etres et leur type
On d´ eclare les param` etres entre parenth` eses
On les utilise dans la fonction en utilisant ce nom : ce sont des variables Il existe des param` etres
D’entr´ ee : utilis´ es dans la fonction De sortie : modifi´ es dans la fonction
Ou les deux : utilis´ es et modifi´ es dans la fonction On d´ eclare le type retourn´ e
D´ eclaration de la fonction suivie par : type
On sort de la fonction avec le mot cl´ e retourner et la valeur retourn´ ee
d´ ebut fonction carre( nombre: Entier ): Entier
1
resultat : Entier
2
resultat ←− nombre × nombre
3
retourner resultat
4
fin fonction
5
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
Appel de fonction
On appelle la fonction ` a partir d’un autre algorithme
On lui passe en param` etres des variables de l’algorithme appelant La valeur retourn´ ee est mise dans une variable de l’algorithme appelant
d´ ebut programme
1
nombreDepart : Entier
2
calcul : Entier
3
calcul ←− carre ( nombreDepart )
4
fin programme
5
d´ ebut fonction carre( nombre: Entier ): Entier
1
resultat : Entier
2
resultat ←− nombre × nombre
3
retourner resultat
4
fin fonction
5
La fonction fournit donc une abstraction de l’action qu’elle r´ ealise param´ etr´ ee
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
Proc´ edures
Une proc´ edure effectue une action. Elle ne retourne rien.
Affichage : pas de r´ esultat de calcul ` a r´ ecup´ erer Calcul sur des variables de sortie
On sort de la proc´ edure
A la fin du bloc d’instructions principal `
Ou quand on rencontre le mot-cl´ e Retour
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
Proc´ edures (exemple)
d´ ebut programme
1
puissance : Entier
2
puissance ( puissance )
3
afficher ( puissance )
4
fin programme
5
d´ ebut proc´ edure puissance( petitepuissance: Entier Sortie )
1
petitepuissance ←− 1
2
tant que V rai faire
3
petitepuissance ←− petitepuissance × 2
4
if petitepuissance > 200 then
5
retourner
6
endif
7
fintq
8
fin proc´ edure
9
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
Visibilit´ e des variables
Les variables d´ eclar´ ees dans la fonction ne sont visibles que dans la fonction
Les variables d´ eclar´ ees dans le programme appelant ne sont visibles que dans le programme appelant ne sont pas visibles dans la fonction
Les variables pass´ ees en param` etre
sont appel´ ees par leur nom dans le programme appelant dans l’appel de la fonction
sont appel´ ees par le nom utilis´ e pour les d´ eclarer dans la fonction elle-mˆ eme
Visibilit´ e des variables
Les variables sont visibles uniquement dans la fonction, la proc´ edure ou le
programme dans lequel elles ont ´ et´ e d´ eclar´ ees, et dans aucune des fonctions ou
proc´ edures appel´ ees ou qui l’appellent.
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
Approche descendante
Les fonctions et les proc´ edures fournissent une abstraction sur les actions r´ ealis´ ees par le programme
Possibilit´ e de les utiliser pour se concentrer sur la structure du programme plutˆ ot que sur la r´ esolution des sous-probl` emes
On d´ ecompose le probl` eme en sous-probl` emes
On fait dans un premier temps l’hypoth` ese qu’ils sont r´ esolus On s’en occupe plus tard
La conception de l’algorithme dans sa globalit´ e est ainsi plus simple D´ ecomposer pour mieux maˆıtriser
On retarde le plus possible le moment d’effectuer les calculs
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
Approche descendante : exemple
Th´ eor` eme de Pythagore : ”le carr´ e de l’hypot´ enuse d’un triangle rectangle est
´ egal ` a la somme des carr´ es des longueurs des deux autres cˆ ot´ es”.
d´ ebut fonction hypo( cote1: Entier, cote2: Entier ): Entier
1
/* variables internes */
2
carre1 : Entier
3
carre2 : Entier
4
hypotenusecarre : Entier
5
hypotenuse : Entier
6
/* on calcule la somme des carr´ es des cˆ ot´ es */
7
carre1 ←− carr´ e( cote1 )
8
carre2 ←− carr´ e( cote2 )
9
hypotenusecarre ←− carre1 + carre2
10
/* on prend la racine carr´ ee de la somme et on retourne le
11
r´ esultat */
hypotenuse ←− racine( hypotenusecarre )
12
retourner hypotenuse
13
fin fonction
14
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
Approche descendante : exemple (suite)
d´ ebut fonction carr´ e( nombre: Entier ): Entier
1
moncarre : Entier
2
moncarre ←− nombre × nombre
3
retourner moncarre
4
fin fonction
5
d´ ebut fonction racine( nombre: Entier ): Entier
1
maracine : reel
2
maracine ←− √ nombre
3
retourner maracine
4
fin fonction
5
Programmation structur´ee COO Relation entre les classes Fonctions Proc´edures Approche descendante R´ecursivit´e
R´ ecursivit´ e
Une fonction ou une proc´ edure peut s’appeler elle-mˆ eme Elle est alors partiellement d´ efinie ` a partir d’elle-mˆ eme
d´ ebut fonction calcul( var: Entier ): Entier
1
si var == 1 alors
2
retourner var
3
sinon
4
retourner var×calcul( var − 1 )
5
finsi
6
fin fonction
7
Correspond bien aux relations de r´ ecurrence
Attention au point d’arrˆ et !
Programmation structur´ee COO Relation entre les classes
1
Programmation structur´ ee Fonctions
Proc´ edures
Approche descendante R´ ecursivit´ e
2
Conception orient´ ee objet
3
Relation entre les classes H´ eritage
Classes abstraites Interfaces
Port´ ee des attributs et des m´ ethodes
Programmation structur´ee COO Relation entre les classes
Int´ erˆ et de la COO
La conception orient´ ee objet fournit une abstraction sur les donn´ ees manipul´ ees Briques de base du programme
Le programme manipule ces ”briques” qui interagissent entre elles
On rassemble les donn´ ees relatives ` a l’´ etat d’un ´ el´ ement du syst` eme et les actions dans une structure de donn´ ees particuli` ere : une classe.
Conception d’un syst` eme ` a partir de l’analyse du probl` eme : Identification des objets
D´ efinition des actions r´ ealis´ ees sur les objets et leurs interactions
Identification des donn´ ees repr´ esentatives de l’´ etat des objets
Programmation structur´ee COO Relation entre les classes
D´ efinition d’une classe
Une classe est constitu´ ee de deux cat´ egories d’´ el´ ements : Des attributs
Des m´ ethodes Attributs
Les attributs sont les donn´ ees relatives ` a l’objet d’une classe et repr´ esentatives de son ´ etat. Ce sont des variables conserv´ ees dans la m´ emoire de l’objet manipul´ e.
M´ ethodes
Les m´ ethodes d´ ecrivent le comportement des objets et les actions que l’on peut
effectuer dessus. Ce sont des fonctions ou des proc´ edures.
Programmation structur´ee COO Relation entre les classes
Variables
Objet
Un objet est une instance d’une classe. La classe est la d´ efinition de la structure de donn´ ees, l’objet est la repr´ esentation en m´ emoire de cette classe qui est manipul´ ee par le programme.
Attention ` a la distinction :
Une classe est la description des objets
Un objet est une instance d’une classe. On peut avoir plusieurs objets d’une mˆ eme classe.
Port´ ee des champs d’un objet
Les attributs et les m´ ethodes peuvent ˆ etre : Priv´ es : accessibles uniquement depuis l’objet Publics : accessible depuis n’importe quel objet Int´ erˆ et : ne pas se tromper !
Pas de modification directe des attributs par un autre objet
Programmation structur´ee COO Relation entre les classes
Exemple : la classe Moto
Comment caract´ eriser une moto ?
Une moto a des roues (utilisation d’une classe Roue), un guidon, une quantit´ e d’essence dans le r´ eservoir, une consommation
Elle peut ˆ etre gar´ ee ou rouler ` a une certaine vitesse On a besoin d’une classe Roue. Comment la caract´ eriser ?
Une roue a un diam` etre et elle est gonfl´ ee ` a un certain niveau
Moto - nbRoues : int - roues[] : Roue - consommation : int + niveauReservoir : float - garee : booleen + vitesse : int - largeurGuidon : int
Roue
- diametre : int
- glonflage : float
Programmation structur´ee COO Relation entre les classes
Exemple : la classe Moto
Comment caract´ eriser une moto ?
Une moto a des roues (utilisation d’une classe Roue), un guidon, une quantit´ e d’essence dans le r´ eservoir, une consommation
Elle peut ˆ etre gar´ ee ou rouler ` a une certaine vitesse On a besoin d’une classe Roue. Comment la caract´ eriser ?
Une roue a un diam` etre et elle est gonfl´ ee ` a un certain niveau
Moto - nbRoues : int - roues[] : Roue - consommation : int + niveauReservoir : float - garee : booleen + vitesse : int - largeurGuidon : int
Roue
- diametre : int
- glonflage : float
Programmation structur´ee COO Relation entre les classes
Exemple : la classe Moto (suite)
Quelles actions peut-on effectuer sur une moto ?
Avancer ` a une certaine vitesse sur une certaine distance : on a une m´ ethode bool avancer( int vitesse, int distance ) S’arrˆ eter : on a une m´ ethode void arreter()
Se garer : on a une m´ ethode void garer() qui arrˆ ete la moto si besoin et qui la gare
Remplir le r´ eservoir d’essence : void fairePlein() Quelles actions peut-on effectuer sur une roue ?
La gonfler compl` etement : void gonfler()
La d´ egonfler partiellement : void degonfler( int quantit´ e )
La percer (d´ egonfler compl` etement) : void percer()
Programmation structur´ee COO Relation entre les classes
Exemple : la classe Moto (suite)
Moto + nbRoues : int - roues[] : Roue + consommation : int - niveauReservoir : float - garee : booleen - vitesse : int - largeurGuidon : int
+ avancer(vitesse:int, distance:int):bool + arreter() : void
+ garer() : void + fairePlein() : void
Roue - diametre : int - glonflage : float + gonfler() : void
+ degonfler(quantit´ e:int):void + percer() : void
Port´ ee des attributs et des m´ ethodes : Priv´ e : not´ e -
Public : not´ e +
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
1
Programmation structur´ ee Fonctions
Proc´ edures
Approche descendante R´ ecursivit´ e
2
Conception orient´ ee objet
3
Relation entre les classes H´ eritage
Classes abstraites Interfaces
Port´ ee des attributs et des m´ ethodes
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
Des classes suppl´ ementaires
En plus de nos classes Moto et Roue, on d´ efini deux autres classes Voiture et Camion :
Voiture + nbRoues : int - roues[] : Roue + consommation : int - niveauReservoir : float - garee : booleen - vitesse : int - diametreVolant : int - capaCoffre : int - remplissageCoffre : float + avancer(vitesse:int,distance:int): bool + arreter() : void
+ garer() : void + fairePlein() : void
+ remplirCoffre( volume : float ) : bool + viderCoffre( ) : void
Camion + nbRoues : int - roues[] : Roue + consommation : int - niveauReservoir : float - garee : booleen - vitesse : int - diametreVolant : int - nbRemorques : int - remorques[] : Remorque + avancer(vitesse:int,distance:int): bool + arreter() : void
+ garer() : void
+ fairePlein() : void
+ ajouterRemorque() : void
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
H´ eritage
On constate des attributs et des m´ ethodes communs entre Moto, Camion et Voiture :
Attributs : nbRoues : int roues[] : Roue consommation : int niveauReservoir : float garee : booleen vitesse : int M´ ethodes :
avancer( vitesse : int, distance : int ) : bool arreter() : void
garer() : void
fairePlein() : void
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
H´ eritage
On va donc les rassembler dans une classe Vehicule : Vehicule
+ nbRoues : int - roues[] : Roue + consommation : int - niveauReservoir : float - garee : booleen - vitesse : int
+ avancer( vitesse : int, distance : int ) : bool + arreter() : void
+ garer() : void + fairePlein() : void
Avantage : factorisation de code, abstraction d’une partie des fonctionnalit´ es
d’une classe
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
H´ eritage : classe m` ere et classes filles
Acc` es aux attributs de la classe Vehicule depuis les classes Moto, Voiture et Camion par h´ eritage
La d´ efinition des classes Moto, Voiture et Camion ne contiennent que les attributs et les m´ ethodes qui leur sont propres
Mais on peut toujours appeler la m´ ethode garer() d’une Moto
Moto - largeurGuidon : int
Voiture - diametreVolant : int - capaCoffre : int - remplissageCoffre : float + remplirCoffre( volume : float ) : bool + viderCoffre( ) : void
Camion
- diametreVolant : int
- nbRemorques : int
- remorques[] : Remorque
+ ajouterRemorque() : void
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
H´ eritage
Vehicule
+ nbRoues : int - roues[] : Roue + consommation : int - niveauReservoir : float - garee : booleen - vitesse : int
+ avancer( vitesse : int, distance : int ) : bool + arreter() : void
+ garer() : void + fairePlein() : void
Moto
- largeurGuidon : int
Voiture
- diametreVolant : int - capaCoffre : int - remplissageCoffre : float + remplirCoffre( volume : float ) : bool + viderCoffre( ) : void
Camion
- diametreVolant : int
- nbRemorques : int
- remorques[] : Remorque
+ ajouterRemorque() : void
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
Classe abstraite
D´ efinition
Une classe abstraite est uen classe dont il n’est pas possible d’instancier des objets.
Exemple : la classe Vehicule peut ˆ etre une classe abstraite
Cela n’a pas de sens d’instancier un objet de la classe Vehicule
Son nom apparait sur le diagramme de classes en italique.
Int´ erˆ et : ne pas instancier par erreur des objets d’une classe qui n’a pas de sens en elle-mˆ eme. Utilis´ e uniquement dans l’arbre d’h´ eritage.
Vehicule
+ nbRoues : int - roues[] : Roue + consommation : int - niveauReservoir : float - garee : booleen - vitesse : int
+ avancer( vitesse : int, distance : int ) : bool + arreter() : void
+ garer() : void + fairePlein() : void
Moto
- largeurGuidon : int
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
Interfaces
D´ efinition
Une interface est une classe qui ne contient que des m´ ethodes, ne donne que leurs prototypes et n’est pas instanciable.
Une interface d´ efinit un contrat de comportement : toutes les classes qui l’instancient doivent respecter de contrat et suivre le comportement d´ efini (prototype des m´ ethodes).
Int´ erˆ et : possibilit´ e d’impl´ ementer la mˆ eme chose de diff´ erentes fa¸ cons dans plusieurs classes diff´ erentes
Toutes les classes impl´ ementant une interface suivent le mˆ eme comportement
On peut instancier un objet de n’importe quelle classe, on sait quel sera
son comportement
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
Interfaces (suite)
<<interface>>
Roule
+ avancer(vitesse:int,distance:int):bool + arreter() : void
+ garer() : void
Vehicule
+ nbRoues : int - roues[] : Roue + consommation : int - niveauReservoir : float - garee : booleen - vitesse : int
+ fairePlein() : void
Moto
- largeurGuidon : int
Voiture
- diametreVolant : int - capaCoffre : int - remplissageCoffre : float + remplirCoffre(volume:float):bool + viderCoffre( ) : void
Camion
- diametreVolant : int
- nbRemorques : int
- remorques[] : Remorque
+ ajouterRemorque() : void
Programmation structur´ee COO Relation entre les classes H´eritage Classes abstraites Interfaces Port´ee
