Un objet constitué d'autres objets

Version imprimable

25/02/2012, 17h49
neon29200

Un objet constitué d'autres objets

Bonjour,

Dans le cadre d'un projet java qui consiste en la gestion d'un fast-food, il me faut établir les produits disponibles à la vente. Le problème c'est que certains produits sont à l'unité (sauce, desserts), d'autres en volume (frites, boissons) et parmi ceux vendus à l'unité, il y a des produits composés (hamburgers,...) qui se composent d'ingrédients.

Voici donc le diagramme de classe sans méthodes ni variables:

http://desmond.imageshack.us/Himg208...png&res=medium

Pour les produits, pas de soucis particulier, j'ai utilisé l'héritage mais je ne vois pas comment "dire" que l'objet Produit_compose se compose d'objet Ingrédient...

Sachant que j'appelle ingrédient ce qui entre dans la constitution d'un produit composé (la frite n'est pas un ingrédient, le coca non plus, mais les cornichons, tomates, steaks oui :)

Pour l'instant on a vu les bases, l'héritage, polymorphisme, interface, méthode abstraite, exception et quelques listes (LinkedList et ArrayList).

Si quelqu'un peut m'aider à résoudre mon problème ou a des conseils pour l'architecture de mon programme je suis preneur.

Merci

En gros, est-ce qu'il est possible de créer des objets (ici Produit_compose) qui sont constitués d'autres objets (ici Ingrédient) préalablement crées?
Le truc c'est qu'en plus, 2 objets Produit_compose ne sont pas nécessairement constitués du même nombre d'objets Ingrédient...

Par exemple, mon constructeur Produit_compose:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Produit_compose extends Produit_unite { protected Ingredient Ing1 = new Ingredient(); protected Ingredient Ing2 = new Ingredient(); protected Ingredient Ing3 = new Ingredient(); public Produit_compose(String nom_produit, int prix, Ingredient Ing1, Ingredient Ing2, Ingredient Ing3){ super(); this.Ing1= Ing1; this.Ing2= Ing2; this.Ing3= Ing3; } }
Mon constructeur Ingredient:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Produit_compose extends Produit_unite { protected String nom_ingred ; protected int prix_ingred; protected int qte_ingred; // quantité de l'ingrédient en stock public Produit_compose(String nom_ingred, int prix_ingred, int qte_ingred){ this.nom_ingred= nom_ingred; this.prix_ingred= prix_ingred; this.qte_ingred= qte_ingred; } }
Est-ce possible d'appeler un objet Ingredient comme variable d'instance et dans mon constructeur de la classe Produit_compose? Je me demande aussi si la classe Produit_unite sert à quelque chose et si je ne peux pas la supprimer... Et du coup dans ma classe Produit je peux avoir un nom et un prix comme variable d'instance et tout serait plus simple.

Merci de votre aide/conseil(s)

26/02/2012, 00h09
wax78

Pour le produit composé de ingrédient : Une Liste fera l'affaire. De cette maniere un produit peut etre composé de 1 ou N ingrédients.

Je ne vais pas répondre pour la globalité de ta modélisation mais simplement sur ta question :

Citation:

En gros, est-ce qu'il est possible de créer des objets (ici Produit_compose) qui sont constitués d'autres objets (ici Ingredient) préalablement créés ?

Vu de l'extérieur (en se plaçant en tant qu'utilisateur de la classe ProduitCompose) ce que j'aurais envie d'appeler c'est un constructeur de ce type :
Code:

1 2 3 4 ProduitCompose bigMac = new ProduitCompose("Big Mac", 4.5, new Ingredient("cornichon", .3, 2), new Ingredient("tomate", .5, 1), new Ingredient("steack", 1, 1));
Pour que ton ProduitCompose contienne un nombre indéterminé d'ingrédients je te suggère l'utilisation d'une propriété java.util.List :
Code:

1 2 3 4 5 6 7 8 9 10 11 class ProduitCompose extends ProduitSimple { private List<Ingredient> ingredients; ProduitCompose(String nomProduit, double prix, Ingredient... ingredients) { super(nomProduit, prix); this.ingredients = new ArrayList<Ingredient>(); this.ingredients.addAll(ingredients); } }
Qu'est-ce que tu en penses ? Ça compile (je n'ai pas de JVM pour tester) ?

