GKCOBJ 2j Corriges

Concepts objet
Corrigés
Concepts Objet : de la modélisation au développement
SOMMAIRE
1. DEFINITION DU PRODUIT...................................................................................... 2
1.1. REPRESENTATION UML ............................................................................... 2
1.2. CODE JAVA POUR LA CLASSE PRODUIT.................................................... 3
1.3. CODE JAVA POUR LA CLASSE TESTPRODUIT .......................................... 4
2. AGREGATION ET COMPOSITION ......................................................................... 5

2.2. DEFINITION DE LA CLASSE DENOMINATION ............................................. 6
2.3. MODIFICATION DE LA CLASSE PRODUIT ................................................... 7
2.4. MODIFICATION DE LA CLASSE TESTPRODUIT .......................................... 7
3. HERITAGE SIMPLE ................................................................................................ 9

3.2. DEFINITION DES CLASSES..........................................................................10
3.2.1. ProduitPerissable ...............................................................................10
3.2.2. ProduitSaisonnier ...............................................................................11
3.3. CLASSE TESTPRODUITS .............................................................................12
4. POLYMORPHISME ................................................................................................14
4.1. PRODUITSAISONNIER .................................................................................14
4.2. CLASSE TESTPRODUITS .............................................................................15
5. HERITAGE MULTIPLE ...........................................................................................15

5.1. CREATION DE L’INTERFACE SAISON .........................................................15
5.2. CREATION DE LA CLASSE PRODUITFUGACE ...........................................16
5.3. MODIFICATION DE LA CLASSE PRODUITSAISONNIER ............................17
5.4. MODIFICATION DE LA CLASSE TESTPRODUITS .......................................18
5.5. CREATION DE LA CLASSE TESTSAISONS .................................................20
6. COMPLEMENTS ....................................................................................................22
6.1. CLASSE PRODUITS ......................................................................................23
6.2. CLASSE TESTLISTE .....................................................................................25
© 2015 Global Knowledge Training LLC. All rights reserved 1

1. DEFINITION DU PRODUIT
Objectif : Manipulation des Classes, variables, méthodes et Objets.
Utilisation de l’encapsulation.
1.1. REPRESENTATION UML

