Poo 1

Architecture logicielle
POO – UML – Design Pattern
26.09.16 Sylvain Cherrier

11 cours
1 partiel
1 contrôle intermédiaire
Objectifs :
●Acquisition des notions et du vocabulaire de la
POO
●Séparer l'apprentissage des langages de celui
des notions

POO, Design et UML :
introduction
La programmation = Analyse de problèmes, puis
conception de solutions => codage et maintenance d'une
application informatique de traitement de données.
 Programmation Orientée Objet : méthode de
programmation dans laquelle les données et les
traitements sont intégrés dans des composants, des
briques nommés Objets, représentant des idées, des
concepts et/ou des entités du monde réel.

Introduction suite...
Design pattern: (Patrons, Modéles de
conception) Façon de résoudre le problème
rencontré. Des solutions éprouvées, validées
existent et doivent être appliquées dans des
cadres bien définis. Ce n'est pas un algorithme,
c'est une architecture, une trame de solution
générique.
UML : langage graphique permettant d'échanger
avec les autres intervenants, modélisant le
comportement attendu, et les solutions mises en
place.
Introduction fin
 Bonnes pratiques : Principales méthodes et
organisations utilisées pour les architectures,
méthodes AGILES, etc...

Introduction à la
Programmation
Orientée
Objet

La solution procédurale
Afin de traiter les données, on appréhende le
problème en raisonnant de façon logique, d'un
état initial vers un état final.
Les données entrent dans l'algorithme, on
applique les actions définies, et on termine.
La programmation procédurale tend à une
capitalisation dans l'écriture du programme. On
tente de trouver des parties qui se répetent,
identiques, de trouver des comportements
types. Ce seront des procédures et fonctions,
qu'on pourra stocker dans des bibliothéques,
puis
26.09.16
réutiliser. Sylvain Cherrier
Les défauts du procédural
Principe de Wirth (inventeur du langage Pascal) :

Programme = algorithme + structure de données
=>Forte dépendance du programme aux

données
=> Peu de réutilisabilité
=> Peu d'interfaçage entre applications
=> Collaboration difficile entre programmeurs...
=> Evolution difficile, effet de bords,
régressions...
L'idée de la POO
la Programmation Orientée Objet, c'est la
tentative de réunir les données ET les
traitements en une unité cohérente et
maintenable. Dans le monde réel, tout est à la
fois données et traitements...
Une facture contient à la fois des données, et
des calculs associés...
Toute chose est à la fois dotée de
caractéristiques (des données, des valeurs) et
des comportements (des actions, des réactions
à des stimulus, des messages).
Procédural/structuré
Avantage d'être logique, mais introduit un fort couplage
Programme entre les données et le programme...
DONNÉES
Flot d'instructions
séquentiel
Procédures et
fonctions

Programmation Objet
Objet1
Programme
principal (contient des
données et les
Utilise les services Utilise traitements Objet3
services
offerts par les associés)
objets
services
crée et supprime
des objets
Objet2
Ut
e
ilis
Utilis
e
services
Les données sont encapsulées

dans l'objet. C'est plus cohérent.
Les traitements peuvent évoluer,
les contenus aussi, sans remettre
l'équilibre de l'ensemble en cause.
Problèmes des logiciels
La complexité :
➔ plus elle grandit, plus le système est fragile
➔ la complexité peut dépasser les capacités

intellectuelles de l'homme
➔ Il faut mettre en place des méthodes
rigoureuses pour se protéger de l'effondrement
de l'ensemble
➔ Il faut pourtant permettre l'évolution de
l'ensemble
➔ il faut masquer cette complexité à l'utilisateur