26/02/2012, 14h47
neon29200
Citation:
Envoyé par b4n0u

Vu de l'extérieur (en se plaçant en tant qu'utilisateur de la classe ProduitCompose) ce que j'aurais envie d'appeler c'est un constructeur de ce type :

Code:

1 2 3 4 ProduitCompose bigMac = new ProduitCompose("Big Mac", 4.5, new Ingredient("cornichon", .3, 2), new Ingredient("tomate", .5, 1), new Ingredient("steack", 1, 1));
Ici quand tu écris

Code:

new Ingredient("cornichon", .3, 2)

le "2" c'est la quantité de l'objet "cornichon" dans l'objet bigMac. Or, dans mon constructeur Ingredient cette variable représente la quantité totale de l'ingrédient en stock. Donc comment puis-je faire pour d'un côté avoir la quantité d'ingrédients nécessaire à la confection d'un produit composé et d'autre part la quantité de l'ingrédient en stock.
Pour résumer, la troisième variable d'instance n'a pas la même signification dans mon constructeur et lors de l'élaboration d'un nouveau produit_compose.

J'essaye tout çà au plus vite ;)

Merci pour votre aide!
26/02/2012, 16h37
tchize_

A priori, de manière visible ou pas, tu va devoir créer un objet qui associe un ingrédient à une quantité utilisée.

exemple:
new IngredientComposition(ingredient, quantité, ordreDansLaRealisation, autreChoses)
26/02/2012, 22h58
neon29200

Citation:

Envoyé par tchize_

A priori, de manière visible ou pas, tu va devoir créer un objet qui associe un ingrédient à une quantité utilisée.

exemple:
new IngredientComposition(ingredient, quantité, ordreDansLaRealisation, autreChoses)

Du coup j'aurais un objet Ingredient et un autre IngredientComposition?

Ca m'embrouille là ^^

edit: Est-ce qu'il est possible de considérer que ma variable quantite_ingredient est bien la quantité en stock, et ainsi, au lieu d'avoir un autre objet IngredientComposition comme tu le suggérais, rajouter l'objet ingrédient autant de fois que nécessaire dans la liste pour Produit_Compose. Vu qu'il n'y a jamais 36 fois le même ingrédient dans un Produit_Compose çà ne serait pas nécessairement plus fastidieux non?

Citation:

Envoyé par neon29200

Est-ce qu'il est possible de considérer que ma variable quantite_ingredient est bien la quantité en stock

C'est bien que tu évoques la notion de stock. Si j'avais à résoudre ton exercice et bien que depuis le début on ne parle que de modélisation de données et non de modélisation objet, j'aurais un objet qui représente le stock du fast food. Ainsi c'est cet objet qui permettrait de dire que j'avais 3 tomates, 2 steaks et 5 cornichons. Si je décide de créer un Big Mac alors le stock des ingrédients est réduit en conséquence.

