Problème dans une boucle

Version imprimable

Bonsoir, je suis encore débutant en Java (j'essaye de prendre de l'avance comme j'aurai des cours dans quelques semaines) et j'essaye de coder un petit programme de "gestion" d'une pharmacie (sans système de base de donnée, c'est majoritairement pour tester ce que j'ai appris jusqu'ici).
Bref dans une boucle while (ligne 127), je vérifie que le nombre entré par l'utilisateur (qui est l'indice de son achat), est bien dans l'intervalle possible de mon Arraylist, pour ensuite ajouter l'objet Medicament dans l'Arraylist représentant les achats du client. Une fois fait je demande si le client à acheter d'autres produits avant de relancer la boucle si le premier char est 'o' et de partir de celle-ci si le premier char est 'n'.
Seulement quand je réponds par 'o', la boucle ne se recommence pas correctement, elle demande continuellement si le client désire un autre produit au lieu de demander lequel il veut acheter. J'ai cherché pendant un petit temps déjà sans vrais résultats, je viens donc demander votre aide ici :)
Voici mon code :

Code:

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.Scanner;
//TODO add custom exception(med only letters).
public class Main {
 
	public static void main(String[] args) throws InterruptedException {
//introduction
		System.out.println("Bienvenue");
		System.out.println("Préparation");
		Thread.sleep(1000);
		System.out.println(".");
		Thread.sleep(1000);
		System.out.println(".");
		Thread.sleep(1000);
		System.out.println(".");
		Thread.sleep(1000);
		System.out.println("Ready");
		Thread.sleep(1000);
		System.out.println("===============");
		System.out.println("Vous allez maintenant devoir les données relatives à votre stock.");
		Thread.sleep(1000);
//Input MED
		ArrayList<Medicament> medList = new ArrayList();
 
		Scanner scan = new Scanner(System.in);
		boolean medRestart = true;
		int iMed = 1;
		int iMedList = 0;
 
		while(medRestart == true){
		System.out.println("Médicament numéro " + iMed+"...");
		System.out.println("Nom du médicament?");
		boolean bNomMed = true;
		String nomMed = "";
 
			while(bNomMed == true){
			try{
			nomMed =scan.nextLine();
			bNomMed = false;
			} catch(InputMismatchException e){
			System.out.println("Nom invalide.");
			scan.next();
			}
			}
		System.out.println("Prix du médicament?");
		int prixMed = -1;
 
		boolean bPrixMed = false;
			while(bPrixMed == false){
			try{
			prixMed = scan.nextInt();
			bPrixMed = true;
			} catch(InputMismatchException e) {
				System.out.println("Le prix doit être un nombre entier.");
				scan.next();
			}}
		medList.add(new Medicament(nomMed, prixMed));
 
		System.out.println("Autre medicament? (O/N)");
		scan.nextLine();
		char medRestartScan = scan.nextLine().toLowerCase().charAt(0);
		while(medRestartScan != 'o' && medRestartScan != 'n'){
		System.out.println("Veuillez répondre par 'O' ou 'N'.");
		medRestartScan = scan.nextLine().toLowerCase().charAt(0);
		}
		if(medRestartScan == 'n'){
			medRestart = false;
		}
		iMed++;
		iMedList++;
		}
//input CLIENTS INTRO
		//TODO try catch
		ArrayList<Client> cList = new ArrayList();
 
		System.out.println("Préparation");
		Thread.sleep(1000);
		System.out.println(".");
		Thread.sleep(1000);
		System.out.println(".");
		Thread.sleep(1000);
		System.out.println(".");
		System.out.println("Prêt à recevoir les clients.");
		System.out.println("====================");
		Thread.sleep(1000);
		Client c = new Client();
		boolean cRestart = true;
//CLIENT INPUT DONNEES
 
		while(cRestart ==true){
		int ic = 1;
		int icList = 0;
		System.out.println("Client numéro "+ic+"...");
		System.out.println("Nom client?");
		String nomC = scan.nextLine();
		System.out.println("Prénom client?");
		String prénomC = scan.nextLine();
		System.out.println("Ville du client?");
		String villeC = scan.nextLine();
		System.out.println("Age client?");
		boolean bMismatchAgeC = true;
		int ageC = -1;
		while(bMismatchAgeC == true){
		try{
		ageC = scan.nextInt();
		bMismatchAgeC = false;
		} catch(InputMismatchException e){
			System.out.println("L'âge doit être un nombre entier.");
			scan.nextLine();
		}}
		cList.add(new Client(nomC, prénomC, villeC, ageC));
//CLIENT ACHATS
		System.out.println("Preparation de la liste pour impression...");
		Thread.sleep(1000);
		System.out.println(".");
		Thread.sleep(1000);
		System.out.println(".");
		System.out.println("=============");
		Thread.sleep(1000);
		int iSizeCorrected = (medList.size())-1;
		for(int i = 0; i <= iSizeCorrected;i++){
			System.out.println(i+" : "+ medList.get(i).getNom());
		}
		boolean medBoughtStatus = true;
		int medBought = -1;
			while(medBoughtStatus == true){
				while(intervallContains(0, (medList.size()-1), medBought) == false){
				System.out.println("Med. acheté? (répondre par l'indice de la liste ci dessus).");
				medBought = scan.nextInt();
				}
			cList.get(icList).cMedList.add(medList.get(medBought));
			System.out.println("Autre med. acheté? (O/N)");
			scan.nextLine();
			String medBoughtStatusBis = scan.nextLine();
			char medBoughtStatusBisChar = medBoughtStatusBis.toLowerCase().charAt(0);
				while (medBoughtStatusBisChar != 'o' && medBoughtStatusBisChar != 'n')
				{
					System.out.println("Veuillez répondre par 'O' ou 'N'.");
					medBoughtStatusBis = scan.nextLine();
				}
			if(medBoughtStatusBisChar == 'n'){
				medBoughtStatus = false;
			}
			else if(medBoughtStatusBisChar == 'o'){
				medBoughtStatus = true;
			}
			}
 
//NEXT CLIENT (?)
		ic++;
		icList++;
		System.out.println("Autre client? (O/N)");
		String charC = scan.nextLine().toLowerCase();
		boolean bCharC = true;
		while(bCharC == true){
		if(charC.charAt(0) != 'n' && charC.charAt(0) != 'o'){
			System.out.println("Veuillez répondre par 'O' ou 'N'.");
			charC = scan.nextLine().toLowerCase();
		}
		else {
			bCharC = false;
		}
		}
		if(charC.charAt(0)=='n')
			cRestart = false;
 
		}
 
	}
	public static boolean intervallContains(int low, int high, int n) {
	    return n >= low && n <= high;
	}
}