1.2. CODE JAVA POUR LA CLASSE PRODUIT
package formation.gestionProduit;
/**
* Titre : 
* Description : 
* Copyright : Copyright (c) 2004
* Société : 
* @author non attribuable
* @version 1.0
*/
public class Produit {

private String code;
private String denomination;
private int prix;
public Produit(String code) {
this.code = code;
}
/** Constructeur attendant en argument une chaine de caractères
* permettant de renseigner le code du produit
*/
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getDenomination() {
return denomination;
}
public void setDenomination(String denomination) {
this.denomination = denomination;
public int getPrix() {

return prix;
}
public void setPrix(int prix) {
this.prix = prix;
}
}

1.3. CODE JAVA POUR LA CLASSE TESTPRODUIT
/**
* Titre : 
* @version 1.0
*/
public class TestProduit {

public TestProduit() {
}
public static void main(String[] args) {

//création du produit1
Produit produit1 = new Produit("produit100");
produit1.setDenomination("crayon de papier");
produit1.setPrix(1);
produit2.setDenomination("crayon de couleur");
//affichage du produit1
System.out.println("AFFICHAGE1: " + produit1.getCode() + " " +
produit1.getDenomination());
System.out.println("AFFICHAGE1: " + produit2.getCode() + " " + produit1.getPrix()
+ " " + produit2.getDenomination());
}
Résultat

2. AGREGATION ET COMPOSITION
Objectif : Manipulation d’un lien de composition.

2.2. DEFINITION DE LA CLASSE DENOMINATION
/**
* Titre : 
* @version 1.0
*/
public class Denomination {

private String libelleLong;
private String libelleCourt;
public Denomination() {
}
public String getLibelleLong() {
return libelleLong;
}
public void setLibelleLong(String libelleLong) {
this.libelleLong = libelleLong;
}
public String getLibelleCourt() {
return libelleCourt;
}
public void setLibelleCourt(String libelleCourt) {
this.libelleCourt = libelleCourt;
}

2.3. MODIFICATION DE LA CLASSE PRODUIT
La variable denomination passe de type String en type Denomination.

Le constructeur instancie la variable denomination.
Les méthodes get et set de la dénomination ont été modifiées pour ne plus travailler
avec des String mais avec des Denomination.
Ajout des méthodes afficheLibelle et modifLibelle
public class Produit {
private String code;
private Denomination denomination;
private int prix;
/** Constructeur attendant en argument une chaine de caractères
* permettant de renseigner le code du produit
* création de l'instance dénomination
*/
public Produit(String code) {
this.code = code;
this.denomination = new Denomination();
}
public Denomination getDenomination() {
return denomination;
}
public void setDenomination(Denomination denomination) {
this.denomination = denomination;
}
public String afficheLibelle() {
//Variable locale pour récupérer l'objet denomination
Denomination lib = this.getDenomination();
//gestion de la variable locale pour manipuler les méthodes de Denomination
return lib.getLibelleCourt() + " " + lib.getLibelleLong();
}
public void modifLibelle(String lg, String court) {
//Variable locale pour récupérer l'objet denomination
Denomination lib = this.getDenomination();
//gestion de la variable locale pour manipuler les méthodes de Denomination
lib.setLibelleCourt(court) ;
lib.setLibelleLong(lg);
}
// suite des get et set définis précédemment
}
2.4. MODIFICATION DE LA CLASSE TESTPRODUIT

Pour tester nos produits et nos dénominations, on utilise les méthodes modifLibelle
et afficheLibelle.
public class TestProduit {

public TestProduit() {
}

produit1.modifLibelle("crayon de papier mine carbone ", "crayon de papier");
produit2.modifLibelle("crayon de couleur jaune", "crayon jaune");
System.out.println("AFFICHAGE1: " + produit1.getCode() + " " +
produit1.afficheLibelle());
System.out.println("AFFICHAGE2: " + produit2.getCode() + " " + produit2.getPrix()
+ " " + produit2.afficheLibelle());
}
Résultat

3. HERITAGE SIMPLE

3.2. DEFINITION DES CLASSES
3.2.1. PRODUITPERISSABLE
import java.util.*;
/**
* Titre : 
* @version 1.0
*/
public class ProduitPerissable extends Produit {
private int dureeConservation;

private java.util.Date dateFabrication;
public ProduitPerissable(String code) {
super(code);
this.dateFabrication = new Date();
}
public int getDureeConservation() {
return dureeConservation;
}
public void setDureeConservation(int dureeConservation) {
this.dureeConservation = dureeConservation;
}
public java.util.Date getDateFabrication() {
return dateFabrication;
}
public void setDateFabrication(java.util.Date dateFabrication) {
this.dateFabrication = dateFabrication;
}
}

3.2.2. PRODUITSAISONNIER
/**
* Titre : 
* @version 1.0
*/
public class ProduitSaisonnier

extends Produit {
private String saison;

private int remiseFinSaison;
public ProduitSaisonnier(String code) {
super(code);
}
public String getSaison() {

return saison;
}
public void setSaison(String saison) {

this.saison = saison;
}
public int getRemiseFinSaison() {

return remiseFinSaison;
}
public void setRemiseFinSaison(int remiseFinSaison) {

this.remiseFinSaison = remiseFinSaison;
}

3.3. CLASSE TESTPRODUITS
public class TestProduits {
public TestProduits() {
}

ProduitPerissable produit3 = new ProduitPerissable("produit300");
produit3.modifLibelle("carton de lait contenant 6 boites", "pack de lait");
produit3.setDureeConservation(6);
ProduitSaisonnier produit4 = new ProduitSaisonnier("produit400");
produit4.modifLibelle("paire de gants en laine couleur rouge",
"gants rouges");
produit4.setRemiseFinSaison(3);
//Enregistrement des produits crées dans un tableau
Produit produits[] = new Produit[4];

produits[0] = produit1;
//Polymorphisme
for (int i = 0; i < produits.length; i++) {
System.out.println("AFFICHAGE élement " + i + " " +
produits[i].getPrix());
}
}
}

Résultat obtenu :

4. POLYMORPHISME
Objectif : Surcharge de la méthode retournant le prix.
4.1. PRODUITSAISONNIER
/**
* Titre : 
* @version 1.0
*/
public class ProduitSaisonnier
extends Produit {
super(code);
}
return saison;
}
}
}
}
//On surcharge la définition de prix pour enlever la remise
//récupération du prix
int prix = super.getPrix();
return prix - this.getRemiseFinSaison();

}
}

4.2. CLASSE TESTPRODUITS
Il n’y a rien à faire, puisqu’il y a un polymorphisme sur la méthode getPrix().
5. HERITAGE MULTIPLE
Objectif : Manipulation des interfaces et surcharge des méthodes.
5.1. CREATION DE L’INTERFACE SAISON
/**
* Titre : 
* @version 1.0
*/
public interface Saison {

public int getPrix();
public void setPrix(int prix);
public String getSaison();
public void setSaison(String saison);
public int getRemiseFinSaison();
public void setRemiseFinSaison(int remise);

}

