Discussion :

[lledune]

Bonjour,
Je souhaite créer un petit programme qui permettrait de simuler un magasin.
J'ai donc commencé par la classe relative aux données des clients, et je rencontre un problème que je n'arrive pas à résoudre :/
Pour l'âge du client, peu importe celui que je rentre, la donnée qu'il me ressort à la fin est -1. (soit la donnée par défaut de ma classe client). J'ai essayé en int et en double, aucun des deux ne résout le problème.
Je suis un pur débutant en programmation et je suis donc venu chercher de l'aide ici, j'espère que vous pourrez m'aidez à résoudre ce problème qui me donne envie de m'arracher les cheveux...
Donc voilà ma classe main :

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
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
 import java.util.ArrayList;
import java.util.Scanner;
public class main {
 
	public static void main(String[] args) {
//-----------------------------------------------------------------------------
		ArrayList listeClients = new ArrayList();
		Scanner ss = new Scanner(System.in);
		Scanner si = new Scanner(System.in);
		Scanner sd = new Scanner(System.in);
		Scanner sb = new Scanner(System.in);
		double age;
		String nom = "";
		String commune ="";
		double tarif = 0;
		boolean restart = true;
		boolean tf;
//----------------------------------------------------------------------
		while (restart==true)
		{
			System.out.println("Age du client?");
			age = sd.nextDouble();
			System.out.println("Nom du client?");
			nom = ss.nextLine();
			System.out.println("Commune du client?");
			commune = ss.nextLine();
			System.out.println("Tarif client?");
			tarif = sd.nextDouble();
			Client addClient = new Client(age, nom, commune, tarif);
			listeClients.add(addClient);
			addClient.setAgeClient(age);
			System.out.println("Introduire un autre client?(true/false)");
				tf = sb.nextBoolean();
				if (tf == false)
				{
					restart = false;
				}
		}
//------------------------------------------------------------------------
		System.out.println("Souhaitez vous revoir un client en particulier?(true/false)");
		boolean revoirClients = sb.nextBoolean();
		boolean revoirTousClients;
		Client allTemp = new Client();
		int iFocus = 0;
		int iAll=0;
		if (revoirClients == true)
		{
			System.out.println("Quel est le numéro du client que vous souhaitez revoir? (En commençant à 0)");
			System.out.println("Pour rappel vous avez enrengistré "+listeClients.size()+" client(s).");
			iFocus = si.nextInt();
			Client focus = (Client) listeClients.get(iFocus);
			printClient(focus);
		}
		else if (revoirClients == false)
		{
			System.out.println("Souhaitez vous revoir tous les clients?(true/false)");
			revoirTousClients = sb.nextBoolean();
			if (revoirTousClients == true)
			{
				while(iAll < listeClients.size())
				{
					allTemp = (Client) listeClients.get(iAll);
					printClient(allTemp);
					iAll = iAll+1;
				}
			}
			else if(revoirTousClients==false)
			{
				System.out.println("Au revoir !");
			}
		}
 
 
//------------------------------------------------------------------------
 
 
//-----------------------------------------------------------------------------
 
 
 
 
 
 
 
 
 
	}
 
	public static void printClient(Client client)
	{
		double age = Client.getAgeClient();
		System.out.println("Monsieur/madame "+client.getNomClient()+", originaire de la commune de "+client.getCommuneClient()+" et agé(e) de "+age+" ans, nous doit "+client.getTarifClient()+" euros.");
	}
}

Et ma classe Client :

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
public class Client {
 
	private static double ageClient;
	private String nomClient;
	private String communeClient;
	private double tarifClient;
	//----------------------------------------------------------
		public Client()
		{
			ageClient = -1;
			nomClient = "inconnu";
			communeClient = "inconnue";
			tarifClient = 0;
		}
	//-----------------------------------------------------------
		public Client(double pAgeClient, String pNomClient, String pCommuneClient, double pTarifClient)
		{
			ageClient = pAgeClient;
			nomClient = pNomClient;
			communeClient = pCommuneClient;
			tarifClient = pTarifClient;
		}
	//---------------------------------------------------------------
		//GET
		public static double getAgeClient()
		{
			return ageClient;
		}
 