la conception
Comment concevoir un système ?
Le principe de base : La décomposition... Un
problème est transformé en sous-problèmes,
etc etc... vers une granularité de plus en plus
fine.
Approche Structurée :
Orientée traitement : Raisonnement principal,
modules fonctionnels, découpage progressif.
Approche OBJET :
Conception d'unités autonomes chargées de la
gestion des données qu'elles comportent. C'est
l'encapsulation. On délégue a quelque chose la
gestion en détail → Sylvain
26.09.16
il enCherrier
a la responsabilité...
L'approche Objet
Une Classe est une abstraction permettant de
modéliser des éléments du monde réel. Un objet
n'existe pas de façon isolée. Il offre des services, et
utilise des services.
Les services sont le miroir de l'activité de l'objet. Par
exemple, un objet ”Compte en banque” permet de connaitre le solde, le nom du
titulaire, d'obtenir son rib.. On peut effectuer un crédit, un débit sur cet objet, obtenir
la liste des opérations
L'objet est plus qu'un regroupement de données et
de traitement : il est cohérent, modèle exact et
complet de la perception de l'utilisateur dans le
reférentiel de son utilisation (il n'est cependant pas universel... Un
compte en banque, ce n'est pas la même chose pour un particulier et pour son
banquier. Il est cohérent pour celui qui la conçu)
Des objets et leurs services.
Dans un gestionnaire de musique (ici

Banshee), les méthodes accessibles
avec un clic droit. Il y des services
offerts par le morceau et d'autres offerts
par la liste de lecture...
Le concept d'Objet offre une
manipulation plus intuitive, puisque
comme dans la vie courante, les
fonctionnalités sont offertes par les
objets eux -mêmes...
Des objets et leurs services.
Dans l'outil de développement

Eclipse, un objet écrit en Ruby
nous présente ses méthodes.
Il s'agit dans cet exemple d'un
objet permettant d'implémenter
l'authentification. Les noms des
méthodes sont assez explicites.
Les couleurs indiquent les
restrictions d'accès à ce service
(vert = pour tous, jaune = limité)

Un objet, qu'est ce que c'est ?

Un objet, qu'est ce que
c'est ?
Un objet est un ensemble de codes informatiques
qui représente à la fois des procédures et des
données.
En Objet, la procédure s'appelle souvent une
méthode, et une donnée, un attribut.
● Un attribut est souvent typé (par exemple un
entier, un booléen, un Objet), et porte un nom.

