Problème de redéfinition de méthode

**Dicupillo** · 09/09/2018, 18h47

Bonjour a tous, étant nouveau sur le forum je ne sais pas si mon problème rentre dans cette rubrique néanmoins j'essaye.

Je travaille sur un exercice ou je dois ajouter des légumes a une soupe, les deux légumes sont soit des carrotes soit des patates et hérite de la classe Vegetable dans laquelle est factorisé l'un de leur attributs (le poids).
Dans la classe Soup j'ai ensuite défini une méthode add pour ajouter les légumes a la soupe ( dans un tableau). Mais voila on me demande maintenant de créer une méthode donnant le poids en épluchure des légumes, sachant que le poids diffère en fonction du légumes. Le poids d'épluchure d'une carotte est 1/10 de son poids et pour celui d'une patate c'est pareil + 10 g par nbyeux (germes) La redéfinition de classe est alors conseillé, ce qui parait logique, néanmoins je ne vois pas comment mettre cela en place. Voila mon code pour illustrer(je ne met que la partie qui nous intéresse).

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
public class Carrot extends Vegetable {
	int taille;
	double PoidsCarrot;
	Carrot(double p, int t){
	         this.Poids = p;
	         this.taille = t;
public  void getPeelingWeight() {
		PoidsCarrot += this.Poids * 1/10;
	}
	}
 
public class Potatoe extends Vegetable {
	double nbyeux;
	double PoidsPotatoe;
	Potatoe(double pp, int nby){
	           this.Poids = pp;
	           this.nbyeux = nby;
	}
	Potatoe(double pp){
	           this.Poids = pp;
	           nbyeux = (int) ( (double) pp * (double) 10);
	}
        public void getPeelingWeight() {
		   PoidsPotatoe += this.Poids * (1/10) + (this.nbyeux * 10);
	}
}
 
 public abstract class Vegetable  {
	double Poids;
	double Poidst;
	abstract public  void getPeelingWeight();
 
}
 
public class Soup {
	static Vegetable[] s = new Vegetable[100];
	int count = 0;
	public void add(Vegetable b){
	         s[count] = b;
	         count += 1;
	}
        public  void getPeelingWeight(){
		 for(Vegetable t: s) {
			Vegetable.getPeelingWeight();		
		}
	}
}
 
public class Test2 {
	public static void main(String[] args) {
                s.add(new Potatoe(0.3, 10));
		s.add(new Carrot(0.25, 30));
		System.out.println(s.getPeelingWeight());
        }
}

Le problème est que dans la methode getPeelingWeight de Soup on me demande un réference static et je ne vois pas pourquoi.. Voila c'est un peu long et un peu fouillis mais j'aimerai beaucoup avoir une discussion la dessus avec vous car je veux vraiment progresser

**joel.drigo** · 10/09/2018, 12h58

Salut,

Tu obtiens ce que tu appelles une "reference static" parce que tu as écrit Vegetable.getPeelingWeight(); : ici, tu appelles une méthode static, parce que ce qui est avant le . est un nom de classe, donc la méthode est censée être static.

C'est sur l'instance que tu dois appeler cette méthode :

Code :

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

1
2
3
for(Vegetable t: s) {
			t.getPeelingWeight();		
		}

En revanche, une telle méthode devrait retourner le poids d'épluchures, et non pas void.

Tu devrais avoir quelque chose 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
public abstract class Vegetable  {
	private double weight;
        public Vegetable(double weight) {
            this.weight = weight;
        }
	public double getWeight() {
              returnd weight;
        }
	public double getWeightWithoutPeeling() {
              returnd getWeight() -getPeelingWeight();
        }
	public abstract double getPeelingWeight();
 
}

**Dicupillo** · 11/09/2018, 20h37

Tout d'abord merci pour cette réponse, j'ai appris quelque chose ! Néanmoins je me posais une question pour terminer ce programme, si la méthode getPeelingWeight doit retourner le poids total d’épluchure de carrote et de patate ; cette somme ce fait forcement dans la méthode getpeelingweight de la classe Soup en récupérant le poids des épluchures de carrote dans la méthode getpeelingweight override dans carrot et des epluchures de patates dans la méthode getpeelingweight override dans potatoe? comme ceci :

Code :

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

1
2
3
4
5
6
 public  double getPeelingWeight(){
		for(Vegetable t: s) {
			t.getPeelingWeight();
			Poidstotal = PoidsCarrot + PoidsPotatoe;
			return Poidstotal;
}

sachant que PoidsCarrot est la variable ou je stock le poids des épluchures de carrote dans la classe carrote et même principe pour poidspotatoe

**joel.drigo** · 12/09/2018, 11h38

Tu n'as pas besoin de variables pour stocker les poids de chaque légume d'une soupe, que ça soit dans la méthode, ou la classe Soup (le but dans la conception objet, c'est que chaque objet s'occupe de ce qu'il a à faire (le poids d'un légume, ça concerne ce légume, le poids d'une soupe, ça concerne la soupe et c'est la somme du poids de chaque ingrédient)). D'ailleurs, ce serait plutôt (inutilement) compliqué à gérer avec des variables spécifiques pour chaque légume, puisque la liste de légumes est variable (si on a besoin de variables intermédiaires pour ce genre de cas, on préférera un tableau, une Collection ou une Map).

Dans ton cas, tu n'as qu'un cumul à faire :

Code :

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

1
2
3
4
5
6
7
 public  double getPeelingWeight(){
                double poidsTotal = 0;
		for(Vegetable t: s) {
			poidsTotal += t.getPeelingWeight();
                }
		return poidstotal;
}

Par ailleurs, la classe Soup n'a pas forcément de méthode getPeelingWeight(). On pourrait débattre sur le bien fondé qu'on appelle getPeelingWeight() de chaque légume dans soup, mais on va supposer que c'est pour l'exercice (fonctionnellement, ça peut se défendre par ailleurs)

On peut très bien avoir ce schéma :

Code :

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

1
2
3
public abstract class Food {
     public abstract double getWeight();
}

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
public class Soup extends Food {
 