		public String getNomClient()
		{
			return nomClient;
		}
 
		public String getCommuneClient()
		{
			return communeClient;
		}
 
		public double getTarifClient()
		{
			return tarifClient;
		}
 
	//------------------------------------------------------------------
		//SET
		public void setAgeClient(double newAge)
		{
			ageClient = newAge;
		}
 
		public void setNomClient(String newName)
		{
			nomClient = newName;
		}
 
		public void setCommuneClient(String newCommune)
		{
			communeClient = newCommune;
		}
 
		public void setTarifClient(double newTarif)
		{
			tarifClient = newTarif;
		}
	//-------------------------------------------------------------------
 
 
 
 
 
 
 
}

[joel.drigo]

Salut,

Code :

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

private static double ageClient;

Une variable static est partagée en toutes les instances de l'objet. Donc tous les clients ont le même age : à chaque création d'un nouveau client, comme l'age est initialisé à -1, tout le monde à -1, puis on affecte une valeur et tous les clients ont ce même age. Si tous tes clients ont -1 à la fin, c'est à cause de la ligne Client allTemp = new Client();, qui ne sert strictement à rien.

Donc enlève le mot static sur la déclaration de variable, puis sur l'accesseur getAgeClient.

Au sujet de :

Code :

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

1
2
3
4
5
public static void printClient(Client client)
	{
		double age = Client.getAgeClient();
		System.out.println("Monsieur/madame "+client.getNomClient()+", originaire de la commune de "+client.getCommuneClient()+" et agé(e) de "+age+" ans, nous doit "+client.getTarifClient()+" euros.");
	}

La notation Client.getAgeClient();, c'est-à-dire avec le nom de la classe avant le ., est justement celle pour appeler une méthode statique : il faut que tu modifies ça pour appeler la méthode sur l'instance de client :

Code :

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

client.getAgeClient();

Au sujet de la déclaration de allTemp, supprime la ligne Client allTemp = new Client(); et déclare-le ici :

Code :

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

1
2
3
Client allTemp = (Client) listeClients.get(iAll);
printClient(allTemp);
iAll = iAll+1;

