Design Patterns

Premire partie

Mohamed Youssfi
Laboratoire Signaux Systmes Distribus et Intelligence Artificielle (SSDIA)
ENSET, Universit Hassan II Casablanca, Maroc
Email : med@youssfi.net
Supports de cours : http://fr.slideshare.net/mohamedyoussfi9
Chane vido : http://youtube.com/mohamedYoussfi
Recherche : http://www.researchgate.net/profile/Youssfi_Mohamed/publications

med@youssfi.net
Dfinitions Design patterns
Un Design pattern dcrit la fois
Un problme qui se produit trs frquemment, dans un
environnement,
et larchitecture de la solution ce problme de telle
faon que lon puisse utiliser cette solution des milliers
de fois.

Permet de dcrire avec succs des types de

solutions rcurrentes des problmes communs
dans des types de situations
Dfinitions Design patterns
Les design patterns offrent
Une documentation dune exprience prouve
de conception
Une identification et spcification d abstractions
qui sont au dessus du niveau des simples classes
et instances
Un vocabulaire commun et aide la
comprhension de principes de conception
Un moyen de documentation de logiciels
Une Aide la construction de logiciels
complexes et htrognes, rpondant des
proprits prcises.
Catgories de Design Patterns
Cration
Description de la manire dont un objet ou un ensemble
dobjets peuvent tre crs, initialiss, et configurs
Isolation du code relatif la cration, linitialisation afin de
rendre lapplication indpendante de ces aspects
Exemples : Abstract Factory, Builder, Prototype, Singleton
Structure
Description de la manire dont doivent tre connects des
objets de lapplication afin de rendre ces connections
indpendantes des volutions futures de lapplication
Exemples : Adapter(objet), Composite, Bridge, Decorator,
Facade, Proxy
Comportement
Description de comportements dinteraction entre objets
Gestion des interactions dynamiques entre des classes et des
objets
Exemples : Strategy, Observer, Iterator, Mediator ,Visitor, State
Porte des Design Patterns
Porte de Classe
Focalisation sur les relations entre classes et
leurs sous-classes
Rutilisation par hritage
Porte dInstance (Objet)
Focalisation sur les relations entre les objets
Rutilisation par composition
Design Patterns du GoF (Gang of Four )
(Gamma, Helm
Helm,, Johnson, Vlissides)
Vlissides)
Prsentation dun Design Pattern
Nom du pattern
utilis pour dcrire le pattern, ses solutions et les
consquences en un mot ou deux
Problme
description des conditions d applications. Explication du
problme et de son contexte
Solution
description des lments (objets, relations, responsabilits,
collaboration)
permettant de concevoir la solution au problme ; utilisation
de diagrammes de classes, de squences,
vision statique ET dynamique de la solution
Consquences
description des rsultats (effets induits) de l application du
pattern sur le systme (effets positifs ET ngatifs)
QUELQUES RAPPELS

med@youssfi.net
 Exigences dun projet informatique
Exigences fonctionnelles:
Une application est cre pour rpondre , tout dabord, aux
besoins fonctionnels des entreprises.
Processus mtier de lentreprise
Exigences Techniques :
Les performances:
La maintenance:
Scurit
Portabilit
Distribution
Architectures orientes services
Capacit de fournir le service diffrents type de clients (Desk TOP,
Mobile, SMS, http)
..
Exigence financires
9
med@youssfi.net
Constat
Il est trs difficile de dvelopper un systme logiciel qui
respecte ces exigences sans utiliser lexprience des autres :
Rutiliser des modles de conceptions (Design Patterns)
Btir les applications sur des architectures existantes:
Architecture JEE
Architecture Dot Net

Ces architectures offrent :
Des Frameworks qui permettent de satisfaire les exigences techniques:
Framework pour lInversion de contrle
Grer le cycle de vie des composants de lapplication
Sparer le code mtier du code technique
Framework ORM (Mapping Objet Relationnel)
Framework MVC WEB
.
Middlewares pour faire communiquer les composants distribus de
lapplication
med@youssfi.net
Concepts fondamentaux de
lorient Objet