● Une méthode est aussi typée (c'est à dire
qu'elle renvoie quelque chose de typé, ou bien
elle ne renvoie rien), porte un nom et peut
attendre des arguments.
Des attributs...
Dans cet exemple de code
Java, l'image que le
programmeur se fait d'un public class Processeur {
MicroProcesseur... boolean verbose=false;
Ce Processeur dispose d'un int compteurOrdinal=0;
compteur ordinal, sous forme int accumulateur=0;
d'entier, d'un accumulateur String etat=" ";
int registre[] = new int[5];
(entier aussi), et d'une chaine ...
de caractère Etat. }
Il dispose de 5 registres (en
gros, des emplacements pour
stocker des valeurs qui sont ici
des entiers).
Un booleen permet de passer
ce processeur en mode bavard.
...et des méthodes
...Puis les méthodes : Ce processeur (du moins, tel que le perçoit
ce programmeur, offre un ensemble de fonctionnalités, de
comportements : des méthodes..).
Par exemple, définir (set) un attribut (Etat en l'occurence),
récupérer des valeurs (celle de l'accumulateur ici), ou extraire
l'adresse mémoire indiquée dans une instruction récupérée par le
processeur...
public class Processeur {
.… (contenu de la page précédente)
public int adresseMem(String argument) {
/* cette methode se charge de récuperer l'adresse mémoire */
String adresse=argument.substring(1);//on récupere aprés $
return(Integer.parseInt(leResultat));
}
public void setEtat() {etat = ""; }
public void setEtat(String valeur) { etat = etat + "-"+valeur; }
public int getAccumulateur() {return accumulateur; }

....
26.09.16 } Sylvain Cherrier
Structure d'un programme
objet
Dans la programmation structurée, le problème posé est
décomposé jusqu'à obtenir un bloc d'instructions, parfois
capitalisé sous forme de procédure ou de fonction.
Dans la démarche objet, la décomposition conduit à
convevoir des objets
Le logiciel s'articulera autour d'objets, qui inter-agiront
les uns avec les autres. Le programme est une
structure d'objets qui collaborent entre eux.
Lors de l'exécution du programme, les objets sont créés,
et établissent entre eux des liens selon les services
qu'ils offrent. Il seront modifiés, détruits, etc..

Avantages/Inconvénients
Les objets peuvent être améliorés, corrigés, mis
à jour sans perturber le fonctionnement de
l'ensemble.. Certains langages acceptent
même des modifications dynamiques des
objets pendant le déroulement de l'application.
Il existe parfois des mécanismes qui permettent
à un objet d'inspecter un autre objet afin d'en
découvrir les méthodes offertes.
Par contre, le problème rencontré par les
débutants en objet est souvent lié à la perte
apparente de la logique séquentielle de
l'application.
Concept objet : la Classe
Dans les langages Objet, le programmeur va souvent
utiliser ou créer des Classes :
La Classe est l'usine qui engendre les objets. La
Classe est le patron (le modèle) qui définit les attributs
et les methodes d'un ensemble d'objets identiques.
La Classe est comme une chaine de montage, qui
fabrique les objets. Ainsi, tous les objets fabriqués
ont le même comportement. Mais ils auront des
attributs spécifiques à chacun, et une vie propre.
Ainsi, la chaine de fabrication des Scénics produit des
voitures ayant toutes le même comportement, mais
pas la même couleur, pas le même propriétaire, et qui
ne seront pas utilisées de la même façon (fréquence,
type de conduite, décoration...).
Plein d'objets issus d'une
Classe...
Le processus de fabrication d'un objet s'appelle
l'instanciation.
On instancie donc un objet (spécifique, précis,
celui là et pas un autre) à partir de la classe
(qui elle est générique)..
C'est la chaine de montage de Voiture (la Classe) qui a produit
Ma Voiture (la mienne, celle là, précisement). Elle ressemble
aux autres... mais c'est la mienne..
Instancier = construire un objet à partir de la
classe (via le constructeur, méthode d'instanciation de
l'objet, qui va donc le fabriquer : cet objet aura les méthodes
attendues, et les attributs aussi. Cependant, les valeurs de ses
attributs lui seront propres).
Un objet, sa naissance, sa
mort….
Et entre les deux...

L'instanciation : le
constructeur
Il s'agit de générer un objet du type décrit par la
classe. La méthode qui se charge de cette
instanciation s'appelle le constructeur.
Exemple en Java
maVoiture=new Voiture(”rouge”);
saVoiture=new Voiture(”bleue”);
Exemple en Ruby
maVoiture=Twingo.new('rouge')
saVoiture=Twingo.new('bleue')

Fin de vie : le destructeur
Lorsque l'objet devient inutile, il doit disparaitre.
Certains langages sont capables de s'apercevoir
de l'inutilité d'un objet (il n'est plus référencé, ceux
qui s'en servaient n'ont gardé aucun lien sur lui), et
le font disparaitre de la mémoire (principe du
Garbage Collector, qui passe régulièrement, en
tâche de fond, pour faire le ménage).
Il est cependant possible de fournir, et même
d'utiliser un destructeur (en C++ par exemple,
mais plus rare si on a un GC), méthode qui va
détruire l'instance de l'objet, en implémentant
certainement des traitements (vérification, logs,
etc).
Se servir d'un objet
Un fois l'objet instancié, ses méthodes seront
accessibles, souvent grâce à la notation pointée.
(nota : on pourrait aussi essayer d'accéder à ses
attributs, mais cela viole le principe d'encapsulation)
Il s'agit d'un message envoyé à l'objet, qui nous
répond alors.
Exemple en Java
maVoiture.accelere(30);
bornes=saVoiture.getKilometres();
maVoiture.depasse(saVoiture);
//notez ici un objet qui travaille avec un autre objet
Pourquoi protéger les
attributs ? (ou comment introduire les
méthodes de façon discréte...)
Pour assurer la pertinence des données !

Si on passe par une méthode, celle-ci va
assurer un nombre plus ou moins important de
vérifications afin de contrôler la validité de cette
donnée. L'exemple typique concerne les
vérifications de date..
//accès direct à l'attribut
maVoiture.dateAchat='24/11/1970'; NON
//définition de la valeur de l'attribut via une méthode
maVoiture.setDateAchat('24/11/1970'); Mieux
Exemple de méthode setter
L'accès aux attributs est trés fortement protégé par
des méthodes d'accès, qu'on appelle getter et
setter...
La méthode void setDateAchat(String laDate)
(méthode qui ne renvoie rien, et attend une chaîne de
caractères) fonctionnera certainement de la façon
suivante:
my_phone.setDateAchat('bidule'); refusera (pas une date)
my_phone.setDateAchat('31/02/2004'); refusera (impossible)
my_phone.setDateAchat('17/05/2034'); refusera (date future)
my_phone.setDateAchat('17/05/2014'); fonctionnera (vraie
date, plausible)
L'encapsulation
On voit l'intéret des méthodes, qui permettent
d'implémenter des procédures de vérification. Si le
domaine de validité de l'attribut évolue, il suffit de
faire évoluer la méthode, et l'impact sur l'ensemble
de l'application est quasi-nul.
C'est ce principe qui pousse à ne pas directement
travailler avec les attributs, mais plutôt avec les
méthodes correspondantes (le getter qui renvoie la
valeur de la variable, et le setter qui permet de la
définir).
On dit qu'on sépare l'interface (publique,
accessible...C'est ce qu'on verra, ce qui est en
contact avec l'extérieur) de l'implémentation (le
code, inaccessible et évolutif)
Des objets qui se ressemblent ?

L'héritage
Deuxième concept associé à la programmation
objet : c'est la généralisation/spécialisation.
L'héritage permet la construction d'une
arborescence de Classes en allant vers une
description de plus en plus fine (une
spécialisation).
Chaque Sous-Classe 'hérite' des
caractéristiques de sa (ses) super-Classe(s)
(méthodes et attributs), tout en l'étendant
(parfois trés peu, parfois beaucoup).
Transport
Maritime Terrestre Aérien
Pédalo Hors-bord Trottinette Train ULM
Voilier

L'héritage 2
Ce mécanisme permet à la fois une écriture

élégante (un sous-Classe ne va décrire que
ses différences par rapport à ses ancêtres :
Code plus court, plus lisible, compact) tout en
permettant un traitement générique (on
pourra traiter toutes sortes de sous-Classes
différentes pourvu qu'on s'intéresse à leur
ancêtre commun et à un attribut/une méthode
de l'ancêtre : comportement générique).

Héritage simple, héritage
multiple
Selon les langages, une classe peut dériver
(hériter) d'une ou de plusieurs super-Classes.
Dans le cadre de l'héritage simple, on obtient une
arborescence de Classes, ce qui est facile à
appréhender.
D'autres langages permettent l'héritage multiple
(C++) (une classe a plusieurs ancêtres, apportant
certains avantages de transversalité, mais
compliquant un peu les choses (conflits possibles
de noms de méthodes et d'attributs, d'où des
comportements plus difficiles à conceptualiser)
D'autres solutions
 Certains langages implémentent des solutions
Objets différentes
 Javascript utilise la programmation orientée
prototype pour réaliser la conception de nouveaux
types d'objets (il n'y a pas de classe).
 Cela permet d'être plus dynamique
 Création à la volée de nouveaux types d'objets,
changement de la hiérarchie d'héritage en cours
d'utilisation...
Héritage : effets sur les
attributs et méthodes

Héritage simple : Saut en
hauteur
Une arborescence de Classes, permettant la
gestion des objets volants.
ObjetVolant
String nom
Généralisation
float taille
Date dateCreation
float record
void vole()
float getRecord()
setRecord(float)
Spécialisation
AvionHelice AvionReactio
Planneur String nbMoteurs String nbMoteurs
Integer getPuissance() Integer getPuissance()
void vole() Bolean postCombus()
26.09.16 Sylvain Cherrier void vole()
Un programme utilisateur
de nos classes
Un autre objet (Compétition par exemple) pourra
utiliser nos classes. Quelques exemples.
ObjetVolant s1,s2; //déclaration
Planneur fb1;
s1=new ObjetVolant(); s2=new Planneur(); //oui un planneur est un
objet volant
fb1=new AvionReaction(); //NON !!! ça n'est pas cohérent !!
fb1=new Planneur(); //oui
s1.vole();s2.vole(); //oui
float record=max(s1.getRecord(),s2.getRecord());
//oui, si max(float,float) existe dans le langage, et renvoie bien un
float. Ce code est il bien objet ??

Héritage simple : Saut en
hauteur
Une arborescence de Classes, permettant la
gestion des objets volants.
ObjetVolant
String nom
Généralisation
float taille
Date dateCreation
float record
void vole()
float getRecord()
setRecord(float)
Spécialisation
AvionHelice AvionReactio
Planneur String nbMoteurs String nbMoteurs
void vole() Bolean postCombus()
26.09.16 Sylvain Cherrier void vole()
Comportement général et
spécialisation :
Le polymorphisme
Un comportement (une méthode) d'une super-Classe peut être
modifié (redéfini) dans une sous-Classe. Cette sous-Classe se
comporte d'une façon différente de la super-Classe pour cette
même action. Cette redéfinition, qui permet de spécialiser le
comportement hérité d'un ancêtre, correspond au
polymorphisme. C'est la façon de sauter qui est redéfinie ici.
Planneur AvionHelice AvionReaction

void vole() String nbMoteurs String nbMoteurs
void vole() void vole()

Redéfinition
Lors de l'appel d'un méthode, le langage recherche la plus

adaptée, celle qui correspond à l'objet traité. On travaille au
plus proche, puis on remonte dans l'arborescence des Classes
jusqu'à trouver la méthode qui s'applique.
ObjectVolant s1,s2; AvionReaction fb1;

s1=new ObjetVolant(); s2=new AvionReaction(); //oui un
AvionReaction est un ObjetVolant
fb1=new AvionReaction(); //oui
s1.vole();s2.vole(); //oui, on appelle la méthode redéfinie
float record=fb1.getRecord(); //ici, on remonte pour trouver la méthode
float record2=s2.getRecord();// Idem ici, le véritable objet est un
AvionReaction, spécialisation de ObjetVolant.. AvionReaction ne redéfinit pas
cette méthode, on appelle donc celleSylvain
26.09.16 de l'ancêtre
Cherrier
Surcharge
Autre dispositif intéressant, la surcharge. Ici, on
décline le comportement de la méthode selon
les arguments fournis. Cela permet d'appeler
un méthode avec différents arguments.
Imaginons par exemple une Classe qui
représente l'idée qu'un programmeur se fait
d'un Point dans l'espace en 2D. Cette classe
doit nous fournir le service suivant : nous dire si
oui ou non un autre Point est proche de lui,
selon une marge...

Exemple Surcharge
public class Point {
Private int x,y; //des Attributs, un point à, ici, un x et un y...
public Point(int _x, int _y) { //constructeur

x=_x; y=_y;
}
public boolean proche(int leX,int leY, int marge) {
return Math.abs(leX-x)<marge&&Math.abs(leY-y)<marge;
/* ici, on explique comment marche la
méthode proche()*/
}
public boolean proche(Point p,int marge) {
return proche(p.x,p.y,marge); //surcharge..
/* on appelle la méthode de CETTE classe, on
reste à la même ”profondeur” dans l'arborescence... */
}
}

Il est temps de jouer….

Exercices
Essayez de donner les
Classe
caractéristiques d'une Classe
nomAttribut1 : type
représentant un Compte bancaire nomAttribut2 : type
(voir le formalisme). Un utilisateur nomAttribut3 : type
doit pouvoir connaitre le solde du nomMéthode1(args..) : type

compte, et effectuer des opérations nomMéthode2(args...) : type
sur ce compte (nota : un compte,

comme un porte monnaie, ne
connait pas toutes les opérations
qui ont été effectuées : Il ne connait
que sa situation actuelle... Quel objet
pourrait être chargé de cette mémoire?)
Exercices...
On vous demande de représenter aussi un

CompteRémunéré (selon un certain taux, il
rapporte des intérêts). Le client vous demande de
pouvoir connaitre le montant des intérêts générés,
et le taux de ce compte (en plus des opérations
habituelles d'un compte). (indice : Faut il tout ré-
écrire ?)
Proposez une solution plus élégante.

Exercice
 Oeuvre
 title, author
 getTitle(), getAuthor()
Livre
● Film
●
Musique
●
● nbPg ● time ● time
● getNbPg() ● getTime() ● getTime()
● film(Livre) ● getAuthor()
Héritage ? Surcharge ? Redéfinition ?

Exercices
● Essayez de construire la Classe qui permettrait
de gérer des morceaux de musique (des Titres).
Un titre a un nom, une durée. Il a peut être été
classé dans les charts.
● Construisez ensuite la Classe Album. Un album
contient des titres (peu importe comment c'est
organisé pour le moment), il faut connaitre le
nom de l'Album, son auteur, etc... On doit
pouvoir récupérer le nombre de Titres de
l'album, la liste des titres (sous forme d'une
longue chaine), et un Titre selon son numéro de
plage...

Poo 1

Transféré par

Droits d'auteur :

Formats disponibles

Poo 1

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Poo 1

Transféré par

Droits d'auteur :

Formats disponibles

Architecture logicielle

POO – UML – Design Pattern

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

Principe de Wirth (inventeur du langage Pascal) :

=>Forte dépendance du programme aux

26.09.16 Sylvain Cherrier

Les données sont encapsulées

➔ la complexité peut dépasser les capacités

26.09.16 Sylvain Cherrier

Dans un gestionnaire de musique (ici

Dans l'outil de développement

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

entier, un booléen, un Objet), et porte un nom.

public void setEtat() {etat = ""; }

public void setEtat(String valeur) { etat = etat + "-"+valeur; }

public int getAccumulateur() {return accumulateur; }

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

Pour assurer la pertinence des données !

26.09.16 Sylvain Cherrier

Maritime Terrestre Aérien

Pédalo Hors-bord Trottinette Train ULM

26.09.16 Sylvain Cherrier

Ce mécanisme permet à la fois une écriture

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

Planneur AvionHelice AvionReaction

26.09.16 Sylvain Cherrier

Lors de l'appel d'un méthode, le langage recherche la plus

ObjectVolant s1,s2; AvionReaction fb1;

26.09.16 Sylvain Cherrier

public Point(int _x, int _y) { //constructeur

26.09.16 Sylvain Cherrier

26.09.16 Sylvain Cherrier

doit pouvoir connaitre le solde du nomMéthode1(args..) : type

sur ce compte (nota : un compte,

On vous demande de représenter aussi un

26.09.16 Sylvain Cherrier

● nbPg ● time ● time

● getNbPg() ● getTime() ● getTime()

26.09.16 Sylvain Cherrier

Vous aimerez peut-être aussi