Discussion :

[neon29200]

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:



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

[neon29200]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[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.

[b4n0u]

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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) ?

[neon29200]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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!

[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)

[neon29200]

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?

[b4n0u]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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).

[neon29200]

Exemple de test unitaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[b4n0u]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[deathness]

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

[neon29200]

Bonsoir!

Alors voilà où j'en suis:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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!

[b4n0u]

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.

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);

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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));

Quand on écrit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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()]));

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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()]));
    }
 
}

[neon29200]

Houla! Ca m'a l'air bien compliqué tout çà ^^ Je vais essayer de comprendre
Je comprends pas qu'on puisse écrire çà:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[b4n0u]

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.

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

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.

[neon29200]

Merci beaucoup!
Par contre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[b4n0u]

Par contre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

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.

[neon29200]

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

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?

[neon29200]

Je ne comprends pas bien ces deux lignes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Pourquoi le get(0)?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[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...