Classe
Objet
Hritage
Encapsulation
Polymorphisme

med@youssfi.net
Pourquoi lapproche Oriente Objet a t cre ?
Principalement :
Pour faciliter la rutilisation de lexprience des autres.
Instancier des classes existantes (Composition)
Crer de nouvelles classes drives (Hritage)
Rutilisation des Frameworks
Crer des applications faciles maintenir :
Applications fermes la modification et ouvertes lextension
Crer des applications performantes
Crer des applications scurises
Crer des applications distribues
Sparer les diffrents aspects dune application
Aspects mtiers (fonctionnels)
Aspect Prsentation (Web, Mobile, Desktop, .)
Aspects Techniques
ORM, Gestion des transaction, Scurit, Monte en charge
Distribution

med@youssfi.net
HRITAGE
ET
COMPOSITION

med@youssfi.net
Hritage et composition
Dans la programmation oriente objet,
lhritage et la composition sont deux
moyens qui permettent la rutilisation des
classes
Lhritage traduit le terme Est un ou
Une sorte de
La composition traduit le terme A un ou
A plusieurs .
Voyons partir dun exemple entre lhritage
et la composition de type A un .
 Exemple Hritage et composition
public class A { public class B extends A {
int v3=5;
int v1=2;
void meth2(){
int v2=3; System.out.print(super.meth1()*v3);
public int meth1(){ }
}
return(v1+v2);
}
}
public class C { un
int v3=5; C A
A a=new A(); 1
void meth2(){ est un
System.out.print(a.meth1()*v3);
} B
}
 Hritage et composition
B b=new B(); C c=new C();
b.meth2(); c.meth2();
:A
v1=2
v2=3

meth1() c:C :A
a= v1=2
b:B v3=5 v2=3
super=
v3=5 meth2() meth1()

meth2()
Porte des Design Patterns
Porte de Classe
Focalisation sur les relations entre classes et
leurs sous-classes
Rutilisation par hritage
Porte dInstance (Objet)
Focalisation sur les relations entre les objets
Rutilisation par composition
Pattern Strategy
Catgorie : Comportement
Objectif s:
Dfinir une famille dalgorithmes, et encapsuler
chacun et les rendre interchangeables tout en
assurant que chaque algorithme puisse voluer
indpendamment des clients qui lutilisent
Raison dutilisation :
Un objet doit pouvoir faire varier une partie de son algorithme
dynamiquement.
Rsultat :
Le Design Pattern permet d'isoler les algorithmes appartenant
une mme famille d'algorithmes.
 Diagramme de classes

On cre donc une interface de base, appele ici Strategy et on y ajoute

une mthode qui sera la mthode qui applique notre stratgie.
Il suffit alors de crer maintenant des classes concrtes qui implmentent cette
interface StrategyImpl et qui donc redfinisse la mthode de stratgie.
A un instant donn, La classe Context qui va utiliser la stratgie compose
une instance de lune des implmentation de Strategy.

med@youssfi.net
 Implmentation Java du pattern Strategy
Interface Strategy.java