La classe client :

Code:

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
import java.util.ArrayList;
 
public class Client {
private String Nom, prenom, ville;
private int age;
ArrayList<Medicament> cMedList = new ArrayList();
 
public Client (){
	this.Nom = "?";
	this.prenom = "?";
	this.ville = "?";
	this.age = -1;
}
 
public Client(String nom, String prenom, String ville, int age) {
	super();
	Nom = nom;
	this.prenom = prenom;
	this.ville = ville;
	this.age = age;
}
 
public String getNom() {
	return Nom;
}
 
public void setNom(String nom) {
	Nom = nom;
}
 
public String getPrenom() {
	return prenom;
}
 
public void setPrenom(String prenom) {
	this.prenom = prenom;
}
 
public String getVille() {
	return ville;
}
 
public void setVille(String ville) {
	this.ville = ville;
}
 
public int getAge() {
	return age;
}
 
public void setAge(int age) {
	this.age = age;
}
//arraylist gestion
public void cAddMed (Medicament med){
	cMedList.add(med);
}
 
}

Et la classe Medicament (car oui c'est une pharmacie dans mon exemple) :

Code:

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
 
public class Medicament {
private String nom;
private int prix;
 
public Medicament(){
	nom = "?";
	prix = -1;
}
 
public Medicament(String nom, int prix) {
	super();
	this.nom = nom;
	this.prix = prix;
}
 
public String getNom() {
	return nom;
}
 
public void setNom(String nom) {
	this.nom = nom;
}
 
public int getPrix() {
	return prix;
}
 
public void setPrix(int prix) {
	this.prix = prix;
}
 
 
 
 
}

Ps : ce n'est pas encore terminé c'est donc normal si je n'ai encore mis aucune action à la fin de celui-ci :)

Merci d'avance !

Salut,

Le problème dans la boucle est que tu ne réinitialises pas medBought. La première fois il vaut -1, donc le test d'intervalle est bien faux, ce qu'il fait qu'il entre bien dans le while et affiche la question. Mais à l'itération suivant sa valeur est le dernier choix fait, donc le test d'intervalle est vrai, et on entre pas dans la boucle. En résumé, chaque fois que tu vas répondre "oui" à "Autre med. acheté?", il va ajouté le premier médicament choisi.

Globalement, tu te compliques bien la vie. La méthode nextLine() ne soulèvera pas l'exception InputMistmachException : un ligne de texte est une ligne de texte, et ne peut être du mauvais type. Cette exception intervient quand tu lis du int alors qu'il n'y en a pas dans le buffer. De plus, on peut simplifier en utilisant les méthode has... qui permette de tester si le buffer contient ce qu'on veut y lire.

Tu peux simplifier tes boucles de cette manière :
Code:

1 2 3 4 5 6 7 8 9 10 11 String reponse=scanner.nextLine(); while( !"O".equalsIgnoreCase(reponse) && !"N".equalsIgnoreCase(reponse)) { System.out.print("Réponse incorrecte. Vous devez saisir soit 0, soit N. Recommencez : "); reponse=scanner.nextLine(); } if ( "O".equalsIgnoreCase(reponse) ) { System.out.println("Vous avez répondu \"oui\""); // exemple de traitement } else { System.out.println("Vous avez répondu \"non\""); // exemple de traitement }
Pour une lecture d'entier, tu peux faire :
Code:

1 2 3 4 5 6 7 8 System.out.print("Entrez un nombre : "); while ( !scanner.hasNextInt() ) { scanner.nextLine(); System.out.print("Réponse incorrecte. Vous devez saisir un nombre. Recommencez : "); } int nombre = scanner.nextInt(); System.out.println("Nombre saisi : " + nombre); scanner.nextLine(); // on vide le buffer pour la suite
Ainsi, déjà, avec cette écriture simplifié, tu n'aurais plus ton problème de réinitialisation : la valeur initiale est forcément réinitialisée implicitement par la saisie de l'utilisateur. Si tu en fais une méthode :
Code:

1 2 3 4 5 6 7 8 public static int lireNombre(Scanner scanner, String invite) { System.out.print(invite); while ( !scanner.hasNextInt() ) { scanner.nextLine(); System.out.print("Réponse incorrecte. Vous devez saisir un nombre. Recommencez : "); } return scanner.nextInt(); }
La lecture avec condition sur le nombre n'en sera que simplifiée, sans avoir à gérer de boolean, ou de valeur initialisée à -1...
Code:

1 2 3 4 5 6 7 int nombre= lireNombre(scanner, "Entrez un nombre compris entre 1 et 100 : "); while ( nombre<1 || nombre>100 ) { scanner.nextLine(); // on doit vider le buffer après avoir lu un int nombre = lireNombre(scanner, "Saisie incorrecte. Le nombre doit être compris entre 1 et 100. Recommencez : "); } System.out.println("Nombre saisi : " + nombre); scanner.nextLine(); // on vide le buffer pour la suite
D'une manière générale, découper ton programme en plusieurs méthodes va te simplifier la relecture, et donc te facilitera la résolution des bogues.

Limite le nombre de variables, en supprimant celles qui sont inutiles aussi :
Code:

1 2 3 4 int iSizeCorrected = (medList.size())-1; for(int i = 0; i <= iSizeCorrected;i++){ System.out.println(i+" : "+ medList.get(i).getNom()); }
peut s'écrire :
Code:

1 2 3 4 int iSizeCorrected = (medList.size())-1; for(int i = 0; i < medList.size() ; i++){ System.out.println(i+" : "+ medList.get(i).getNom()); }
Par ailleurs, écris ArrayList<Medicament> medList = new ArrayList<>();, pour éviter le warning (les chevrons à droite). Sinon, dans la mesure où tu n'utilises cette liste que de manière standard, autant écrire : List<Medicament> medList = new ArrayList<>();. C'est une habitude à prendre : le cas échéant, ça te permettra de modifier le type de List (par exemple, utiliser une LinkedList au lieu d'une ArrayList), sans retoucher à tout le code où le type serait référencé (en particulier en type de paramètres de méthode).

Enfin, pourquoi une méthode cAddMed (que tu aurais pu appeler plus judicieusement addMedicament), si c'est pour écrire : cList.get(icList).cMedList.add(medList.get(medBought));. En fait, la méthode c'est la bonne solution, mais appelle-là, et rends ta liste privée.

25/01/2016, 14h45
lledune

Merci beaucoup pour ta réponse détaillée :)
Je ne connaissais pas vraiment la méthode hasNext(), mais maintenant je vois que c'est bien plus simple comme ça !
Pour ce qui est du try catch pour le scan.Nextline() je m'en suis rendu compte juste après avoir fait mon post, j'essayais vraiment d'éviter à tout prix que le programme ne bug et j'ai un peu abusé sur les try catch ^^
Enfin pour la méthode que j'ai créée sans utiliser, en fait je l'avais utilisée de base, mais galérant à résoudre mon problème dans la boucle j'ai essayé de faire sans au cas ce serait ma méthode qui était mauvaise.

En tout cas super réponse grâce à laquelle j'ai appris pas mal de choses.
Par contre un petit truc que je n'ai pas compris, dans la méthode lireNombre(Scanner scan, String invite) que tu as postée, pourquoi déclares-tu celle-ci en tant que static?

Citation:

Envoyé par lledune

Par contre un petit truc que je n'ai pas compris, dans la méthode lireNombre(Scanner scan, String invite) que tu as postée, pourquoi déclares-tu celle-ci en tant que static?

Parce que :
c'est une méthode indépendante : ses paramètres lui suffisent, elle n'utilise pas de variable membre de la classe
ainsi ça évite d'avoir à créer une instance pour pouvoir l'appeler, en particulier depuis la méthode main, elle-même static
je n'ai pas vu de raison à priori d'avoir besoin de la rédéfinir dans une classe de spécialisation, dans le contexte de mon exemple. Bien sûr, on peut imaginer des implémentations où c'est envisageable, en particulier si tu dois lire de nombreuses entrées de différents types (String, int, float...) sur le même principe. Cela dit le fait de devoir systématiquement appeler nextXXX() et son pendant hasNextXXX() rendrait sa structure pas forcément très simple au regard d'une classe avec avec des méthodes statiques. En Java 8, l'introduction des lambdas permet justement d'opter pour la solution statique, la plus simple à appeler, à écrire tout en donnant un maximum de possibilités :
Code:

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 public class SystemInUtil { private static Scanner SCANNER = new Scanner(System.in); // De toute manière, il faut n'utiliser qu'une seule instance de Scanner sur System.in autant la rendre static et final // l'algo général, qui sera appelé par les autres méthodes : on évite la répétition de code private static <T> T read(String inviteMessage, String errorMessage, Predicate<Scanner> hasNext, Function<Scanner,T> next) { System.out.print(inviteMessage); while ( !hasNext.test(SCANNER) ) { SCANNER.nextLine(); System.out.format("Réponse incorrecte. %s Recommencez : ", errorMessage); } T value = next.apply(SCANNER); SCANNER.nextLine(); return value; } // pour lire un int public static int nextInt(String inviteMessage, String errorMessage) { return read(inviteMessage, errorMessage, Scanner::hasNextInt, Scanner::nextInt); } // pour lire un float public static float nextFloat(String inviteMessage, String errorMessage) { return read(inviteMessage, errorMessage, Scanner::hasNextFloat, Scanner::nextFloat); } // pour lire un mot public static String next(String inviteMessage, String errorMessage) { return next(inviteMessage, errorMessage, null); } // pour lire un mot validant une expression régulière public static String next(String inviteMessage, String errorMessage, String pattern) { return read(inviteMessage, errorMessage, scanner-> pattern==null?scanner.hasNext():scanner.hasNext(pattern), Scanner::next); } // on peut ajouter nextBoolean, nextLong, nextDouble... sur le même principe // pour tester public static void main(String[] args) { int intValue = nextInt("Entrez un nombre entier : ", "Vous devez entrer un nombre entier."); float floatValue = nextFloat("Entrez un nombre décimal : ", "Vous devez entrer un nombre décimal (utilisez , pour la virgule)."); String name = next("Entrez votre nom : ", "Votre nom doit commencer par une majuscule !", "\\p{Upper}\\S*" ); System.out.format("Vous avez saisi %d, %.2f et %s%n", intValue, floatValue, name); } }

25/01/2016, 16h13
lledune

D'accord merci à toi.
Dernière question, j'ai un peu amélioré le code et j'aimerai en faire un fichier "exécutable" (un jar exécutable en fait), y a-t-il un moyen de le faire?
Je sais comment y arriver avec la programmation événementielle, quand des fenêtres s'affichent, mais ici, vu qu'il n'y en a pas, serait-il possible de lancer ceci dans le cmd automatiquement?
25/01/2016, 16h29
joel.drigo

Citation:

Envoyé par lledune

Dernière question, j'ai un peu amélioré le code et j'aimerai en faire un fichier "exécutable" (un jar exécutable en fait), y a-t-il un moyen de le faire?

SI tu utilises Eclipse, utilises le menu "Export...", puis choisis "Runnable Jar file". En ligne de commande, voir la doc (suivre le lien https://docs.oracle.com/javase/tutor...ar/appman.html).

Citation:

Envoyé par lledune

Je sais comment y arriver avec la programmation événementielle, quand des fenêtres s'affichent, mais ici, vu qu'il n'y en a pas, serait-il possible de lancer ceci dans le cmd automatiquement?

C'est à dire "automatiquement" ? Quel rapport avec la programmation évènementielle et les fenêtres ?
Si tu fais un jar exécutable, un "double-clic" (ou équivalent selon ton os et son paramétrage) sur le jar le lance, mais ça ne fonctionnera pas avec un code qui ne fonctionne qu'en console, puisqu'il n'y a pas de console par défaut. En ligne de commandes, tu lances ton jar par java -jar tonfichier.jar (cf doc ci-dessus). Tu peux faire un fichier de commandes (.cmd ou .bat) qui lance un cmd et y exécute ton jar (ou l'équivalent en linux, avec sh). Ensuite, ce fichier de commandes peut être lancé par "double-clic".
25/01/2016, 16h35
lledune

Oui par automatiquement j'entendais qui lance la console et s'exécute dedans. Mais donc la solution serait un fichier bat je suppose.
Dedans je mets juste :
Java -jar test.jar

C'est bien ça ?
25/01/2016, 16h43
joel.drigo
Code:

1 2 @echo off cmd /C java -jar test.jar
Si tu veux que la console se ferme à la fin
Code:

1 2 @echo off cmd /K java -jar test.jar
Si tu veux que la console reste ouverte à la fin (ce qui est nécessaire s'il n'y a pas de message d'attente (message avec saisie au clavier) à la fin).

Ajoute start devant cmd si tu veux pouvoir aussi lancer cette commande en shell, et que ça t'ouvre une nouvelle console.
25/01/2016, 19h21
lledune

Ça marche merci bien :)