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 !

[joel.drigo]

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

Très bien : tu peux l'utiliser alors de la même façon que j'ai indiquée.

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.

Peu importe que tu aies fait une classe Boeuf qui étend Viande, ou que tu déclares Viande boeuf = new Viande("Boeuf"). Ceci influe juste sur les possibilités de ton modèle, mais ça ne change rien au concept qu'il y a derrière (du boeuf c'est du boeuf). Et je ne peux pas connaitre ton modèle. Et si Viande étend Ingredient, ou si Boeuf étend Viande qui étend Ingredient, ça ne change rien au fait que tu peux tout manipuler en tant que Ingredient.

[Pierre Louis Chevalier]

En fait en partant de la liste des cours et tutoriels Java, si tu as du mal pour apprendre Java, je te recommande vivement de suivre ce livre Java gratuit : Programmation Java pour les enfants, les parents et les grands-parents. C'est vraiment très bien fait, facile et ludique, il n'y à pas de meilleur cours pour apprendre facilement Java.

[Kodut]

Salut à tous, merci Pierre Louis Chevalier ce cours a l'air sympa je pense qu'il me sera bien utile.

Sinon j'ai encore galéré toute la matinée sans arriver à rien. J'ai essayé ton code Joel.Drigo en me disant qu'en le bidouillant et en le voyant a l'action ca me permettrait de mieux comprendre mais Eclipse me souligne des lignes de codes que je ne comprend pas moi meme :

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
package cuisine;
import java.util.*;
 
public class Recettebuild {
 
	private final Map<Ingred, Integer> map;
 
    public Recettebuild() {
         map = new HashMap<>();
    }
 
    public Recettebuild add(Ingred ingredient, int nombre) {  // ici "add(Ingred ingredient, int nombre)" est souligné : this methode must return a result of type Recettebuild
         map.compute(ingredient, (i,n)-> n==null?nombre:n+nombre); // que fait cette ligne ? je ne comprend pas
    }
 
    public Recette create() {
         return new Recette(map); 
    }
 
}

Si j'ai bien compris ce qui va définir mes objets Recette seront des (objets ?) Map. Dans mon code je crée une Recettebuild que je fournis avec la methode add (bien que je ne comprenne pas le code de la méthode ..?..) , puis la méthode create crée un objet de type Recette.

Je pense que j'y suis presque

edit : surtout comment faire apres pour récupérer les variables de ma recette et les utiliser dans des méthodes recette.cuisiner(nbr); par exemple boeufcarotte.cuisiner(2); me permettant de faire boeuf.qte -= recette.boeuf.qte * 2 (ou un truc du genre)
je sens que j'en ai pas terminé

[joel.drigo]

ici "add(Ingred ingredient, int nombre)" est souligné : this methode must return a result of type Recettebuild

Il manque juste le return

Code :

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

1
2
3
4
 public Recettebuild add(Ingred ingredient, int nombre) { 
         map.compute(ingredient, (i,n)-> n==null?nombre:n+nombre); 
         [highlight]return this;[/hightlight]
}

Code :

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

map.compute(ingredient, (i,n)-> n==null?nombre:n+nombre);

que fait cette ligne ? je ne comprend pas

C'est l'équivalent de

Code :

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

1
2
3
4
5
6
7
8
Integer n = map.get(ingredient);
if ( n==null ) { // l'ingredient n'était pas encore dans la map
    map.put(ingredient, nombre); // on met l'ingredient dans la map et on lui associe le nombre
}
else { // l'ingrédient était déjà dans la map avec le nombre n
   n = n + nombre; // on augment le nombre déjà ajouté avec le nouveau nombre 
    map.put(ingredient, nombre); // on associe à l'ingrédient le nouveau nombre   
}

Si j'ai bien compris ce qui va définir mes objets Recette seront des (objets ?) Map. Dans mon code je crée une Recettebuild que je fournis avec la methode add (bien que je ne comprenne pas le code de la méthode ..?..) , puis la méthode create crée un objet de type Recette.

L'objet map permet d'associer à chaque ingrédient le nombre de cet ingrédient (ce que tu indiquais dans ton constructeur dans ta première question, les valeurs 1 et 2 que tu passes en paramètres : Recette boeufcarotte = new Recette (boeuf, 1, carotte, 2);).
Ensuite oui add permet d'ajouter un ingrédient et le nombre, et la méthode create créer au final l'objet de type Recette avec tous les ingrédients ajoutés par les appels succesifs de map.

Avec l'appel écrit comme çà par exemple :

Code :

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

1
2
3
Recette boeufcarotte = new RecetteBuild().add(boeuf, 1)
                                                              .add(carotte, 2)
                                                              .create();

ou comme ça par exemple

Code :

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

1
2
3
4
RecetteBuild builder = new RecetteBuild();
builder.add(boeuf, 1);
builder.add(carotte, 2);
Recette boeufcarotte = builder.create();

On pourrait faire ça directement dans des constructeurs de Recette, mais ça t'obligerait à avoir plein de constructeurs pour 1 ingrédient, 2 ingrédients, 3 ingrédients...10 ingrédients...20...42... etc. Ceci à cause de l'alternance entre Ingred et int.

Ensuite, dans Recette tu peux faire des méthodes comme ça par exemple :

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
public class Recette {
 
         private Map<Ingred, Integer> ingredients;
 
         Recette(Map<Ingred, Integer> ingredients) {
             this.ingredients=ingredients;
         }
 
         public List<Ingred> getListeDesIngredients() {
              return new ArrayList<>(ingredients.keySet());
         }
 
        public int getNombreDe(Ingred ingred) {
              return ingredients.getOrDefault(ingred, 0);
         }
 
}

[Kodut]

Merci pour ta réponse. Comme je le craignais plus ca va plus on s'enfonce dans un code que je ne comprend pas et donc je n'arrive pas à manipuler mes objets recette ensuite... Ni pour en afficher le contenu, ni pour coder la suppression des objets correspondants avec une méthode "cuisiner". J'ai plus l'impression que tu fais le travail à ma place et mon but est l'apprentissage avant tout, ce programme n'est qu'un prétexte pour m'entrainer.

Pour te donner une idée de mon niveau je ne connais pas la syntaxe avec des <> , tu invoques des méthodes .getOrDefault que je ne connais pas non plus, des méthodes .keySet() connais pas non plus, des mots clé "final" jamais vu, des methodes qui retournent des ArrayList<> que je ne sais pas manipuler...

Donc je pense qu'il vaut mieux que j'arrete la et que je fasse un truc plus simple et que je reste "maitre" de mon programme. Je vais certainement coder les recettes sans passer par des objets et écrire le code à la main à chaque fois. Merci de ton aide encore

[thelvin]

Hello,

bon ce qu'il faut retenir, c'est que dans des paramètres, de constructeur ou de méthodes, on ne peut pas alterner autant qu'on veut un ingrédient / une quantité / un ingrédient / une quantité / un ingrédient / une quantité... sous la forme new Recette (boeuf, 1, carotte, 2) .

Comme on ne peut pas faire ça, eh ben, on fait autrement .

Il existe des millions de manière de se débrouiller, en programmation. Celle discutée ici, c'est celle quand on connaît bien Java et qu'on tombe souvent sur des cas de ce genre.
C'est pas la seule, il existe des solutions accessibles aux débutants (mais très frustrantes à causes de nombreuses lourdeurs et limitations.)