public interface Strategy {

public void operaionStrategy();
}
Classe Context.java
public class Context {
protected Strategy strategy;

public void appliquerStrategy(){

strategy.operaionStrategy();
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
}

med@youssfi.net
 Implmentation Java du pattern Strategy
Implmentation 1 de linterface Strategy.

public class StrategyImpl1 implements Strategy {

@Override
public void operaionStrategy() {
System.out.println("Application de Strategy 1");
}
}

Implmentation 2 de linterface Strategy.

public class StrategyImpl2 implements Strategy {
@Override
public void operaionStrategy() {
System.out.println("Application de Strategy 2");
}
}

med@youssfi.net
 Utilisation du pattern Strategy
Application.java
public class Application { Excution :
public static void main(String[] args) { Stratgie 1:
Context ctx=new Context(); Application de Strategy 1
System.out.println("Stratgie 1:"); Stratgie 2:
ctx.setStrategy(new StrategyImpl1()); Application de Strategy 2
ctx.appliquerStrategy();
Stratgie 3:
Application de Strategy 3
System.out.println("Stratgie 2:");
ctx.setStrategy(new StrategyImpl2());
ctx.appliquerStrategy();
System.out.println("Stratgie 3:");
ctx.setStrategy(new StrategyImpl3());
ctx.appliquerStrategy();
}
}

med@youssfi.net
EXEMPLE
DAPPLICATION

med@youssfi.net
Rfrence
Simple Application: SuperCanard
Jol travaille pour une socit qui a rencontr un
norme succs avec un jeu de simulation de mare
aux canard SuperCanard .
Le jeu affiche toutes sortes de canards qui nagent
et mettent des sons.
Les premiers concepteurs du systme ont utilis
des techniques OO standard et cr une super
classe Canard dont tous les autres types de canards
hritent.
SuperCanard dans le pass

Tous les canard cancanent et nagent.

La super classe gre le code de
limplmentation

Comme tous les sous types de la

classes canard ont un aspect
diffrent, la mthode afficher est
abstraite
Autres types de canards

Chaque sous classe de canard a la

charge dimplmenter le
comportement de la mthode
afficher() pour la faon dont il
apparatra lcran
 Super canard
La socit a subi de plus en plus la pression de
la part de la concurrence.
A lissue dune semaine dun sminaire
rsidentiel consacr au brainstorming, les
dirigeants ont pens quil tait temps de
lancer une grande innovation.
Il leur faut, maintenant, quelque chose de
rellement impressionnant prsenter la
runion des actionnaires qui aura lieu la
semaine prochaine.
Maintenant, nous voulons que les canards
VOLENT
Les dirigeant ont dcid que les canards
volant taient exactement ce quil fallait
pour battre la concurrence.
Naturellement, le responsable de Jol a
dit que celui-ci naurait aucun problme
pour bricoler quelque chose en une
semaine.
Aprs tout , a-t-il dit, Jel est un
programmeur OO a ne doit pas tre si
difficile !
Maintenant, nous voulons que les canards
VOLENT

Il suffit que jajoute une mthode

voler dans la classe Canard et tous
les autres types de canards en
hriteront. Lheure est venue pour
montrer mon vraie gnie

Joe pense
 Nous somme la runion: Il y a quelque chose
qui ne va pas
Jel, cest Marie, je suis la
runion des actionnaires.
On vient de passer la dmo
et il y a plein de canard en
plastique qui volent dans
tout lcran. Cest une
plaisanterie ou quoi? Tu as
peut tre envie de passer du
temps sur Monster.fr?
Que sest t-il pass?
Jel a oubli que toutes les sous-
classes de canard ne doivent pas
voler.
Quand il a ajout le nouveau
comportement de la super classe
Canard, il a galement ajout un
comportement non appropri
certaines de ses sous-classes;
Maintenant, il a des objets volant
inanims dans son programme
SuperCanard
Il y a quelque chose qui ne va pas
OK, On dirait quil y a un lger
dfaut dans ma conception. Je ne
vois pas pourquoi il ne peuvent pas
appeler a une fonctionnalit .
Cest marrant..

Que pense Joe?

Jel rflchit lhritage

Sauf que le problme cest que je

Je pourrais toujours me
contenter de redfinir
la mthode voler() dans
la sous-classe
CanardEnPlastique,
comme je lai fait pour
cancaner()
dois faire la mme chose pour les
tous les autres types de canards
qui ne volent pas. En effet les
canards de type Leure ne volent
pas et ne cancanent pas. Je crois
que cette manire de faire me
poserait un problme pour la
maintenance

CanardEnPlastique Leurre
cancaner() { cancaner() {
//Redfinir pour couiner //Redfinir pour ne rien faire
} }
voler(){ voler(){
// Redfinir pour ne rien faire // Redfinir pour ne rien faire
} }
afficher() { afficher() {
//Aspect dun colvert //Aspect dun colvert

} }
En plus du cot fonctionnel penser la
maintenance
Jel sest rendu compte que lhritage nest
probablement pas la rponse.
En fait, il vient de recevoir une note annonant
que les dirigeant ont dcid de ractualiser le
produit tous les six mois.
Il sait que les spcifications vont changer en
permanence et quil sera peut tre amen
redfinir voller() et cancaner() pour toute sous
classes de Canard qui sera ajoute au
programme.
Il a donc besoin dun moyen plus sain pour que
seuls certains types de canard puissent voler ou
cancaner.
 La seule et unique constante du
dveloppement
Quelle est la seule chose sur laquelle vous puissiez toujours compter
en tant que dveloppeur?
Indpendamment de lendroit ou vous travaillez, de lapplication que
vous dveloppez ou du langage dans lequel vous programmez, La seule
vraie constante qui vous accompagnera toujours est:

Prenez un miroir pour voir la rponse pour ne jamais loublier

Une application qui nvolue pas meurt