5.2. CREATION DE LA CLASSE PRODUITFUGACE
/**
* Titre : 
* @version 1.0
*/
public class ProduitFugace extends ProduitPerissable implements Saison {
public ProduitFugace(String code) {
super(code);
}

return super.getPrix()- this.getRemiseFinSaison();
}
public void setPrix(int prix) {

super.setPrix(prix);
}

return this.saison;

}

return this.remiseFinSaison;
}
public void setRemiseFinSaison(int remise) {

this.remiseFinSaison = remise;
}

5.3. MODIFICATION DE LA CLASSE PRODUITSAISONNIER

/**
* Titre : 
* @version 1.0
*/
public class ProduitSaisonnier extends Produit implements Saison {

super(code);
}

return saison;
}

}

}

}

//On surcharge la définition de prix pour enlever la remise
//récupération du prix
int prix = super.getPrix();
return prix - this.getRemiseFinSaison();

}

5.4. MODIFICATION DE LA CLASSE TESTPRODUITS
On ajoute un nouveau produit de type ProduitFugace
public class TestProduits {
public TestProduits() {}
produit4.modifLibelle("paire de gants en laine couleur rouge", "gants rouges");
ProduitFugace produit5 = new ProduitFugace("produit500");
produit5.modifLibelle("huitre fine claire taille 2", "fine claire");
//Enregistrement des produits crées dans un tableau
Produit produits[] = new Produit[5];
//Polymorphisme
for (int i = 0; i < produits.length; i++) {
System.out.println("AFFICHAGE élement " + i + " " +
produits[i].getPrix());
}
}}

Résultat obtenu :

5.5. CREATION DE LA CLASSE TESTSAISONS
public class TestSaisons {
"gants rouges");
produit5.modifLibelle("huitre fine claire taille 2",
"fine claire");
produit6.modifLibelle("bar Breton de ligne", "bar");
produit7.modifLibelle("bonnet de laine couleur rouge", "bonnet rouge");
produit8.modifLibelle("Echarpe de laine couleur rouge", "Echarpe rouge");
//Enregistrement des produits crées dans un tableau de Saison
Saison saison[] = new Saison [5];
saison[0] = produit8;
//Polymorphisme
for (int i = 0; i < saison.length; i++) {
System.out.println("AFFICHAGE élement " + i + " remise " +
saison[i].getRemiseFinSaison() + " prix "
+ saison[i].getPrix());
}
}
}

Résultat obtenu :

6. COMPLEMENTS
Afin de mémoriser les produits à commander, on crée une classe qui contient en
variable d’instance une structure de données de type Hashtable (appartient au
java.util). On préfère la manipulation d’une structure plutôt que d’un tableau, pour
gérer de manière dynamique le nombre d’éléments à ajouter. (Un tableau est
statique). Le contenu de cette structure sera des objets de type Produit, et/ou de ses
classes filles.
Les traitements à prévoir sont :

 ajout d’un nouveau produit,
 suppression d’un produit,
 recherche de l’existence d’un produit dans la liste,
 affichage des produits existants.
Lorsque l’on ajoute ou supprime un produit, il faut vérifier que l’on traite bien un objet
Produit.
Lorsque l’on ajoute un produit, on vérifie en plus s’il n’existe pas déjà dans la liste.
On crée donc une classe nommée Produits et une classe permettant de tester
TestListe.

6.1. CLASSE PRODUITS
//importation pour la manipulation de la structure de données
import java.util.*;
public class Produits {
//Liste des produits
private Hashtable lesProduits;
//constructeur : création de l’objet structure de données.
public Produits() {
lesProduits = new Hashtable();
}
public void ajouter(Produit p) {

// si le produit est renseigné on vérifie s'il n'existe pas dans la liste
if (p != null) {
this.chercher(p.getCode());
}
// on l'ajoute s'il nexiste pas déjà
if (p != null) {
lesProduits.put(p.getCode(), p);
}
}
public void supprimer(Produit p) {

if (p != null) {
lesProduits.remove(p.getCode());
}
}
public void supprimerTout() {

lesProduits.clear();
}
public Produit chercher(String code) {

if (code != null) {
return (Produit) lesProduits.get(code);
}
else {
return null;
}
}

public String afficheInfo() {

Enumeration liste = lesProduits.elements();
Produit p;
String chaine = null;
String element = null;
while (liste.hasMoreElements()) {
p = (Produit) liste.nextElement();
element = p.getCode() + " " + p.afficheLibelle();
if (chaine == null) {
chaine = element;
}
else {
chaine += " / " + element;

}
}
if (chaine == null) {
return "Liste vide aucun produit à commander";
}
return chaine;
}
}