Il vaut mieux toujours déclarer une variable dans un scope (portée, visibilité...) limité à son usage (ici le scope est le bloc de la boucle while (le bloc ci-dessus donc).

A noter, que si tu déclares ta liste comme ça ArrayList<Client> listeClients = new ArrayList<>();, tu n'auras plus besoin de caster :

Code :

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

Client allTemp = /*(Client)*/ listeClients.get(iAll);

Le cast(ce que j'ai commenté et surligné) peut être supprimé.

Enfin, utilise une seule instance de Scanner. C'est inutile d'avoir 4 scanners. En plus cette classe est bufferisée, et donc peut lire des caractères d'avance, ce qui pourra causer des bugs (des saisies qui ne seront pas prises en compte, ou prises en compte au mauvais endroit) : dans tout programme, prend l'habitude de n'utiliser qu'une seule instance de Scanner.

[lledune]

Merci beaucoup pour la réponse rapide et complète !
J'ai fait ce que tu m'as dit et le programme fonctionne maintenant à merveille.
J'aurai cependant deux autres petites questions
Premièrement, j'envisage par la suite de créer une classe "Article", qui servirait à associer à chaque client les articles qu'ils aurait acheté, et éventuellement déterminer le tarif en fonction de cela.
Je pensais modifier la liste lient pour qu'elle soit comme ceci : {{Client 1, article1, article2},{..},{..},...};
Est-ce possible avec une arraylist?

Deuxièmement, j'ai essayé de créer un .jar avec eclipse, pour pouvoir lancer le programme directement, mais il ne dispose pas d'interface graphique et donc rien ne s'affiche, existe-t-il un moyen d'utiliser la console via ce .jar?

Merci d'avance !

[joel.drigo]

Premièrement, j'envisage par la suite de créer une classe "Article", qui servirait à associer à chaque client les articles qu'ils aurait acheté, et éventuellement déterminer le tarif en fonction de cela.
Je pensais modifier la liste lient pour qu'elle soit comme ceci : {{Client 1, article1, article2},{..},{..},...};
Est-ce possible avec une arraylist?

Oui et non. En fait, ce n'est pas la bonne solution de faire une seule ArrayList avec clients et articles : c'est trop lourd à gérer.
Comme pour n'importe quel attribut, si un client a une liste d'articles, il suffit de lui ajouter un attribut liste d'articles, donc une variable de type List<Article>.

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 Client {
 
	private double ageClient;
	private String nomClient;
	private String communeClient;
	private double tarifClient;
	private List<Article> articles = new ArrayList<>();
 
    /* ... */
 
    public void ajouterArticle(Article article) {
         articles.add(article);
    }
 
    public List<Article> getArticles() {
          return articles;
    }

Attention, avec ce getArticles(), on peut modifier la liste d'articles à l'extérieur de la classe, ce que tu veux peut-être empêcher. Dans ce cas :

Code :

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

1
2
3
4
 
    public List<Article> getArticles() {
          return Collections.unmodifiableList(articles);
    }

Deuxièmement, j'ai essayé de créer un .jar avec eclipse, pour pouvoir lancer le programme directement, mais il ne dispose pas d'interface graphique et donc rien ne s'affiche, existe-t-il un moyen d'utiliser la console via ce .jar?

Merci d'avance !

Si c'est un jar exécutable, ouvre une console, et exécute-le en tapant la commande : java -jar tonjar.jar

[lledune]

D'accord merci, je vais bosser donc j'essaierai ça ce soir
Et pour le prix des articles?
Je suppose que je renseigne dans main ?
Par exemple : Article classeur = new Article(prixunitaire, quantité).
Dans ce cas lors de l'impression des clients, comment déterminer que chaque client possède tel nombre d'articles ? (pour pouvoir déterminer le tarif).

[joel.drigo]

D'accord merci, je vais bosser donc j'essaierai ça ce soir
Et pour le prix des articles?
Je suppose que je renseigne dans main ?
Par exemple : Article classeur = new Article(prixunitaire, quantité).

Par exemple (avec les attributs pour la classe Article pour stocker ces informations) et client.ajouterArticle(classeur); pour l'affecter au client

Dans ce cas lors de l'impression des clients, comment déterminer que chaque client possède tel nombre d'articles ? (pour pouvoir déterminer le tarif).

Le nombre d'articles, c'est la taille de la liste : articles.size()Pour parcourir les articles pour les afficher, par exemple :

Code :

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

1
2
3
for( Article article : articles ) {
   System.out.println(article);
}

ou (Java8)

Code :

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

articles.forEach( System.out::println );

Si c'est la somme totale dont tu as besoin, tu peux faire :

Code :

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

1
2
3
4
5
double total=0;
for( Article article : articles ) {
   total += article.getQuantite() * article.getPrixUnitaire();
}
System.out.println("Prix total " + total);

ou (Java8) :

Code :

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

1
2
3
double total = articles.stream()
                       .mapToDouble(article-> article.getQuantite()*article.getPrixUnitaire())
                       .sum()

ou (Java8)

Code :

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

1
2
3
4
double total = articles.stream()
                       .map(article-> article.getQuantite()*article.getPrixUnitaire())
                       .reduce((s, v)-> s + v)
                       .orElse(0d);

[lledune]

Ok merci à toi
Une dernière petite chose (je sais je suis embêtant), est-ce que la création d'un système de sauvegarde serait relativement simple ? J'aimerais bien en faire un mais comme je suis vraiment débutant je ne sais pas si j'en serai capable :/

[joel.drigo]

Système de sauvegarde veut tout dire et rien à dire à la fois. On peut sauvegarder de maintes manières : base de données (ou autre système de persistence, comme hibernate par exemple), fichiers binaires ou texte (structurés (xml, json, yaml...) ou pseudo structurés (csv)), fichier unique ou fichiers multiples, sérialisation...

Le plus simple, dans ton cas (si tu ne multiplies pas trop le nombre d'objets différents), c'est le fichier unique. Mais ça peut être lourd à gérer s'il y a beaucoup de données, en particulier les ajouts et les suppressions : il faudra juste tout charger d'un coup, faire les modifications en mémoire, puis tout sauvegarder d'un coup. Ce qui a l'avantage d'être très simple.

Le plus simple, mais pas forcément sur certains aspects (ça dépend des données), c'est le fichier texte. Il a le défaut que les données sont en clair, et surtout éditables dans un éditeur de texte, donc on peut facilement tout bousiller et que le fichier ne soit plus lisible. Dans les fichiers textes, il faut faire attention à 2 choses principalement :

• pouvoir retrouver les données isolées les unes des autres (parsage) : le format peut nous aider à gérer ça directement. Par exemple, le format xml intègre directement ces notions. Ce n'est pas très complexe à gérer même quand on est débutant, d'autant plus qu'il y a de nombreuses API. Le format CSV est beaucoup plus simple à écrire et à lire, mais il faut gérer soit même les problématiques liées au parsage (en particulier en échappant les caractères de séparation). Tu pourras aussi plus facilement le passer sous excel.
• pouvoir gérer les liens entre données (et par extension, les notions éventuelles de hiérarchie), ce qui implique d'abord un moyen de repérer une instance d'objet (identifiant unique). Dans ton cas, la question est de savoir si une même instance d'article peut appartenir à 2 clients différents. Sinon, ou si le cas échéant, on peut dupliquer ces articles pour revenir à cette situation, on peut complètement se passer d'identifiant.

L'alternative binaire à ce que je viens de dire n'est pas beaucoup plus compliquée, mais l'avantage du fichier texte et qu'on peut plus facilement regarder dedans si on sauvegarde bien. Quand on débute, c'est tout de même bien pratique.

Donc avant toute chose, choisir un format (XML ou CSV). Ensuite je pourrais te guider vers les tutoriels concernés.

[lledune]

D'après ce que tu m'as dit je suis plus tenté par le xml.
Surtout que j'ai l'impression de voir ce format assez souvent sur mon ordinateur.

[joel.drigo]

Pour le XML, il y a plusieurs alternatives :

• SAX
• StAX
• DOM
• Les systèmes basés sur xml, gérant du mapping (comme castor par exemple) - trop compliqué pour un débutant, à mon avis.

SAX et StAX sont plutôt dédiés à de gros fichiers, lorsqu'on veut éviter de trop consommer de la mémoire. Personnellement, j'ai un petit faible pour StAX, même pour les petits fichiers, en particulier les fichiers de configuration.

Mais il est peut-être plus simple quand on débute, d'utiliser DOM, même s'il y a des aspects pas si évident que ça à voir certaines discussions sur ce forum. Malheureusement, l'API DOM fournie en standard avec Java présente certains aspects un peu rugueux et il est beaucoup plus simple pour un débutant d'aborder DOM avec l'API JDOM (JDOM2 exactement).

Ce qui demande :

• de télécharger le jar et de l'ajouter à ton projet (à son classpath)
• à regarder ce tutoriel, pour commencer. Attention, il s'agit d'un tutoriel basé sur l'ancienne version : pour l'utiliser avec la nouvelle version de JDOM, il suffit de remplacer les packages org.jdom par org.jdom2, en gros. (Il y a aussi ce tutoriel, également pour l'ancienne version)
• Et puis tu pourras toujours revenir sur ce forum en cas de difficulté

[lledune]

D'accord merci à toi pour l'aide, c'est vraiment sympa

[adiGuba]

Salut,

Pour le XML, il y a plusieurs alternatives :

Pour la sauvegarde dans un fichier il y a une solution encore plus simple, et en standard dans l'API standard : XmlEncoder

Certes cela génère un XML très verbeux et pas forcément optimisé, mais il se compresse très bien.

Et puis cela se code en deux-deux à partir du moment où l'on utilise bien les getter/setter :

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 static void saveGzipXmlObject(String fileName, Serializable object)
			throws IOException {
		try (OutputStream os = new FileOutputStream(fileName);
				GZIPOutputStream gzip = new GZIPOutputStream(os);
				XMLEncoder xml = new XMLEncoder(gzip)) {
			xml.writeObject(object);
		}
	}
 
	@SuppressWarnings("unchecked")
	public static <T> T readGzipXmlObject(String fileName) throws IOException, ClassNotFoundException {
		try (InputStream is = new FileInputStream(fileName);
				GZIPInputStream gzip = new GZIPInputStream(is);
				XMLDecoder xml = new XMLDecoder(gzip)) {
			return (T)xml.readObject();
		}
	}

a++

[joel.drigo]

Certes cela génère un XML très verbeux et pas forcément optimisé, mais il se compresse très bien.

Pour le coup, si c'est pour avoir un fichier texte imbittable, avec 75% d'informations purement structurelles, on perd le seul intérêt du fichier texte (avec la portabilité) : la lisibilité (surtout si en plus, on le compresse). Disons qu'on tape moins de code, mais je suis dubitatif sur le gain en simplicité.
Surtout pour gérer les évolutions des objets par la suite.

Par contre, il me semblait qu'on pouvait utiliser XMLEncoder sur des objets non serializables (l'histoire du "DefaultPersitenceDelegate") ?

[lledune]

Me revoila.. encore ^^

Je ne me suis pas encore attaqué au xml, je suis encore en train d'améliorer mon programme et je suis tombé sur un nouveau prolème (encore un), je n'arrive pas à exprimer le tarif du client en fonction de ses achats.
Si je garde le tarif que l'on mets en tant que paramètre du client, alors tout fonctionne bien, mais dès que j'essaye d'utiliser les composant de la liste d'achat et d'utiliser leur prix (que je configure dans une nouvelle classe medicament), alors j'obtiens soit des erreurs, soir le programme ne se lance carrément pas.

Je remets mon code mis à jour ici.
Pour la classe main c'est après le ligne 124 que le problème doit survenir.
Main :

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
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
 
import java.util.ArrayList;
import java.util.Scanner;
public class main {
 
	public static void main(String[] args) {
 
//-----------------------------------------------------------------------------Déclaration des variables
		ArrayList<Client> listeClients = new ArrayList<Client>();
		ArrayList<Medicament> listeMedicaments = new ArrayList<Medicament>();
		Scanner ss = new Scanner(System.in);
		Scanner si = new Scanner(System.in);
		Scanner sd = new Scanner(System.in);
		Scanner sb = new Scanner(System.in);
		double age;
		String nom = "";
		String commune ="";
		double tarif = 0;
		boolean restart = true;
		boolean tf;
		boolean restartMed = true;
		boolean tfMed;
		boolean tfRevoirMed;
//---------------------------------------------------------------------- Demander les différents médicaments disponibles
		System.out.println("Vous allez maintenant être invités à introduire les différents médicaments disponibles dans la pharmacie.");
		while (restartMed == true)
		{
			System.out.println("Nom du medicament?");
			String nextMedName = ss.nextLine();
			System.out.println("Prix du médicament?");
			double nextMedPrice = sd.nextDouble();
			Medicament addMed = new Medicament(nextMedName, nextMedPrice);
			listeMedicaments.add(addMed);
			System.out.println("Voulez vous introduire un autre médicament ?(true/false)");
			tfMed = sb.nextBoolean();
			if(tfMed == true)
			{
				restartMed = true;
			}
			else if(tfMed ==false)
			{
				restartMed = false;
				System.out.println("Voulez-vous revoir les médicaments encodés?(true/false)");
				tfRevoirMed = sb.nextBoolean();
				if (tfRevoirMed == true)
				{
					int iRevoirMed = 0;
					while (iRevoirMed<listeMedicaments.size())
					{
						System.out.print(listeMedicaments.get(iRevoirMed).getNomMedicament()+", ");
						System.out.println(listeMedicaments.get(iRevoirMed).getPrixMedicament()+" euros.");
						iRevoirMed = iRevoirMed+1;
					}
				}
				else if(tfRevoirMed == false);
				{
					//on ne fait rien.
				}
 
 
 
			}
		}
//----------------------------------------------------------------------On demande les différents clients.
		System.out.println("Vous allez maintenant être invité à encoder les diférents clients.");
		while (restart==true)
		{
			System.out.println("Age du client?");
			age = sd.nextDouble();
			System.out.println("Nom du client?");
			nom = ss.nextLine();
			System.out.println("Commune du client?");
			commune = ss.nextLine();
			System.out.println("Tarif client?");
			tarif = sd.nextDouble();
			Client addClient = new Client(age, nom, commune, tarif);
			listeClients.add(addClient);
			addClient.setAgeClient(age);
			System.out.println("Introduire un autre client?(true/false)");
				tf = sb.nextBoolean();
				if (tf == false)
				{
					restart = false;
				}
		}
//------------------------------------------------------------------------ On veut revoir les clients ?
		System.out.println("Souhaitez vous revoir un client en particulier?(true/false)");
		boolean revoirClients = sb.nextBoolean();
		boolean revoirTousClients;
		boolean revoirTarif;
		int iFocus = 0;
		int iAll=0;
		if (revoirClients == true)
		{
			System.out.println("Quel est le numéro du client que vous souhaitez revoir? (En commençant à 0)");
			System.out.println("Pour rappel vous avez enrengistré "+listeClients.size()+" client(s).");
			iFocus = si.nextInt();
			Client focus = (Client) listeClients.get(iFocus);
			printClient(focus);
			System.out.println("Voulez-vous voir le vrai tarif du client?(true/false)");
			revoirTarif = sb.nextBoolean();
			if (revoirTarif == true)
			{
				int iClientNumber = iFocus;
				listeClients.get(iClientNumber).realTarif(listeClients.get(iClientNumber));
			}
			else if(revoirTarif == false)
			{
				//On ne fait rien.
			}
		}
		else if (revoirClients == false)
		{
			System.out.println("Souhaitez vous revoir tous les clients?(true/false)");
			revoirTousClients = sb.nextBoolean();
			if (revoirTousClients == true)
			{
				while(iAll < listeClients.size())
				{
					Client allTemp = (Client) listeClients.get(iAll);
					printClient(allTemp);
					iAll = iAll+1;
				}
				boolean revoirTarifAll;
				System.out.println("Voulez-vous revoir le tarif de tous vos clients?(true/false)");
				revoirTarifAll = sb.nextBoolean();
				if (revoirTarifAll == true)
				{
					int iRevoirTarifAll = 0;
					while(iRevoirTarifAll<listeClients.size())
					{
					listeClients.get(iRevoirTarifAll).realTarif(listeClients.get(iRevoirTarifAll));
					{
				}
					}}
				else if(revoirTarifAll == false)
				{
 
				}
 
 
 
			}
			else if(revoirTousClients==false)
			{
				System.out.println("Au revoir !");
			}
		}
 
 
//------------------------------------------------------------------------
 
 
//-----------------------------------------------------------------------------
 
 
 
 
 
 
 
 
 
	}
 
	public static void printClient(Client client)
	{
		double age = client.getAgeClient();
		System.out.println("Monsieur/madame "+client.getNomClient()+", originaire de la commune de "+client.getCommuneClient()+" et agé(e) de "+age+" ans, nous doit "+client.getTarifClient()+" euros.");
	}
}

Client :

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
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
 
 
import java.awt.List;
import java.util.ArrayList;
 
 
public class Client {
 
	private double ageClient;
	private String nomClient;
	private String communeClient;
	private double tarifClient;
	private ArrayList<Medicament> medicamentsClient = new ArrayList<>();	
	//----------------------------------------------------------
		public Client()
		{
			ageClient = -1;
			nomClient = "inconnu";
			communeClient = "inconnue";
			tarifClient = 0;
		}
	//-----------------------------------------------------------
		public Client(double pAgeClient, String pNomClient, String pCommuneClient, double pTarifClient)
		{
			ageClient = pAgeClient;
			nomClient = pNomClient;
			communeClient = pCommuneClient;
			tarifClient = pTarifClient;
			ArrayList medicamentsClient = new ArrayList();
		}
	//---------------------------------------------------------------
		//GET
		public double getAgeClient()
		{
			return ageClient;
		}
 
		public String getNomClient()
		{
			return nomClient;
		}
 
		public String getCommuneClient()
		{
			return communeClient;
		}
 
		public double getTarifClient()
		{
			return tarifClient;
		}
 
	//------------------------------------------------------------------
		//SET
		public void setAgeClient(double newAge)
		{
			ageClient = newAge;
		}
 
		public void setNomClient(String newName)
		{
			nomClient = newName;
		}
 
		public void setCommuneClient(String newCommune)
		{
			communeClient = newCommune;
		}
 
		public void setTarifClient(double newTarif)
		{
			tarifClient = newTarif;
		}
	//-------------------------------------------------------------------
		//ARTICLES
		public void addMedicament(Medicament medicament)
		{
			medicamentsClient.add(medicament);
		}
 
 
		public double realTarif(Client client)
		{
			int i=0;
			double newTarif = 0;
			while(i<medicamentsClient.size())
			{
				newTarif = newTarif + ((medicamentsClient.get(i)).getPrixMedicament());
			}
			return newTarif;
 
		}
 
 
}

Medicament : (car les produits vendus ici dont des medicaments)

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
 
 
public class Medicament {
 
	private String nomMedicament;
	private double prixMedicament;
	//-------------------------------------
	public Medicament()
	{
		nomMedicament = "inconnu";
		prixMedicament = 0;
	}
	//-------------------------------------
	public Medicament(String pNomMedicament, double pPrixMedicament)
	{
		nomMedicament = pNomMedicament;
		prixMedicament = pPrixMedicament;
 
	}
	//-------------------------------------
	//GET
	public String getNomMedicament()
	{
		return nomMedicament;
	}
 
	public double getPrixMedicament()
	{
		return prixMedicament;
	}
	//---------------------------------------
	//SET
	public void setNomMedicament(String newName)
	{
		this.nomMedicament = newName;
	}
 
	public void setPrixMedicament(double newPrice)
	{
		this.prixMedicament = newPrice;
	}
	//-----------------------------------------
}

Mon idéal serait de retirer le paramètre "tarif" du Client pour exprimer celui ci via la méthode realTarif(Client client). (Du moins je pense que c'est la manière la plus pratique de faire cela).
Merci d'avance !

[joel.drigo]

S'il y a des erreurs, dis-nous lesquelles.

Ensuite, tu es sûr que le programme ne se lance pas ? Il ne bouclerait pas indéfiniement en donnant l'impression qu'il ne fait rien parce qu'il n'affiche rien ?
Parce que dans ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public double realTarif(Client client)
		{
			int i=0;
			double newTarif = 0;
			while(i<medicamentsClient.size())
			{
				newTarif = newTarif + ((medicamentsClient.get(i)).getPrixMedicament());
			}
			return newTarif;
 
		}

i ne varie pas, medicamentsClients.size() non plus. Donc la boucle est "inifinie".
Tu devrais pour ce genre de boucle, faire un for : déjà ça te fera plus penser à la variabtion de l'index d'itération, et ensuite, ça permet d'avoir un scope limité pour des variables qui n'ont pas besoin d'exister en dehors de la boucle.

Le plus simple étant le forEach (à défaut d'utiliser les streams) :

Code :

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

1
2
3
4
5
6
7
public double realTarif(Client client) {
    double newTarif = 0;
    for(Medicament medicament : medicamentsClient) {
        newTarif = newTarif + medicament.getPrixMedicament();
    }
    return newTarif;
}

[lledune]

Tu as raison c'était un problème de boucle infinie...
Dernière question (promis :p), comment manipuler les variables qu'on a "return" ave une méthode?
Parce que quand je mets la méthode realTarif avec le return, je n'arrive pas à utiliser la variable retournée (newTarif).
Cependant si je change pour que le print soit dans la méthode alors tout fonctionne correctement...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public void realTarif(Client client)
		{
			int i=0;
			double newTarif = 0;
			while(i<medicamentsClient.size())
			{
				double jjj = ((medicamentsClient.get(i)).getPrixMedicament());
				newTarif = newTarif + jjj;
				i=i+1;
			}
				System.out.println(newTarif);
		}

Comme ceci, désolé si c'est une question de base mais c'est vraiment un truc que je ne comprends pas et je préfère combler toutes les lacunes dès maintenant pour ne pas avoir à le faire plus tard.

PS : Pour les boucles FOR je sais que je ne devrais pas, mais j'essaye de les utiliser le moins possible car j'ai horreur de celles-ci et qu'on peut faire la même chose avec une boucle while.

[joel.drigo]

comment manipuler les variables qu'on a "return" ave une méthode?
Parce que quand je mets la méthode realTarif avec le return, je n'arrive pas à utiliser la variable retournée (newTarif).
Cependant si je change pour que le print soit dans la méthode alors tout fonctionne correctement...

Exactement pareil que quand tu veux afficher le retour de getNomMedicament() :

Code :

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

1
2
3
4
if (revoirTarif == true) {
				int iClientNumber = iFocus;
				System.out.println("Tarif = " + listeClients.get(iClientNumber).realTarif(listeClients.get(iClientNumber)));
			}

D'ailleurs, l'argument de la méthode realTarif ne sert à rien (et tu ne t'en sers pas).

PS : Pour les boucles FOR je sais que je ne devrais pas, mais j'essaye de les utiliser le moins possible car j'ai horreur de celles-ci et qu'on peut faire la même chose avec une boucle while.

ça faisait longtemps que je n'avais pas entendu/lu un argument aussi incongru (la dernière fois : c'était "les abstractions c'est trop compliqué"). On n'est pas au jap où on demande 2 soupes miso parce qu'on n'aime pas la salade de choux. Bien sûr qu'on peut tout faire avec des while (même des if), mais d'une part au détriment de la clarté, de la logique, et de l'augmentation des possibilités d'erreur. Et d'autre part, un forEach n'est pas un for : non seulement il évite d'avoir une variable à état, mais en plus allège le code en faisant disparaitre le get. Il est également plus généraliste (applicable aux iterables).

[adiGuba]

Pour le coup, si c'est pour avoir un fichier texte imbittable, avec 75% d'informations purement structurelles, on perd le seul intérêt du fichier texte (avec la portabilité) : la lisibilité (surtout si en plus, on le compresse). Disons qu'on tape moins de code, mais je suis dubitatif sur le gain en simplicité.
Surtout pour gérer les évolutions des objets par la suite.

La lecture/sauvegarde est simple à mettre en place, même si on est amené à utiliser du polymorphisme.
Le XML généré est très verbeux, mais il se compresse très bien et on se retrouve au final avec un fichier relativement petit (proche de la taille du même objet sérialisé).

Le fichier n'est certe pas lisible tel quel car compressé, mais on peut toujours le lire/modifier facilement si besoin (en le décompressant bien sûr).
Quand à l'évolution (ajout/suppression d'attributs dans la classe), c'est assez souple en fait...


Alors oui ce n'est pas le meilleur format si on veut faire des échanges de données, mais là il est juste question d'une sauvegarde au sein d'une application.

Par contre, il me semblait qu'on pouvait utiliser XMLEncoder sur des objets non serializables (l'histoire du "DefaultPersitenceDelegate") ?

Oui en effet c'est une erreur de ma part...


a++