Exemple de test unitaire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 FastFood stock = new FastFood(); stock.add(Ingredient.tomate, 3); stock.add(Ingredient.steack, 2); stock.add(Ingredient.cornichons, 5); ProduitCompose bigMac = stock.createBigMac(); assertThat(stock.get(Ingredient.tomate)).isEqualTo(1); assertThat(stock.get(Ingredient.steack)).isEqualTo(1); assertThat(stock.get(Ingredient.cornichons)).isEqualTo(3); try { ProduitCompose nouveauBigMac = stock.createBigMac(); fail(); } catch (NoMoreIngredientException e) { assertThat(e.getMessage()).isEqualTo("no more \"tomate\" in stock to cook a BigMac"); }
Du coup tes ingrédients deviennent une simple enum relié à une quantité possédant éventuellement un prix (un ingrédient n'a pas de comportement).

Citation:
Envoyé par b4n0u
Exemple de test unitaire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 FastFood stock = new FastFood(); stock.add(Ingredient.tomate, 3); // ajout de 3 tomates stock.add(Ingredient.steack, 2); // ajout de 2 steacks stock.add(Ingredient.cornichons, 5); // ajout de 5 cornichons ProduitCompose bigMac = stock.createBigMac(); assertThat(stock.get(Ingredient.tomate)).isEqualTo(1); // ? assertThat(stock.get(Ingredient.steack)).isEqualTo(1); // ? assertThat(stock.get(Ingredient.cornichons)).isEqualTo(3); // ? try { ProduitCompose nouveauBigMac = stock.createBigMac(); fail(); } catch (NoMoreIngredientException e) { assertThat(e.getMessage()).isEqualTo("no more \"tomate\" in stock to cook a BigMac"); }
Du coup tes ingrédients deviennent une simple enum relié à une quantité possédant éventuellement un prix (un ingrédient n'a pas de comportement).
Et du coup ton constructeur FastFood il ressemble à quoi?
Je piges pas trop les 3 lignes avec assertThat tu pourrais préciser?

29/02/2012, 23h19
b4n0u
Citation:

Envoyé par neon29200

Et du coup ton constructeur FastFood il ressemble à quoi?
Je piges pas trop les 3 lignes avec assertThat tu pourrais préciser?
Code:

1 2 3 4 5 private final Map<Ingredient, Integer> ingredients; FastFood() { this.ingredients = new HashSet<Ingredient, Integer>(); }
assertThat est une méthode statique de la librairie fest-assert. Elle permet d'écrire des assertions de tests lisibles. Si tu n'es pas familier avec les tests unitaires, je t'encourage à te documenter sur le sujet.

Concrètement ici, on s'assure que la quantité d'ingrédients utilisés pour createBigMac a bien diminué (2 tomates, un steak et deux cornichons).

Tu peux télécharger le code source complet si tu le souhaites. Les sources sont exportées comme un projet maven.
01/03/2012, 10h24
deathness

Les assert sont un bon moyen de vérification et font aussi office de commentaire. Au final ça aide à mieux comprendre le code.

Bonsoir!

Alors voilà où j'en suis:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class Ingredient {
 
	// Variables d'instance
 
		protected String nom_ingredient;
		protected double prix_unitaire;
		protected int quantite_ingredient;
 
		// Constructeur
 
		public Ingredient(String nom_ingredient, double prix_unitaire, int quantite_ingredient){
			System.out.println("Un nouvel ingrédient vient d'être ajouté au stock!");
			this.nom_ingredient=nom_ingredient;
			this.prix_unitaire=prix_unitaire;
			this.quantite_ingredient=quantite_ingredient;
		}
 
		// Getters
 
		public String getNomIngredient(){
			return nom_ingredient;
		}
 
		public double getPrixUnitaire(){
			return prix_unitaire;
		}
		public double getQuantiteIngredient(){
			return quantite_ingredient;
		}
 
		// Setters
 
		public void setNomIngredient(String nom_ingredient){
			this.nom_ingredient=nom_ingredient;
 
		}
		public void setPrixUnitaire(double prix_unitaire){
			this.prix_unitaire=prix_unitaire;
		}
		public void setQuantiteIngredient(int quantite_ingredient){
			this.quantite_ingredient=quantite_ingredient;
		}
 
		// Autres méthodes
 
		public String DecrisIngredient(){
			return "L'ingrédient "+this.nom_ingredient+" est au prix unitaire de "+this.prix_unitaire+" € et il y en a actuellement "+this.quantite_ingredient+" en stock";
		}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Produit { //abstract?
 
	// Variables d'instance
 
	protected String nom_produit;
	protected double prix_produit;
 
	// Constructeur par défaut
 
	public Produit () {
		this.nom_produit="";
		this.prix_produit=0;
	}
 
	// Constructeur
 
	public Produit (String nom_produit, double prix_produit) {
		this.nom_produit=nom_produit;
		this.prix_produit=prix_produit;
	}
	}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Produit_simple extends Produit {
 
	// Variables d'instance
	protected int quantite_produit;
 
	public Produit_simple(String nom_produit, double prix_produit, int quantite_produit){
		super(nom_produit, prix_produit);
		System.out.println("Un nouveau produit simple est disponible!");
		this.quantite_produit=quantite_produit;
 
	}
 
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.ArrayList;
import java.util.LinkedList;
public class Produit_compose extends Produit {
 
  protected ArrayList<Ingredient> liste_ingredient;
 
	  Produit_compose(String nom_produit, double prix_produit, Ingredient... liste_ingredient) {
		  super(nom_produit,prix_produit);
		  System.out.println("Un nouveau produit composé est disponible!");
		  this.liste_ingredient = new ArrayList<Ingredient>();
		  this.liste_ingredient.addAll(liste_ingredient);
	  }
 
}	
 
// ProduitCompose bigMac = new ProduitCompose("Big Mac", 4.5,
// new Ingredient("cornichon", .3, 2),
// new Ingredient("tomate", .5, 1),
// new Ingredient("steack", 1, 1));

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Test {
	public static void main(String[] args){
		Ingredient tomate = new Ingredient("tomate", 2.5,10);
		System.out.println(tomate.DecrisIngredient());
		Ingredient steack = new Ingredient("steack", 4,5);
		System.out.println(steack.DecrisIngredient());
		tomate.setQuantiteIngredient(60);
		System.out.println(tomate.DecrisIngredient());
		Produit_simple frite = new Produit_simple("frite",4.5,10);
 
	}
 
}

J'ai bien regardé les différents codes que vous m'avez proposé mais comme certains trucs n'ont pas encore été vu, je préfère faire comme si je ne les connaissaient pas :)

J'ai plusieurs interrogations:

-Ma classe Produit ne devrait-elle pas être déclarée abstract car je n'aurai pas d'objet Produit mais seulement des objets Produit_compose et Produit_simple?

-Je ne peux pas faire this.liste_ingredient=liste_ingredient dans mon constructeur c'est pas comme si c'était des int ou autres.

-J'aimerai qu'à chaque création d'un objet Ingredient il soit ajouté à une liste stock_ingredient.

-Quand on écrit:

Code:

1
2
3
4
 ProduitCompose bigMac = new ProduitCompose("Big Mac", 4.5,
new Ingredient("cornichon", .3, 2),
 new Ingredient("tomate", .5, 1),
 new Ingredient("steack", 1, 1));

On peut crée un nouvel objet Ingredient lorsque l'on crée l'objet Produit_compose (comme ci-dessus) mais je veux que les objets Ingredient puissent être appelé seulement s'il ont été crées au préalable (c'est-à-dire qu'ils sont dans stock_ingredient)

-J'aimerai qu'à chaque création d'un objet Produit_simple ou Produit-compose il soit ajouté à une liste produits_en_vente.

Merci de m'avoir lu jusqu'au bout!

Citation:

Envoyé par neon29200

Ma classe Produit ne devrait-elle pas être déclarée abstract car je n'aurai pas d'objet Produit mais seulement des objets Produit_compose et Produit_simple?

Oui c'est effectivement intéressant dans ce cas de passer la classe Produit abstract.

Citation:

Envoyé par neon29200

Je ne peux pas faire this.liste_ingredient=liste_ingredient dans mon constructeur c'est pas comme si c'était des int ou autres.

Ce que tu peux faire c'est transformer la propriété liste_ingredient de ArrayList<Ingredient> en List<Ingredient>. C'est d'ailleurs une bonne pratique de déclarer les types des variables sous leur forme la plus abstraite et ainsi de pouvoir affecter la liste dans le constructeur avec cet appel : this.liste_ingredient = Arrays.asList(liste_ingredient);

Citation:

Envoyé par neon29200

J'aimerai qu'à chaque création d'un objet Ingredient il soit ajouté à une liste stock_ingredient.

Si tel est ton besoin alors je te propose l'utilisation de la classe statique Ingredients :

Code:

1
2
3
List<Ingredient> tomates = Ingredients.createIngredients("tomate", 2.5, 10);
// augmenter le stock de tomates (anciennement tomate.setQuantiteIngredient(10))
tomates.addAll(Ingredient.createIngredients("tomate", 2.5, 50));

Citation:

Envoyé par neon29200

Quand on écrit:

Code:

1
2
3
4
ProduitCompose bigMac = new ProduitCompose("Big Mac", 4.5,
new Ingredient("cornichon", .3, 2),
 new Ingredient("tomate", .5, 1),
 new Ingredient("steack", 1, 1));

Avec l'objet static Ingredients, ce code se transforme en :

Code:

1
2
3
4
List<Ingredient> ingredients = Ingredients.createIngredients("cornichons", .3, 2);
ingredients.addAll(Ingredients.createIngredients("tomate", .5, 1));
ingredients.addAll(Ingredients.createIngredients("steack", 1, 1));
Produit_compose bigMac = new Produit_compose("Big Mac", 4.5, ingredients.toArray(new Ingredient[ingredients.size()]));

Citation:

Envoyé par neon29200

J'aimerai qu'à chaque création d'un objet Produit_simple ou Produit-compose il soit ajouté à une liste produits_en_vente.

Ici ça peut être la même technique que pour Ingredients.

Voici les classes modifiées :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Ingredient {
 
    protected String nom_ingredient;
    protected double prix_unitaire;
 
    Ingredient(String nom_ingredient, double prix_unitaire, Ingredients stock){
        System.out.println("Un nouvel ingrédient vient d'être ajouté au stock!");
        this.nom_ingredient=nom_ingredient;
        this.prix_unitaire=prix_unitaire;
    }
 
    public String DecrisIngredient(){
        return "L'ingrédient "+this.nom_ingredient+" est au prix unitaire de "+this.prix_unitaire+" €";
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.ArrayList;
import java.util.List;
 
/**
 * Permet de créer de nouveaux ingrédients.
 */
public final class Ingredients {
 
    /**
     * Singleton statique qui permet de ne référencer qu'une seule instance
     * de la classe Ingredients.
     */
    private static Ingredients ingredients = new Ingredients();
 
    /**
     * Liste de tous les ingrédients créés par l'intermédiaire de l'instance
     * unique d'ingrédients.
     */
    private List<Ingredient> stockIngredient;
 
    /**
     * Constructeur privé interdisant son instanciation à l'extérieur de la classe.
     */
    private Ingredients() {
        this.stockIngredient = new ArrayList<Ingredient>();
    }
 
    /**
     * Crée une nouvelle liste d'ingrédients.
     * @param ingredientType nom des ingrédients
     * @param price prix des ingrédients créés
     * @param quantity nombre d'ingrédients à créer
     * @return liste de tous les ingrédients créés
     */
    public static List<Ingredient> createIngredients(String ingredientType, double price, int quantity) {
        List<Ingredient> newIngredients = new ArrayList<Ingredient>();
        for (int i = 0; i < quantity; i++) {
            newIngredients.add(new Ingredient(ingredientType, price, ingredients));
        }
        ingredients.stockIngredient.addAll(newIngredients);
        return newIngredients;
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class Produit {
 
    protected String nom_produit;
    protected double prix_produit;
 
    protected Produit(String nom_produit, double prix_produit, ProduitsEnVente stock) {
        if (stock == null) {
            throw new IllegalArgumentException("stock cannot be null");
        }
        this.nom_produit=nom_produit;
        this.prix_produit=prix_produit;
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.Arrays;
import java.util.List;
 
public class Produit_compose extends Produit {
 
    protected List<Ingredient> liste_ingredient;
 
    Produit_compose(String nom_produit, double prix_produit, ProduitsEnVente stock, Ingredient... liste_ingredient) {
        super(nom_produit, prix_produit, stock);
        System.out.println("Un nouveau produit composé est disponible!");
        this.liste_ingredient = Arrays.asList(liste_ingredient);
    }
 
}

Code:

1
2
3
4
5
6
7
8
public class Produit_simple extends Produit {
 
    public Produit_simple(String nom_produit, double prix_produit, ProduitsEnVente stock) {
        super(nom_produit, prix_produit, stock);
        System.out.println("Un nouveau produit simple est disponible!");
    }
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import java.util.ArrayList;
import java.util.List;
 
/**
 * Référence et créée de nouveaux produits.
 */
public final class ProduitsEnVente {
 
    /**
     * Singleton de ProduitsEnVente utilisé pour référencer de manière unique
     * les produits créés par le système.
     */
    private static ProduitsEnVente produits = new ProduitsEnVente();
 
    /**
     * Liste des produits créés par ProduitsEnVente.
     */
    private List<Produit> products;
 
    /**
     * Constructeur privé qui permet à la classe de ne pas pouvoir être
     * instanciée.
     */
    private ProduitsEnVente() {
        products = new ArrayList<Produit>();
    }
 
    /**
     * Crée une liste de Produit_simple.
     * @param productName nom des produits à créer
     * @param price prix des produits
     * @param quantité nom de Produit_simple à créer
     */
    static List<Produit> createProduits(String productName, double price, int quantity) {
        List<Produit> newProducts = new ArrayList<Produit>();
        for (int i = 0; i < quantity; i++) {
            newProducts.add(new Produit_simple(productName, price, produits));
        }
        produits.products.addAll(newProducts);
        return newProducts;
    }
 
    /**
     * Crée un nouveau produit.
     * @param productName nom des produits à créer
     * @param price prix des produits
     * @param ingredients liste des ingrédients à créer. Si la liste est vide, le
     * produit sera une instance de Produit_simple. Sinon il s'agira d'un
     * Produit_compose.
     * @return nouveau produit créé.
     */
    static Produit createProduits(String productName, double price, Ingredient... ingredients) {
        Produit product;
        if (ingredients.length > 0) {
            product = new Produit_compose(productName, price, produits, ingredients);
        } else {
            product = new Produit_simple(productName, price, produits);
        }
        produits.products.add(product);
        return product;
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.List;
 
public class Test {
 
    public void main() throws Exception {
        List<Ingredient> tomates = Ingredients.createIngredients("tomate", 2.5, 10);
        System.out.println(tomates.get(0).DecrisIngredient());
        List<Ingredient> steacks = Ingredients.createIngredients("steack", 4, 5);
        System.out.println(steacks.get(0).DecrisIngredient());
        tomates.addAll(Ingredients.createIngredients("tomate", 2.5, 50));
        System.out.println(tomates.get(0).DecrisIngredient());
        Produit frite = ProduitsEnVente.createProduits("frite", 4.5, 1).get(0);
 
        List<Ingredient> ingredients = Ingredients.createIngredients("cornichons", .3, 2);
        ingredients.addAll(Ingredients.createIngredients("tomate", .5, 1));
        ingredients.addAll(Ingredients.createIngredients("steack", 1, 1));
        Produit bigMac = ProduitsEnVente.createProduits("Big Mac", 4.5, ingredients.toArray(new Ingredient[ingredients.size()]));
    }
 
}

08/03/2012, 11h50
neon29200
Houla! Ca m'a l'air bien compliqué tout çà ^^ Je vais essayer de comprendre
Je comprends pas qu'on puisse écrire çà:
Code:

1 2 3 public class ProduitsEnVente { private static ProduitsEnVente produits = new ProduitsEnVente();
On est en train de créer le constructeur de ProduitsEnVente et on a un objet ProduitsEnVente comem variable d'instance...

Si çà te dérange pas est-ce que tu pourrais commenter le code? Parce que je vois globalement ce que fait telle ou telle partie du code mais sans vraiment en comprendre le fonctionnement.

En tout cas merci beaucoup de ton aide
08/03/2012, 23h06
b4n0u
Citation:

Envoyé par neon29200

Houla! Ca m'a l'air bien compliqué tout çà ^^ Je vais essayer de comprendre

Oui j'avoue que je ne t'ai pas donné beaucoup d'explications.
Citation:
Envoyé par neon29200

Je comprends pas qu'on puisse écrire çà:

Code:

1 2 3 public class ProduitsEnVente { private static ProduitsEnVente produits = new ProduitsEnVente();

On est en train de créer le constructeur de ProduitsEnVente et on a un objet ProduitsEnVente comem variable d'instance...
En fait il ne s'agit pas d'une variable d'instance car il y a le mot clé static. On appelle ça une variable de classe. Autrement dit elle est instanciée une seule fois par le programme. Pour y accéder, il n'est pas nécessaire de faire un new ProduitsEnVente. D'ailleurs cette instruction est interdite par le mot clé private sur le constructeur. Comme expliqué dans les commentaires cela permet de créer ce que l'on appelle un singleton. Par ce mécanisme, on garantit qu'il n'existe qu'une seule et unique instance de ProduitsEnVente pour tout le programme.

Citation:

Envoyé par neon29200

Si çà te dérange pas est-ce que tu pourrais commenter le code? Parce que je vois globalement ce que fait telle ou telle partie du code mais sans vraiment en comprendre le fonctionnement.

J'ai modifié le post précédent en rajoutant des commentaires.

Merci beaucoup!
Par contre:
Code:

1 2 3 4 5 6 7 8 static List<Produit> createProduits(String productName, double price, int quantity) { List<Produit> newProducts = new ArrayList<Produit>(); for (int i = 0; i < quantity; i++) { newProducts.add(new Produit_simple(productName, price, produits)); } produits.products.addAll(newProducts); return newProducts; }
Là je piges pas pourquoi il y a produits car il ne s'agit pas du type spécifié dans mon constructeur Produit_simple mais je vois l'intérêt de cette ligne: ajouter le produit crée à la liste newProducts.

Idem pour l'autre partie en rouge: je vois pas ce qu'elle fait.

Autrement le reste c'est assez clair pour l'instant :)

Citation:
Envoyé par neon29200
Par contre:
Code:

1 2 3 4 5 6 7 8 static List<Produit> createProduits(String productName, double price, int quantity) { List<Produit> newProducts = new ArrayList<Produit>(); for (int i = 0; i < quantity; i++) { newProducts.add(new Produit_simple(productName, price, produits)); } produits.products.addAll(newProducts); return newProducts; }
Là je piges pas pourquoi il y a produits car il ne s'agit pas du type spécifié dans mon constructeur Produit_simple mais je vois l'intérêt de cette ligne: ajouter le produit crée à la liste newProducts.
Oui le troisième paramètre est un peu bidon. En fait ça ne sert à rien. Le but est simplement d'interdire l'instanciation d'un nouveau Produit_simple sans stock. Mais il est clair que ce n'est pas de la responsabilité du constructeur de Produit_simple de mettre à jour le stock. Je pense que le seul fait de passer le constructeur en visibilité package protected devrait suffire. Tu peux supprimer ce paramètre.

Citation:

Envoyé par neon29200

Idem pour l'autre partie en rouge: je vois pas ce qu'elle fait.

Là par contre c'est important : c'est cette instruction qui permet d'ajouter les produits qui viennent d'être créés dans le stock et ainsi de pouvoir les restituer par la suite, les compter, faire des statistiques dessus, etc. Pour rappel : ton stock est le singleton produits et à travers cette instance tu as accès à la liste des produits par la variable d'instance products.

09/03/2012, 19h09
neon29200

En fait c'est le design pattern singleton qu'on utilise? Je trouve pas d'explications clair sur le net.

Citation:

Oui le troisième paramètre est un peu bidon. En fait ça ne sert à rien. Le but est simplement d'interdire l'instanciation d'un nouveau Produit_simple sans stock. Mais il est clair que ce n'est pas de la responsabilité du constructeur de Produit_simple de mettre à jour le stock. Je pense que le seul fait de passer le constructeur en visibilité package protected devrait suffire. Tu peux supprimer ce paramètre.

Heu je vois pas là. le troisième paramètre de mon constructeur Ingredient c'est une quantité, je ne peux pas ne rien mettre non?
18/03/2012, 19h42
neon29200

Je ne comprends pas bien ces deux lignes:

Code:

System.out.println(tomates.get(0).DecrisIngredient());

Pourquoi le get(0)?

Code:

Produit bigMac = ProduitsEnVente.createProduits("Big Mac", 4.5, ingredients.toArray(new Ingredient[ingredients.size()]));

On crée un produit composé bigmac que l'on ajoute à ProduitsEnVente mais la fin je vois pas trop...
18/03/2012, 21h46
neon29200

C'est bon pour le get(0) c'est pour récupérer l'élément 0 de la liste mais pas pour ma 2ème interrogation...
19/03/2012, 19h53
neon29200

J'ai essayé de le faire comme ceci:

Code:

Produit bigMac = ProduitsEnVente.createProduits("Big Mac", 4.5, ingredients)

Mais Eclipse me sort une erreur alors que pourtant çà semble cohérent avec la définition de mon constructeur Produit_compose.
19/03/2012, 20h17
Robin56

Citation:

Envoyé par neon29200

Mais Eclipse me sort une erreur alors que pourtant çà semble cohérent avec la définition de mon constructeur Produit_compose.

Ça dépend de ton erreur et du type de "ingredients".
19/03/2012, 20h39
neon29200

Citation:

Envoyé par Robin56

Ça dépend de ton erreur et du type de "ingredients".

ingredients est une List composé d'objet Ingredient :)
19/03/2012, 20h46
Robin56

Citation:

Envoyé par neon29200

ingredients est une List composé d'objet Ingredient :)

Et la signature de ta méthode c'est ça :

Code:

static List<Produit> createProduits(String productName, double price, int quantity) {

Donc ça ne peut matcher, tu mets une List dans une variable qui attend une quantité en int.