Discussion :

[gmalonga]

Bonjour,

Je dois réaliser un TP, et je suis bloqué à une question. C'est la suivante :

On veut permettre d'ajouter plusieurs pommes ou plusieurs poires à notre panier d'un coup en indiquant un paramètre supplémentaire à la méthode add, indiquant la quantité de pommes ou de poires que l'on veut mettre dans le panier.
L'affichage du panier devra indiquer la quantité de chaque pomme et poire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
       public static void main(String[] args) {
         var apple1 = new Apple(20, "Golden");
         var apple2 = new Apple(40, "Pink Lady");
         var pear = new Pear(5);
 
         var basket = new Basket();
         basket.add(apple1, 5);      // 5 pommes
         basket.add(apple2);
         basket.add(pear, 7);        // 7 poires
         System.out.println(basket);
       }

Modifiez le code en conséquence, sachant que pour représenter une pomme (ou une poire) et une quantité, le plus simple est de créer une classe FruitQuantity qui contient une pomme (ou une poire) et une quantité (une valeur entière).

Je ne comprends pas ce que je dois mettre dans cette classe FruitQuantity (de plus elle ne doit pas être en public c'est pour cela que je l'ai mise abstraite) sachant que j'ai déjà fais les deux méthodes add dans ma classe Basket qui ajoute bien selon les arguments :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
	public boolean add(Fruits f) {
		return basket.add(f);
	}
 
	public boolean add(Fruits f, int nb) {
		for(var i = 0; i < nb; i++) {
			basket.add(f);
		}
		return true;
         }

Pourriez-vous m'éclairer ?

Merci d'avance.

[Drowan]

Quelle est cette classe FruitQuantity dont tu nous parles ?

de plus elle ne doit pas être en public c'est pour cela que je l'ai mise abstraite

Abstraite n'a pas de lien avec public ou private.
Abstraite signifie que l'on ne peut pas instancier d'objet à partir de cette classe.
Public signifie que la classe est accessible de partout.
Private signifie que la classe n'est accessible que depuis la classe où elle est déclarée. (Il me semble que ce n'est utilisé que pour les inner Classe)

Pourquoi cette classe FruitQuantity (dont on ne sait rien) devrait ne pas être public ?

[gmalonga]

Bonjour,

Je me suis mal expliqué, je l'ai mis en abstract car cette classe ne doit pas être instanciée, elle doit juste vérifier le fruit et sa quantité.
Et justement, grâce à cette classe abstraite, je veux récupérer la quantité de chaque type de fruit dans mon panier qui est représentée par ma classe Basket. Sauf que je ne vois pas le but de créer cette classe et surtout comment récupérer les informations.
Dois-je faire une méthode abstract dans ma classe FruitQuantity ?

[Drowan]

Modifiez le code en conséquence, sachant que pour représenter une pomme (ou une poire) et une quantité, le plus simple est de créer une classe FruitQuantity qui contient une pomme (ou une poire) et une quantité (une valeur entière).

J'avais mal lu cette ligne, c'est plus clair maintenant

Je pense que si ta classe FruitQuantity doit être instanciée. Si je comprends bien elle doit représenté le couple (fruit, quantité).

Je pense que tu doit faire quelque chose comme ça :

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
public class FruitQuantity {
    private Fruit fruit;
    private int Quantity;
 
    // etc
}
 
public static void main(String[] args) {
     Fruit apple1 = new Apple(20, "Golden");
     Basket basket = new Basket();
     FruitQuantity fruitQuantity1 = new FruitQuantity(apple1, 5);
 
     basket.add(fruitQuantity1);
 
    // etc
}
 
public class Basket {
 
    // ton code deja existant
 
    public add(FruitQuantity fruitQuantity) {
        //le code qui ajoute les fruits dans ta liste
    }
}

[Yonito]

Salut !

Si j'ai bien compris l'utilite de ta class FruitQuantity alors le programme peux se construire ainsi :

Ta classe Basket serait composee de deux proprietes FruitQuantity :

Code :

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