 Attaquons le problme

Principe de conception:
Identifier les aspects qui changent dans
votre application et sparez-les de ceux
qui demeurent constants.

1er Principe de conception

 Sparons ce qui change de ce qui reste identique.
Pour linstant, en dehors du problme de voler() et de cancaner(), la
classe Canard fonctionne bien et ne contient rien qui semble changer
frquemment. Nous allons la laisser pratiquement telle quelle.
Maintenant, pour sparer les parties qui changent de celles qui restent
identiques, nous allons crer deux ensembles de classes, totalement
distincts de Canard, lun pour voler et lautre pou cancaner.
Chaque ensemble de classes contiendra toutes les implmentations de
leur comportement respectif.

Extraction de ce qui change

Classe Canard
Comportements qui
varient De Canard
 Conception des comportements de Canard

Comment allons-nous procder pour concevoir les classes qui

implmentent les deux types de comportements?
Pour conserver une certaine souplesse, nous allons procder de faon
que nous puissions affecter un comportement de vol de manire
dynamique un objet Canard cr.
Avec ces objectifs en tte, voyons notre deuxime principe de
conception

Principe de conception:
Programmer une interface, non une
implmentation

2me Principe de conception

 Conception des comportements de Canard

Nous allons donc utiliser une interface

pour reprsenter chaque
comportement; par exemple,
ComportementVol et
ComportementCancan.
Et chaque implmentation dun
comportement implmentera lune de
ces deux interfaces.
Cette fois, ce nest pas les classes
Canard qui implmenteront ces
interfaces, mais nous allons crer un
ensemble de classes qui
implmenteront ces interfaces et dont
la seule raison dtre est de
reprsenter un comportement
 Intgrer les comportements des canards
Les variables
Notre diagramme de classes comportementales sont
dclares de type de
lINTERFACE qui gre le
Comportement de vol encapsul comportement

Ces deux mthodes

remplacent cancaner() et
voler()
Comportement de cancanement
Conception des comportements de Canard

Avec cette conception, les autres types de dobjets

peuvent rutiliser nos comportements de vol et de
cancanement parce que ces comportements ne sont pas
cachs dans nos classes Canard!
Et nous pouvions ajouter de nouveaux comportements
sans modifier aucune des classes comportementales
existantes, ni toucher aucune des classes Canard qui
utilisent les comportements de vol et de canacanement.
Nous obtenons ainsi les avantages de la rutilisation
sans la surcharge qui accompagne lhritage.
Intgrer les comportements des canards

La cl est quun canard va maintenant dlguer ses

comportements au lieu dutiliser les mthodes voler et
cancaner() dfinies dans la classe Canard (ou une sous-
classe)
Nous allons dabord ajouter la classe Canard deux
variables dinstance nommes:
comportementVol
comportementCancan
Ces attributs seront dclars de type dinterface et non
de type dimplmentation concrte.
Chaque objet Canard affectera ces variables de
manire polymorphe pour rfrencer le type de
comportement spcifique quil aimerait avoir
lexcution (VolerAvecDesAiles, Coincoin, etc)
 Implmentons maintenant la mthode effectuerVol()

public abstract class Canard { Chaque Canard une

ComportementVol comportementVol; rfrence quelque un objet
//autres variables qui implmente linterface
ComportementVol
public void effectuerVol() {
comportementVol.voler();
}
// Autres mthodes Au lieu de grer son vol lui-
} mme, lobjet Canard dlgue
ce comportement lobjet
rfrenc la variable
Rien de plus simple cest ce pas?
dinstance comportementVol
Pour voler, lobjet Canard demande
La variable dinstance
lobjet rfrenc par comportVol de le
comportementVol est
faire sa place
dclare du type de
Dans ce niveau dimplmentation, peu lINTERFACE
importe de quel sorte dobjet sagit-il. Comportementale.
Une seule chose nous intresse: il sait
voler
 Suite de lintegration
Il est maintenant temps de soccuper de la faon dont les variables
dinstances comportementVol et comportementCancan sont affectes
Jeton un coup dil sur la sous-classe Colvert

public class Colvert extends Canard { En crant un Colvert,

public Colvert(){ la responsabilit de
comportementCancan=new Cancan(); cancanement est
comportementVol=new VolerAvecDesAilles(); dlgue un objet
} de type Cancan
public void afficher(){ Quand on fait appel
System.out.println("Je suis un vrai Colvert"); la mthode
} effectuerCancan()
cest la mthode
}
cancaner() de lobjet
Cancan qui va
Souvenez-vous que les sexcuter
Le comportement de vol sera
variables compVol et dlgu un objet de type
compCancan sont hrite VolerAvecDesAilles
de la classe Canard
Suite de lintgration
Le cancan de Colvert est un vrai cancan, pas un
coincoin, ni un cancan muet.
Quand un Colvert est instanci, son constructeur
initialise sa variable dinstance comportementCancan
hrite en lui affectant une nouvelle instance de type
Cancan ( une classe dimplmentation concrte de
linterface ComportementCancan)
Il en va de mme pour comportementVol. Le
constructeur de Colvert ou de Mandarin initialise la
variable dinstance comportementVol avec une
instance du comportement VolerAvecDesAilles (Une
classe dimplmentation concrte de linterface
ComportementVol.
 Les dveloppeurs critiquent
Bien vue. Cest exactement ce que nous
faisons. pour linstant.
Attends une seconde. Plus tard, nous aurons dans notre boite outils
Tu nas pas dit quon ne de conception dautres patterns qui nous
doit pas programmer une permettent dy remdier.
implmentation? Remarquez quand mme que si nous affectons
Mais , quest ce quon bien les comportements aux classes concrtes
fait dans le constructeur (en instanciant une classe comportementale
de Colvert? On a cr une comme Cancan ou VolerAvecDesAilles et en
instance dune classe
affectant linstance notre variable de
rfrence comportementale), nous pourrions
dimplmentation facilement cela au moment de lexcution en
concrte de Cancan: faisant appel aux setters:
new Cancan() setComportementVol(ComportementVol cc)
setComportementCancan(ComportementCancan cc)
Nous avons toujours beaucoup de souplesse,
mais la faon daffecter les variables nest pas
trs satisfaisante. z
 Intgrer les comportements des canards
Les variables
Notre diagramme de classes comportementales sont
dclares de type de
lINTERFACE qui gre le
Comportement de vol encapsul comportement

Ces deux mthodes

remplacent cancaner() et
voler()
Comportement de cancanement
Implmenter les comportements de vol
- Interface ComportementVol.java

public interface ComportementVol {

public void voler();
}
- Classe VolerAvecDesAilles.java
public class VolerAvecDesAilles implements ComportementVol
{
public void voler() {
System.out.println("Je vole !");
}}
- Classe NePasVoler.java
public class NePasVoler implements ComportementVol {
public void voler() {
System.out.println("Je ne sais pas voler!");
}}
 Implmenter les comportements de Cancanement
- Interface ComportementCancan.java
public interface ComportementCancan {
public void cancaner();
}
- Classe Cancan.java
public class Cancan implements ComportementCancan {
public void cancaner() {
System.out.println("can can can");
}}
- Classe coincoin.java
public class CoinCoin implements ComportementCancan {
public void cancaner() {
System.out.println("coin coin coin!");
}}
- Classe CancanMuet.java
public class CancanMuet implements ComportementCancan {
public void cancaner() {
System.out.println("Silence!");
}}
 Intgration des comportements aux canards
Implmentation de Canard.java
public abstract class Canard {
ComportementVol comportementVol;
ComportementCancan comportementCancan;

public void effectuerCancan() {

comportementCancan.cancaner();
}
public void effectuerVol() {
comportementVol.voler();
}
public void setComportementVol(ComportementVol compV) {
this.comportementVol = compV;
}
public void setComportementCancan(ComportementCancan compC) {
this.comportementCancan = compC;
}
public void nager() {
System.out.println("Je nage en flottant");
}
public abstract void afficher();
}
 Intgration des comportements aux canards
Implmentation des sous classes : Colvert.java
public class Colvert extends Canard {
public Colvert(){
comportementCancan=new Cancan();
comportementVol=new VolerAvecDesAilles();
}
public void afficher(){
System.out.println("Je suis un vrai Colvert");
}
}

CanardEnPlastique.java
public class CanardEnPlastique extends Canard {
public CanardEnPlastique(){
comportementCancan=new CancanMuet();
comportementVol=new NePasVoler();
}
public void afficher(){
System.out.println("Je suis un canard en plastique");
}
}
 public void effectuerVol() {
c- comportementVol.voler();
MiniSimulateur.java 9
4
}
public void effectuerCancan() {
d- comportementCancan.cancaner();
5 8 }
6
:NePasVoler
C:\>java MiniSimulateur
Je suis un vrai Colvert voler() 9-c :Canard :VolerAvecDesAilles
Je vole ! a
can can can 7 compVol: voler() 4-c
coin coin coin!
:CoinCoin compCancan
Je ne sais pas voler! b
cancaner() 8-d nager() :Cancan
effectuerVol()
cancaner() 5-d
effectuerCancan()
public class MiniSimulateur {
public static void main(String[] args) {
1- Canard colvert=new Colvert();
2- colvert.nager();
:Colvert 1
3- colvert.afficher();
4- colvert.effectuerVol();
colvert
5- colvert.effectuerCancan(); afficher()
6- colvert.setComportementCancan(new CoinCoin());
7- colvert.setComportementVol(new NePasVoler());
Constructeur de Colvert :
8- colvert.effectuerCancan(); public Colvert(){
9- colvert.effectuerVol(); a- comportementCancan=new Cancan();
} b- comportementVol=new VolerAvecDesAilles();
} Modifier les comportements de cancan }
et de vol dynamiquement
 Vue densemble des comportements encapsuls

Notre diagramme de classes

Comportement de vol encapsul

Soyez trs attentif aux relations entre les

classes. Dans notre diagramme de classe
nous avons 3 types de relations:
EST-UN : Hritage
A-UN : Composition
Comportement de cancanement IMPLEMENTE : Implmentation
A-UN peut tre prfrable EST
EST--UN
La relation A-UN est une relation intressante :
Chaque Canard a un comportementVol et un comportementCancan auxquels il
dlgue le vol est le cancanement.
Lorsque vous avez deux classes de la sorte, vous utilisez le composition.
Au lieu dhriter leur comportement, les canards lobtiennent en tant composs
avec le bon objet comportemental.
Cette technique est importante; en fait, nous avons appliqu notre troisime
principe de conception:

Utiliser la composition procure beaucoup

Principe de conception:
Prfrez la composition
lhritage
3me Principe de conception
de souplesse.
La composition permet dencapsuler un
ensemble dalgorithmes dans leur propre
ensemble de classes
Et surtout, vous pouvez modifier le
comportement au moment de lexcution
tant que lobjet avec lequel vous composez
implmente la bonne interface
comportementale.
Flicitation pour votre premier
design pattern
Vous venez dappliquez votre premier design pattern appel
STRATEGIE
Oui, vous avez appliqu le pattern Stratgie, pour revoir la conception de
SuperCanard.
Grce ce pattern, le simulateur est prt recevoir toutes les
modifications qui pourraient provenir de la prochaine sminaire aux
Balares.
Nous navons pas pris le court chemin pour lappliquer, mais en voici la
dfinition formelle

Le pattern Stratgie dfinie une famille dalgorithmes, encapsule

chacun deux et les rend interchangeables.
Stratgie permet lalgorithme de varier indpendamment des
clients qui lutilise.
Problme de conception
Vous trouverez ci-dessous un ensemble de classes et dinterfaces
pour un jeu daventure. Elles sont toutes mlanges. Il y a des
classes pour les personnages et des classes correspondants aux
comportements aux armes que les personnages peuvent utiliser.
Chaque personnage ne peut faire usage que dune seule arme la
fois, mais il peut en changer tout moment en cours du jeu.Votre
tache consiste :
Rorganiser les classes.
Identifier une classe abstraite, une interface et 8 classes concrtes
Dfinir les associations entre les classes et linterface.
Respecter le type de flche de lhritage. (extends)
Respecter le type de flche de limplmentation.(implements)
Respecter le type de flche pour la composition .(A-UN)
Placer le mthode setArme() dans la bonne classe
Problme de conception
 Exercice dimplmentation
On considre la classe Employe (voir annexe) qui est dfinie par :
deux variables dinstance cin et salaireBrutMensuel,
deux constructeurs, les getters et setters
et une mthode calculerIGR qui retourne limpt gnral sur les revenus salariaux.
La mthode getSalaireNetMensuel retourne le salaire net mensuel.
Supposant que la formule de calcul de lIGR diffre dun pays lautre.
Au Maroc, par exemple le calcul seffectue selon les cas suivant :
Si le salaire annuel est infrieur 40000, le taux de lIGR est : 5%
Si le salaire annuel est suprieur 40000 et infrieur 120000, le taux de lIGR est : 20%
Si le salaire annuel est suprieur 120000 le taux de lIGR est : 42%
En Algrie, le calcul seffectue en utilisant un taux unique de 35%.
Comme cette classe est destine tre utilise dans diffrent type de pays
inconnus au moment du dveloppement de cette classe,
1. Identifier les mthodes qui vont subir des changements chez le client.
2. En appliquant le pattern strategie, essayer de rendre cette classe ferme la
modification et ouverte lextension.
3. Crer une application de test.
4. Proposer une solution pour choisir dynamiquement limplmentation de calcul de
lIGR.
Code de la classe Employe
public class Employe {
private String cin;
private float salaireBrutMensuel;
public Employe(String cin, float salaireBrutMensuel) {
this.cin = cin;
this.salaireBrutMensuel = salaireBrutMensuel;
}
public float calculerIGR(){
float salaireBrutAnuel=salaireBrutMensuel*12;
float taux=42;
return salaireBrutAnuel*taux/100;
}
public float getSalaireNetMensuel(){
float igr=calculerIGR();
float salaireNetAnuel=salaireBrutMensuel*12-igr;
return salaireNetAnuel/12;
}
// Getters et Setters
}