6.2. CLASSE TESTLISTE
public class TestListe {

public TestListe() {
}

"gants rouges");
produit5.modifLibelle("huitre fine claire taille 2",
"fine claire");

//Enregistrement des produits a commander
Produits produits = new Produits();

//ajout produit inexistant
produits.ajouter(null);
//ajout produit
produits.ajouter(produit1);
// ajout du même produit
System.out.println("AFFICHAGE " + produits.afficheInfo());
//suppression produit inexistant
produits.supprimer(null);
//suppression produit n'appartenant pas à la liste
produits.supprimer(produit2);
// ajout d'un autre produit
// vidage de la liste
produits.supprimerTout();
}
}
Résultat obtenu :
Remarque :
La méthode afficheInfo qui existe dans la classe Produits et dans la classe Client des
exemples du cours est une méthode polymorphée.

Langue

GKCOBJ 2j Corriges

Transféré par

Informations du document

Titre original

Copyright

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 :

GKCOBJ 2j Corriges

Titre original :

Transféré par

Droits d'auteur :

Concepts objet

2. AGREGATION ET COMPOSITION ......................................................................... 5

3. HERITAGE SIMPLE ................................................................................................ 9

5. HERITAGE MULTIPLE ...........................................................................................15

© 2015 Global Knowledge Training LLC. All rights reserved 1

Objectif : Manipulation des Classes, variables, méthodes et Objets.

1.1. REPRESENTATION UML

© 2015 Global Knowledge Training LLC. All rights reserved 2

1.2. CODE JAVA POUR LA CLASSE PRODUIT

public class Produit {

public int getPrix() {

© 2015 Global Knowledge Training LLC. All rights reserved 3

1.3. CODE JAVA POUR LA CLASSE TESTPRODUIT

public class TestProduit {

public static void main(String[] args) {

© 2015 Global Knowledge Training LLC. All rights reserved 4

Objectif : Manipulation d’un lien de composition.

2.1. REPRESENTATION UML

© 2015 Global Knowledge Training LLC. All rights reserved 5

2.2. DEFINITION DE LA CLASSE DENOMINATION

public class Denomination {

© 2015 Global Knowledge Training LLC. All rights reserved 6

2.3. MODIFICATION DE LA CLASSE PRODUIT

La variable denomination passe de type String en type Denomination.

2.4. MODIFICATION DE LA CLASSE TESTPRODUIT

© 2015 Global Knowledge Training LLC. All rights reserved 7

public class TestProduit {

public static void main(String[] args) {

© 2015 Global Knowledge Training LLC. All rights reserved 8

3.1. REPRESENTATION UML

© 2015 Global Knowledge Training LLC. All rights reserved 9

3.2. DEFINITION DES CLASSES

public class ProduitPerissable extends Produit {

private int dureeConservation;

© 2015 Global Knowledge Training LLC. All rights reserved 10

public class ProduitSaisonnier

private String saison;

public String getSaison() {

public void setSaison(String saison) {

public int getRemiseFinSaison() {

public void setRemiseFinSaison(int remiseFinSaison) {

© 2015 Global Knowledge Training LLC. All rights reserved 11

3.3. CLASSE TESTPRODUITS

public static void main(String[] args) {

//Enregistrement des produits crées dans un tableau

Produit produits[] = new Produit[4];

© 2015 Global Knowledge Training LLC. All rights reserved 12

© 2015 Global Knowledge Training LLC. All rights reserved 13

Objectif : Surcharge de la méthode retournant le prix.

return prix - this.getRemiseFinSaison();

© 2015 Global Knowledge Training LLC. All rights reserved 14

4.2. CLASSE TESTPRODUITS

Il n’y a rien à faire, puisqu’il y a un polymorphisme sur la méthode getPrix().

Objectif : Manipulation des interfaces et surcharge des méthodes.

5.1. CREATION DE L’INTERFACE SAISON

public interface Saison {

public void setPrix(int prix);

public String getSaison();

public void setSaison(String saison);

public int getRemiseFinSaison();

public void setRemiseFinSaison(int remise);

© 2015 Global Knowledge Training LLC. All rights reserved 15

5.2. CREATION DE LA CLASSE PRODUITFUGACE

public int getPrix() {