1
2
FruitQuantitiy appleFruitQuantity = new AppleFruitQuantitiy();
FruitQuantitiy pearFruitQuantitiy = new PearFruitQuantity()

Je verrai plutot FruitQuantity comme une interface avec une fonction total() plutot qu'une classe abstraite avec une fonction abstraite total().

Bien entendu FruitQuantity aurait pour methodes :

Code :

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

1
2
abstract void add(Fruit);
abstract int total();

que les deux classes AppleFruitQuantity et PearFruitQuantity implementeraient.


Ta classe basket aurait donc une methode total() qui ferait la somme des totaux renvoyes par appleFruitQuantity.total() et pearFruitQuantity.total().


La deuxieme methode possible serait que ta classe Basket contienne une Map<FruitType, Integer> qui ferait le compte de tes fruits ajoutes au panier par type de fruit.
Dans ce cas Fruit serait une abstract classe avec une methode abstract String/Enum getType() que chaque methode derivees pourrait implementer.

Ta methode add() dans la classe Basket ressemblerait donc a :

Code :

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

1
2
3
4
5
6
7
8
public void add(Fruit fruit) {
   Integer counter = mapOfFruit.get(fruit.getType());
   if (counter != null) {
       counter++;
   } else {
      mapOfFruit.put(fruit.getType, new Integer(0));
   }
}

Je pars ici du principe dans le second exemple que nous somme dans une application single thread.

[gmalonga]

Avant tout merci pour vos réponses,

J'ai créé une classe abstract FruitQuantity dans lequel j'ai mis les fonctions :
public abstract boolean add(Fruits f)
public abstract int total()

Mais concernant la première méthode add(), dans appleFruitQuantity, comment instancier cette méthode car je n'ai pas accès à mon panier (j'ai extends ces 2 classes par FruitQuantity).

Pour plus de précision ma classe Basket est :

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
 
public class Basket {
	private final ArrayList<Fruits> basket;
 
	public Basket() {
		this.basket = new ArrayList<Fruits>();
	}
 
	public boolean add(Fruits f) {
		return basket.add(f);
	}
 
	public boolean add(Fruits f, int nb) {
		for(var i = 0; i < nb; i++) {
			basket.add(f);
		}
		return true;
	}
 
	public int totalPrice() {
		int total = 0;
 
		for(var fr : basket) {
			total += fr.price();
		}
		return total;
	}
 
	@Override
	public String toString() {
		var sb = new StringBuilder();
 
		for(var fr : basket) {
			sb.append(fr).append("\n");
		}
		sb.append("Price : ").append(totalPrice());
		return sb.toString();	
	}
}

A noter que Fruits est une interface.

Merci.

[Yonito]

Salut !

Tout d'abord je pense que ta classe Fruit doit etre une classe abstract et non pas une interface. La relation Pomme/Fruit repond a la regle "Une pomme EST UN fruit".

Tes implementations de ton interface FruitQuantity doit venir en remplacement de ta list de fruit que tu as cree dans ta classe.

Ta classe contiendrait alors une map du genre :

Code :

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

Map<FruitType, FruitQuantity> = new EnumMap(FruitType.class)

si tu souhaites travailler avec un enum en tant que key de ta map ou bien

Code :

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

Map<String, FruitQuantity> = new Hashmap<>()

si tu souhaites travailler avec le nom du fruit en tant que key ta map par example.


Tes instances de FruitQuantity serait instancier au moment de l'appelle de la fonction add(Fruit fruit) de ta classe Basket.
Si le fruit n'est pas deja present dans ta map, tu instancies alors une implementation de FruitQuantity selon le fruit a rajouter. Ton FruitQuantity aurait alors sont compteur egale a 1.
Si le fruit est deja present dans ta map, tu auras juste a incrementer le compteur de ton implementation FruitQuantity correspondante.

Ta fonction total() de Basket consisterait alors a parcourir toutes les valeurs de ta map via Map.values() puis de faire la somme de tous les compteurs internes de tes implementations FruitQuantity.