Analyse et conception orientées objet Tête la première

1 une appli bien conçue qui assure
Un bon logiciel
commence ici
J’ai du mal à m’en remettre,
Solange, mais depuis que j’ai
commencé à utiliser ACOO, je me
sens un autre homme... un autre
homme, crois-moi !
Alors comment écrit-on vraiment un bon logiciel ? Il
n’est jamais facile de décider par où commencer. Est-ce que l’application fait
effectivement ce qu’elle est censée faire ? Et que dire du code dupliqué ?
Est-ce mauvais signe ? Il est toujours difficile de choisir sur quoi travailler en
premier, tout en s’assurant de ne pas compromettre le reste de l’opération.
Mais pas de souci. Quand vous aurez fini ce chapitre, vous saurez comment
écrire un bon logiciel et vous aurez fait un grand pas en avant pour
améliorer définitivement le développement de vos applications. Pour finir, vous
comprendrez pourquoi vous avez tout intérêt à connaître l’ACOO.
voici un nouveau chapitre
le son du bois et des cordes
Le Rock’n’roll, c’est pour la vie !
Il n’y a rien de mieux que le son d’une guitare de rêve dans les mains
d’un grand musicien. Les Guitares d’Éric est le magasin tout indiqué pour
trouver l’instrument idéal quand on est connaisseur.
Nous vous proposons un
choix hallucinant. Entrez, ditesnous quel genre de guitare vous
aimez et nous vous trouverons
l’instrument parfait, c’est garanti !
guitare
Voici Éric, aficionado de lasin de
ga
ma
n
et propriétaire d’u
guitares haut de gamme.
Il y a tout juste quelques mois, Éric a décidé de se débarrasser de
son vieux système de gestion sur papier et de commencer à utiliser
un système informatique pour faire son inventaire. Il a contacté une
entreprise de programmation renommée, Codage Pur et Dur. Ils lui
ont créé une application de gestion d’inventaire. L’entreprise lui a
même fabriqué un nouvel outil de recherche pour l’aider à trouver
l’instrument idéal pour chaque client.
chapitre 1
une application bien conçue qui assure
La toute nouvelle application d’Éric...
Voici l’application que l’entreprise de programmation a créée. Ils ont
élaboré un système pour remplacer toutes les notes écrites par Éric et
l’aider à associer un client à une guitare idéale. Voici le diagramme de
classe UML qu’ils ont donné à Éric pour lui montrer ce qu’ils ont fait :
Voici l’inventaire complet
d’Éric, ainsi qu’un moyen de
chercher des guitares.
Chaque guitare de est
l’inventaire d’Éric e
représentée par un classe.
instance de cette
Inventaire
Guitare
Voici les
variables
de la classe
Guitare.
Ce sont les
méthodes
pour la classe
Guitare.
numSerie : String
prix : double
fabricant : String
modele : String
type : String
boisFond : String
boisTable : String
getNumSerie() : String
getPrix() : double
setPrix(float)
getFabricant() : String
getModele() : String
getType() : String
getBoisFond() : String
getBoisTable() : String
L’inventaire conserve uneres
liste de toutes les guita
qu’Éric a à disposition.
guitares : List
addGuitare(String, double, String, String,
String, String, String)
getGuitare(String) : Guitare
chercher(Guitare) : Guitare
Cette
méthode
rentre tous
e
od
le
th
s détails
mé
e
tt
Ce
prend le numéro de elC’est la méthode de recherche ; d’une guitare,
série d’une guitare cl le prend la guitare idéale d’un crée un objet
et renvoie l’objet l’i ient et renvoie une guitare de Guitare et
de cette guitare. aunventaire d’Éric qui correspond l’ajoute à
x critères du client
l’inventaire
.
d’Éric.
les attributs qui
Éric a décidé qugue itare sont : le numéro de
définissent une fabricant et le modèle, le Nous avons une petite
série, le prix, lee ou électrique) et les bois surprise à votre attention
dans l’Annexe B. Je
type (acoustiqu guitare.
un œil avant de contteinuz-y
utilisés pour la
l’UML ou la programmater si
OO sont nouveaux pour ion
vous.
Nouveau à Objectville ?
m
phis
mor
Pol
y
ge
a
Hérit
n
sulatio
Encap
Si vous découvrez la programmation orientée objet, et que vous n’avez jamais
entendu parler d’UML, ou si vous vous posez des questions sur le diagramme
ci-dessus, ne vous en faites pas ! Nous avons préparé un petit dossier spécial
« Bienvenue à Objectville » pour vous aider à commencer. Rendez-vous à
la fin du livre et lisez l’Annexe B, vous ne le regretterez pas. Puis revenez à
cette page et tout sera beaucoup plus clair pour vous.
vous êtes ici 4
le début du code de l’application d’Éric
Voici ce à quoi ressemble le code
de Guitare.java
Vous avez vu le diagramme de classe pour l’application
d’Éric à la page précédente ; regardons maintenant à quoi
ressemble concrètement le code de Guitare.java et
Inventaire.java.
public class Guitare {
Ce sont toutes
propriétés que noles
avons vues dans leus
diagramme de
pour la classe Gcluiasse
tare.
private String numSerie, fabricant, modele, type, boisFond,
boisTable;
private double prix;
public Guitare(String numSerie, double prix,
String fabricant, String modele, String type,
String boisFond, String boisTable) {
this.numSerie = numSerie;
this.prix = prix;
Les diagrammes de classes UML ne
this.fabricant = fabricant;
montrent pas les constructeurs ; le
this.modele = modele;
constructeur de Guitare ne fait
this.type = type;
cependant rien d’exceptionnel : il met
this.boisFond = boisFond;
en place toutes les propriétés initiales
this.boisTable = boisTable;
pour une nouvelle Guitare.
}
public String getNumSerie() {
return numSerie;
}
public double getPrix() {
return prix;
}
public void setPrix(float nouveauPrix) {
this.prix = nouveauPrix;
Vous pouvez voir
}
public String getFabricant() {
que le diagramme de
return fabricant;
classe correspond
}
bien aux méthodes
public String getModele() {
du code de la classe
return modele;
Guitare.
}
public String getType() {
return type;
}
public String getBoisFond() {
return boisFond;
}
public String getBoisTable() {
return boisTable;
}
chapitre 1
Guitare
numSerie : String
prix : double
fabricant : String
modele : String
type : String
boisFond : String
boisTable : String
getNumSerie() : String
getPrix() : double
setPrix(float)
getFabricant() : String
getModele() : String
getType() : String class
getBoisFond() : String{Guitare
getBoisTable() : String Guitare()
}
Guitare.java
une appli bien conçue qui assure
Et Inventaire.java...
public class Inventaire {
private List guitares;
les
Attention, nous avons retnirépour
déclarations d’importatio
économiser de l’espace.
public Inventaire() {
guitares = new linkedList();
}
public void addGuitare(String numSerie, double prix,
String fabricant, String modele,
String type, String boisFond, String boisTable) {
Guitare guitare = new Guitare(numSerie, prix, fabricant,
modele, type, boisFond, boisTable);
addGuitare() réunit
guitares.add(guitare);
tous
les attributs requ
}
is
po
ur
public Guitare getGuitare(String numSerie) {
créer une nouvelle
in
st
an
for (Iterator i = guitares.iterator(); i.hasNext(); ) {
ce
de Guitare, la crée
Guitare guitare = (Guitare)i.next();
et
l’ajoute à l’inventa
if (guitare.getNumSerie().equals(numSerie)) {
ire.
return guitare;
}
}
return null;
}
public Guitare chercher(Guitare chercherGuitare) {
méthode est un peu en
for (Iterator i = guitares.iterator(); i.hasNext(); ) { Cette
fouillis... Elle compare chaquedans
Guitare guitare = (Guitare)i.next();
// Ignore le numéro de série puisqu’il est unique
attribut de l’objet Guitare et
// Ignore le prix puisqu’il est unique
lequel elle passe à chaque obj ric.
String fabricant = chercherGuitare.getFabricant();
Guitare dans l’inventaire d’É
if ((fabricant != null) && (!fabricant.equals(“”)) &&
(!fabricant.equals(guitare.getFabricant())))
continue;
String modele = chercherGuitare.getModele();
if ((modele != null) && (!modele.equals(“”)) &&
(!modele.equals(guitare.getModele())))
continue;
String type = chercherGuitare.getType();
if ((type != null) && (!chercherGuitare.equals(“”)) &&
(!type.equals(guitare.getType())))
continue;
String boisFond = chercherGuitare.getBoisFond();
Inventaire
if ((boisFond != null) && (!boisFond.equals(“”)) &&
guitares : List
(!boisFond.equals(guitare.getBoisFond())))
continue;
addGuitare(String, double, String,
String boisTable = chercherGuitare.getBoisTable();
String,
String, String, String)
if ((boisTable != null) && (!boisTable.equals(“”)) &&
getGuitare(String)
: Guitare
(!boisTable.equals(guitare.getBoisTable())))
class
continue;
chercher(Guitare) : Guitare Inven{
taire
}
cherreturn null;
cher()
}
}
Inventaire.java
vous êtes ici 4
le cas de la guitare manquante
Mais c’est là qu’Éric a commencé à perdre
des clients...
On dirait que peu importe qui est le client et ce qu’il aime, le nouveau programme de
recherche ne parvient presque jamais à trouver une guitare qui correspond. Pourtant
Éric sait qu’il a les guitares que ses clients désirent... alors que se passe-t-il ?
TrouverGuitareTest.jav
maintenant un jour ordia simule
naire
pour Éric... un client entr
dit ce qu’il veut et Éric e, lui
cherche
dans son inventaire.
public class TrouverGuitareTest {
public static void main(String[] args) {
// Dresse l’inventaire des Guitares d’Éric
Inventaire inventaire = new Inventaire();
initialiserInventaire(inventaire);
Irène cherche une
guitare Fender lne.
« Strat » en au
Guitare prefIrene = new Guitare(“”, 0, “fender”,
“Stratocaster”, “électrique”, “aulne”, “aulne”);
Guitare guitare = inventaire.chercher(prefIrene);
if (guitare != null) {
System.out.println(“Irène,peut-être aimerez-vous cette guitare” +
guitare.getFabricant() + “ ” +
guitare.getModele() + “ ”
guitare.getType() + “ en :\n
” +
guitare.getBoisFond() + “ pour le corps,\n
” +
guitare.getBoisTable() + “ pour la table.\n Elle est à vous
pour seulement ” +
guitare.getPrix() + “ € !”);
} else {
System.out.println(“Désolé, Irène, nous n’avons rien pour
vous.”);
}
}
private static void initialiserInventaire(Inventaire inventaire) {
// Ajoute des guitares dans l’inventaire...
class
}
ChercherGui}
tare {
}
main()
TrouverGuitareTest.java
Fichier Édition Fenêtre Aide C7#5
%java TrouverGuitareTest
Désolé, Irène, nous n’avons rien pour vous.
and Irène
Voilà ce qui se passesinqud’Éric et qu’il
entre dans le maga r une guitare.
essaie de lui trouve
chapitre 1
Je suis navrée Éric,
mais il ne me reste plus qu’à
aller dans l’autre magasin, à
l’autre bout de la ville.
une appli bien conçue qui assure
Pourtant je sais que j’ai une
magnifique guitare Fender
Strat. Tenez, la voilà :
inventaire.addGuitare(“V95693”,
1499.95, “Fender”, “Stratocaster”,
“électrique”, “aulne”, “aulne”);
Voici un morceau du code
qui dresse l’inventaire d’Éric.
Vous voyez qu’il a une guitare
parfaite pour Irène.
À vos crayons
Ces critères semblent
correspondre
exactement à ce qu’a
demandé Irène... alors
que se passe-t-il ?
Comment changer l’application d’Éric ?
Regardez bien les trois dernières pages, avec le code de l’application d’Éric et
les résultats que l’on obtient lors d’une recherche. Quels problèmes voyez-vous ?
Qu’est-ce que vous changeriez ? Écrivez ci-dessous la PREMIÈRE chose que
vous feriez pour améliorer l’application d’Éric avant de tourner la page.
vous êtes ici 4
comment écrire un bon logiciel ?
Quelle est la PREMIÈRE chose que vous changeriez ?
Il est évident que l’application d’Éric a des problèmes, mais il est plus difficile de décider par où
commencer pour la modifier. Et il semble que les opinions ne manquent pas :
Regardez
toutes ces chaînes ! C’est
abominable... On ne pourrait
pas utiliser des constantes ou
des objets à la place ?
Whoa... ces notes
du propriétaire disent qu’il veut
que ses clients aient un large
choix. Est-ce que la méthode chercher()
ne devrait pas renvoyer une liste de
correspondances ?
Guitare
numSerie : String
prix : double
fabricant : String
modele : String
type : String
boisFond : String
boisTable : String
getNumSerie() : String
getPrix() : double
setPrix(float)
getFabricant() : String
getModele() : String
getType() : String
getBoisFond() : String
getBoisTable() : String
nt
Jacques est relativeme
mmation,
ra
og
pr
la
nouveau dans
isan
mais c’est un fervent .part
du code orienté objet
François est dans le coin
depuis un bail
et il connaît vraiment bie
n
OO et ses modèles de conc ses principes
eption.
chapitre 1
Inventaire
guitares : List
addGuitare(String, double, String, String,
String, String, String)
getGuitare(String) : Guitare
chercher(Guitare) : Guitare
Ce modèle est une
catastrophe ! Les classes
Inventaire et Guitare dépendent trop
l’une de l’autre et je ne vois pas comment
on pourrait construire quoi que ce
soit sur cette architecture. Il faut
restructurer.
on de
Julie a la réputatiac
tement
ex
r
toujours livre
ce que veut le client.
Que feriez-vous en premier ?
une appli bien conçue qui assure
Comment suis-je censé savoir par où
commencer ? J’ai l’impression qu’à chaque nouveau
projet, tout le monde a une opinion différente sur ce
que l’on doit faire en premier. Parfois j’y arrive, parfois
je finis par retravailler toute l’application parce que j’ai
commencé au mauvais endroit. Je veux juste écrire
un bon logiciel ! Alors qu’est-ce que je dois faire pour
l’application d’Éric ?
Comment
est-ce qu’on
écrit un bon
logiciel à tous
les coups ?
vous êtes ici 4
qu’est-ce que cela veut dire un bon logiciel ?
Attendez une
seconde... Je ne voudrais pas vous
interrompre, mais qu’est-ce ça veut
dire « un bon logiciel » ? C’est pas le
genre de terme vague qu’on lance
un peu en l’air ?
Bonne question... et il y a
beaucoup de réponses différentes :
Le programmeur « orienté client » dit :
« Un bon logiciel fait toujours ce que le client
veut. De sorte que même si les clients pensent à
de nouvelles façons de l’utiliser, il ne plante pas
ou ne donne pas de résultats inattendus. »
Le programmeur orienté objet dit :
Guitare
numSerie: String
prix: double
pref: PrefGuitare
getNumSerie(): String
getPrix(): double
setPrix(float)
getPref(): PrefGuitare
Inventaire
PrefGuitare
fabricant: Fabricant
modele: String
type: Type
boisFond: Bois
boisTable: Bois
guitares: Guitare [*]
addGuitare(String, double, Fabricant, String,
Type, Bois, Bois)
getGuitare(String): Guitare
chercher(PrefGuitare): Guitare [*]
getFabricant(): Fabricant
getModele(): String
getType(): Type
getBoisFond(): Bois
getBoisTable(): Bois
Fabricant
toString(): String Type
toString(): String
Bois
toString(): String
Les bons programmeurs OO
cherchent toujours à rendre
leur code plus souple.
Vous n’êtes pas certainiede?
ce que tout cela signif vous
Ne vous en faites pas... choses
apprendrez toutes ces nts.
dans les chapitres suiva
0 chapitre 1
Cette approche à
cherche uniquementient
s’assurer que le cl que
est content de ce n.
fait son applicatio
« Un bon logiciel, c’est du code orienté objet.
Donc il n’y a pas beaucoup de code dupliqué,
et chaque objet contrôle à peu près son propre
comportement. C’est aussi plus extensible
parce que votre structure est vraiment solide
et souple. »
Cette approche ce
sur la conception opnttirée
le code pour l’extensiomise
et la réutilisation et n
avantage des modèles tire
de conception et
techniques OO étabdelies
s.
Le programmeur gourou de la conception dit :
« Un bon logiciel, c’est quand vous utilisez des
modèles et des principes de conception testés et
approuvés. Vous avez gardé vos objets couplés
lâchement et votre code ouvert à l’extension, mais
fermé à la modification. Cela aide aussi à rendre
le code plus recyclable, donc vous n’avez pas à
tout retravailler pour réutiliser des parties de votre
application. »