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

une appli bien conçue qui assure 1
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 difcile 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 ni ce chapitre, vous saurez comment
écrire un bon logiciel et vous aurez fait un grand pas en avant pour
améliorer dénitivement le développement de vos applications. Pour nir, vous
comprendrez pourquoi vous avez tout intérêt à connaître l’ACOO.
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 !
voici un nouveau chapitre 1

2 chapitre 1
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.
le son du bois et des cordes
Nous vous proposons un
choix hallucinant. Entrez, dites-
nous quel genre de guitare vous
aimez et nous vous trouverons
l’instrument parfait, c’est garanti !
Voici Éric, aficionado de la guitare
et propriétaire d’un magasin de
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.
Voici Éric, aficionado de la guitare

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 :
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
Inventaire
guitares : List
addGuitare(String, double, String, String,
String, String, String)
getGuitare(String) : Guitare
chercher(Guitare) : Guitare
Éric a décidé que les attributs qui
définissent une guitare sont : le numéro de
série, le prix, le fabricant et le modèle, le
type (acoustique ou électrique) et les bois
utilisés pour la guitare.
Chaque guitare de
l’inventaire d’Éric est
représentée par une
instance de cette classe.
Voici l’inventaire complet
d’Éric, ainsi qu’un moyen de
chercher des guitares.
Cette
méthode
rentre tous
les détails
d’une guitare,
crée un objet
Guitare et
l’ajoute à
l’inventaire
d’Éric.
Cette méthode
prend le numéro de
série d’une guitare
et renvoie l’objet
de cette guitare.
C’est la méthode de recherche ;
elle prend la guitare idéale d’un
client et renvoie une guitare de
l’inventaire d’Éric qui correspond
aux critères du client.
L’inventaire conserve une
liste de toutes les guitares
qu’Éric a à disposition.
Voici les
variables
de la classe
Guitare.
Ce sont les
méthodes
pour la classe
Guitare.
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 n du livre et lisez l’Annexe B, vous ne le regretterez pas. Puis revenez à
cette page et tout sera beaucoup plus clair pour vous.
Encapsulation
Héritage
Polymorphism
une application bien conçue qui assure
vous êtes ici 4 3
Nouveau à Objectville ?
Nous avons une petite
surprise à votre attention
dans l’Annexe B. Jetez-y
un œil avant de continuer si
l’UML ou la programmation
OO sont nouveaux pour vous.

4 chapitre 1
public class Guitare {
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;
this.fabricant = fabricant;
this.modele = modele;
this.type = type;
this.boisFond = boisFond;
this.boisTable = boisTable;
}
public String getNumSerie() {
return numSerie;
}
public double getPrix() {
return prix;
}
public void setPrix(float nouveauPrix) {
this.prix = nouveauPrix;
}
public String getFabricant() {
return fabricant;
}
public String getModele() {
return modele;
}
public String getType() {
return type;
}
public String getBoisFond() {
return boisFond;
}
public String getBoisTable() {
return boisTable;
}
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.
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
getBoisFond() : String
getBoisTable() : String
class
Guitare
{
Gui-
tare()
}
Guitare.java
Ce sont toutes les
propriétés que nous
avons vues dans le
diagramme de classe
pour la classe Guitare.
Les diagrammes de classes UML ne
montrent pas les constructeurs ; le
constructeur de Guitare ne fait
cependant rien d’exceptionnel : il met
en place toutes les propriétés initiales
pour une nouvelle Guitare.
Vous pouvez voir
que le diagramme de
classe correspond
bien aux méthodes
du code de la classe
Guitare.
le début du code de l’application d’Éric

une appli bien conçue qui assure
vous êtes ici 4 5
public class Inventaire {
private List guitares;
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);
guitares.add(guitare);
}
public Guitare getGuitare(String numSerie) {
for (Iterator i = guitares.iterator(); i.hasNext(); ) {
Guitare guitare = (Guitare)i.next();
if (guitare.getNumSerie().equals(numSerie)) {
return guitare;
}
}
return null;
}
public Guitare chercher(Guitare chercherGuitare) {
for (Iterator i = guitares.iterator(); i.hasNext(); ) {
Guitare guitare = (Guitare)i.next();
// Ignore le numéro de série puisqu’il est unique
// Ignore le prix puisqu’il est unique
String fabricant = chercherGuitare.getFabricant();
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();
if ((boisFond != null) && (!boisFond.equals(“”)) &&
(!boisFond.equals(guitare.getBoisFond())))
continue;
String boisTable = chercherGuitare.getBoisTable();
if ((boisTable != null) && (!boisTable.equals(“”)) &&
(!boisTable.equals(guitare.getBoisTable())))
continue;
}
return null;
}
}
Inventaire
guitares : List
addGuitare(String, double, String,
String, String, String, String)
getGuitare(String) : Guitare
chercher(Guitare) : Guitare
class
Inven-
taire {
cher-
cher()
Inventaire.java
Et Inventaire.java...
Attention, nous avons retiré les
déclarations d’importation pour
économiser de l’espace.
addGuitare() réunit tous
les attributs requis pour
créer une nouvelle instance
de Guitare, la crée et
l’ajoute à l’inventaire.
Cette méthode est un peu en
fouillis... Elle compare chaque
attribut de l’objet Guitare dans
lequel elle passe à chaque objet
Guitare dans l’inventaire d’Éric.