      private List<Vegetable> ingredients = new ArrayList<>();
      public Soup () {
      }  
 
      public void addIngredient(Vegetable ingredient, int qte) {
           for(int i=0; i<qte; i++ ) ingredients.add(ingredient);
      }
 
      public List<Vegetable> getIndredients() {
            return ingredients;
      } 
 
      // par défaut le poids d'une soupe est la somme du poids de chaque ingrédient - le poids des épluchures
      public double getWeight() {
          double total = 0;
          for(Ingredient ingredient : getIndredients()) { 
               total += ingredient.getWeight() - ingredient.getPeelingWeight();
          }
          return total;
      }
 
}

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 abstract class Vegetable extends Food {
 
     private double weight;
     public Vegetable(double weight) {
           this.weight=weight;
     }
 
     public double getWeight() {
            return weight;
     }
 
     public abstract double getPeelingWeight();
 
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public class Carrot extends Vegetable {
 
     public Carrot(double weight) {
           super(weight);
     }
 
     public double getPeelingWeight() {
            return getWeight()/10;
     }
 
}

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 Potato extends Vegetable {
     private int eyes;
     public Potato(double weight, int eyes) {
           super(weight); // a noter qu'il faudrait un controle d'intégrité qui impose que le weight est supérieur à eyes*10 !!!
           this.eyes=eyes;
     }
 
     public int getEyes() {
            return eyes;
     }
 
     public double getPeelingWeight() {
            return getWeight()/10+10*getEyes();  
     }
 
}

Code :

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

1
2
3
4
5
6
7
8
public static void main(String[] args) {
         Soup soup = new Soup();
         soup.addIngredient(new Carrot(100));
         soup.addIngredient(new Carrot(100));
         soup.addIngredient(new Potato(100,1));
         soup.addIngredient(new Potato(120,2));
         System.out.println("Poid de la soupe " + soup.getWeight());
}

Quand je parlais du "bien fondé qu'on appelle getPeelingWeight() dans Soup", on devrait avoir plutôt une méthode getNetWeight qui donne le poids qu'un ingrédient contribue au poids total du plat : pour un légume, ce poids net pourra être son poids brut - son poids d'épluchures, pour un autre type d'ingrédient, une autre formule. Le poids net pourra dépendre de facteurs internes ou externes au légume d'ailleurs, la cuisson (l'évaporation d'eau, la transformation chimique de certains ingrédients...), le fait qu'on fasse une soupe paysanne avec les épluchures (et/ou pépins) de certains légumes et pas d'autres, de l'association de certains ingrédients entre eux, etc. Dans ce cadre, le calcul des poids net de chaque ingrédient doit être faite par l'ingrédient, pas par la soupe. La soupe peut ajouter sa partie de formule qui dépend de la soupe elle-même mais pas de chacun de ses ingrédients.

**Rony Rauzduel** · 12/09/2018, 23h39

Pour joel.drigo, une légère correction dans ton code

Code java :

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

1
2
3
4
5
6
7
8
9
// par défaut le poids d'une soupe est la somme du poids de chaque ingrédient - le poids des épluchures
      public double getWeight() {
          double total = 0;
          for(Ingredient ingredient : getIndredients()) { 
               total += ingredient.getWeight() - ingredient.getPeelingWeight();
          }
          return total;
      }

Tu voulais probablement écrire cela :

Code java :

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

1
2
3
4
5
6
7
8
9
// par défaut le poids d'une soupe est la somme du poids de chaque ingrédient - le poids des épluchures
      public double getWeight() {
          double total = 0;
          for(Vegetable ingredient : getIndredients()) { 
               total += ingredient.getWeight() - ingredient.getPeelingWeight();
          }
          return total;
      }

Cependant ton explication est claire et limpide.