Discussion :

[Kodut]

Bonjour à tous, c'est encore moi le noob

J'aimerai pouvoir créer des objets "recette" qui soient de type ArrayList (c'est à dire un tableau d'objets si je ne me trompe pas ?) contenant les ingrédients nécessaires (ce sont des objets) et les quantités (ce sont des int). J'aimerai pouvoir instancier des recettes comme suit :

Code :

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

1
2
3
4
 
	Recette boeufcarotte = new Recette (boeuf, 1, carotte, 2);
// ici boeuf est un objet de la classe "viande" et carotte un objet de la classe "Legume"
// 1 est la quantité de boeuf nécessaire à la recette, et 2 la quantité de carottes.

j'ai créé une classe Recette mais je n'arrive pas à lui définir un ArrayList comme parametre ni de constructeur. Déja mon idée est-elle réalisable ? Quelqu'un aurait-il une meilleure idée pour créer mes recettes ? merci d'avance encore vous etes au top

[freddou17]

Slt,
Tu peux créer une classe Ingredient qui serait la super classe de Legumes et Viandes et en paramètre de recette tu passes une map<Ingredient, Integer>

Code :

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

1
2
3
4
5
 
Map<Ingredient, Integer> mesIngredients = new HashMap()
mesIngredients.put(boeuf, 1);
mesIngredients.put(carottes, 2);
new Recette (mesIngredients)//...

tu peux créer une enum ALIMENTS pour factoriser les noms d'aliments (par ex.).

ça t'aide?

Après si tu stocke tout ça en base tu peux te créer un objet IngredientParRecette qui serait le miroir de l'association n,n recette<->ingredient

Il y a plusieurs solutions...

++

[joel.drigo]

Salut,

Vu que les combinaisons d'ingrédients et de leur nombre peuvent être multiples et très variés, au lieu de faire un constructeur à Recette comme tu l'as fait (ou une série de constructeurs, pour un ingrédient, 2, 3...), tu pourrais faire une fabrique sous forme de motif constructeur :

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
public class RecetteBuilder {
 
 
 
      public RecetteBuilder() {
      }
 
      public RecetteBuilder add(Ingredient ingredient, int nombre) { // Ingredient étant par exemple une interface commune à toutes les classes d'ingrédients
           /*...*/
      }
 
      public Recette create() {
           /*...*/
      }
 
}

Ce qui te permettra de faire :

Code :

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

Recette recette = new RecetteBuilder().add(ingredien1, n1).add(ingredient2, n2).add....create();

Tu peux par exemple mettre cette classe dans le même package que Recette, et mettre un constructeur de visibilité package, par exemple avec une Map comme la indiqué @freddou17 :

Code :

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

1
2
3
4
5
6
7
8
9
public class Recette {
 
         private Map<Ingredient, Integer> ingredients;
 
         Recette(Map<Ingredient, Integer> ingredients) {
             this.ingredients=ingredients;
         }
 
}

La Map sera construite et remplie par l'instance de RecetteBuilder. Par exemple, à chaque add, on peut faire :

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
 
public class RecetteBuilder {
 
      private final Map<Ingredient, Integer> map;
 
      public RecetteBuilder() {
           map = new HashMap<>();
      }
 
      public RecetteBuilder add(Ingredient ingredient, int nombre) { // Ingredient étant par exemple une interface commune à toutes les classes d'ingrédients
           map.compute(ingredient, (i,n)-> n==null?nombre:n+nombre);
      }
 
      public Recette create() {
           return new Recette(map);
      }
 
}

[Kodut]

Alors la je vous remercie beaucoup mais je comprend rien de rien... ces notions de map et d'interface et de hashtruc j'arrive pas encore a comprendre meme en lisant un cours d'un autre site. Je crois que je vais garder ce topic de coté et revenir dessus quand je serai un peu plus à l'aise avec le code.

Désolé de pas avoir fait honneur à vos réponses mais la j'y arrive pas je veux pas vous prendre plus de temps pour ce coup-ci, je reviendrai plus tard

[joel.drigo]

Alors la je vous remercie beaucoup mais je comprend rien de rien... ces notions de map et d'interface et de hashtruc j'arrive pas encore a comprendre meme en lisant le cours d'un autre site.

Peut-être que ce serait plus clair en regardant les tutoriels Java et FAQs Java Developpez. En particulier le cours Java de JM Doudoux.

Mais rapidement :

1. une interface se déclare comme ça
   

   Code :

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

   1
   2
   3
   4
   5
   public interface MonIntefarce {
    
        void method();
    
   }

   C'est pour simplifier comme une classe, mais il n'y a que les signatures des méthodes, pas le code de ces méthodes. L'interface définit un contrat : on dit qu'on veut définir un objet qui a telles méthodes avec tels paramètres, peu importe la façon dont c'est implémenté : ce sera fait par la suite.
   Ensuite d'autres classes implémentent l'interface, au sens qu'elles disent qu'elle l'implemente :
   

   Code :

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

   public class UneClasse implements MonInterface

   et qu'elle implémente le code des méthodes de l'interface :
   

   Code :

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

   1
   2
   3
   4
   5
   6
   public class UneClasse implements MonInterface {
        public void method() {
                // l'implémentation pour cette méthode de l'interface est d'afficher "Bonjour" dans la sortie standard
                System.out.println("Bonjour");
        }
   }

   On peut également manipuler les instances de la classe UneClasse comme typées par l'interface (par exemple par une variable dont le type est MonInterface).
   Ainsi, avec une interface Ingredient toutes tes classes Boeuf, Carotte, etc, peuvent être manipulés comme si c'était une classe Ingredient.
   Tu peux aussi faire une classe Ingredient et faire que toutes tes classes Boeuf, Carotte, etc, étendent cette classe : tu pourrais manipuler également tous les objets de toutes ces classes comme si c'était de l'Ingredient (la classe héritée de toutes).
   
   Tu un cas d'usage assez couramment utilisé en Java : List. ArrayList est une classe qui implémente l'interface List. C'est pourquoi on peut écrire
   

   Code :

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

   List<String> list = new ArrayList<>();

   et qu'on le fait comme ça généralement parce que les méthodes qui nous intéressent pour la manipulation de la liste sont dans l'interface List. Si tu as déjà fait du Swing, il y a aussi ActionListener qui est très utilisé et qui montre bien l'intérêt d'avoir une sorte de "classe" mais sans le code des méthodes (qui n'est pas connu d'avance forcément).
   
2. Une map c'est juste un objet qui permet d'associer des clefs et des valeurs et qui permet de retrouver une valeur en ayant la clef : c'est donc comme un index si tu préfères.

[Kodut]

En fait dans mon cas j'ai deja une superclasse ingrédient qui est déclarée abstraite, puis des classes filles "Legume" "Viande" etc.. Boeuf est un objet de type viande, carotte est un objet de type Legume. Donc quand tu me parle de classe Boeuf ou classe carotte, c'est peut-etre chipoter de ma part mais ca me perturbe. Je vais aller approfondir tout ca et lire le cours que tu m'as conseillé, avec une reformulation et en laissant un peu murir tout ca dans ma tete je devrais pouvoir (non pas y arriver mais...) revenir avec des questions plus précises !