[amélioration] Critique de mon programme

Voici toutes les modifications que j'ai réalisées grâce à vos conseils. Je pense qu'il reste des erreurs donc n'hésitez pas à me le faire remarquer 8-)

Pour les classes LireObjet et EcrireObjet, je n'ai changé que la possibilité d'enregistrer la classe en serialisation au lieu de l'élève donc rien n'a réellement changé. N'ayant pas encore compris comment faire remonter les exceptions, il reste du travail à ce niveau :oops: mais avant d'aller plus loin, je voulais savoir ce que vous pensiez du reste :aie:

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
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.io.Serializable;
 
/**
 * Eleve est la classe représentant un élève dans une école
 * Il est représenté par les attributs suivants :
 * <ul>
 * <li> Son nom
 * <li> Son prénom
 * <li> Ses notes
 * </ul>
 *
 * @author Chipster
 * @version 0.3
 */
public class Eleve implements Serializable, Comparable<Eleve> {
	/**
         * Le nom de famille de l'élève. Il est modifiable
         * @see Eleve#setNom(String)
         * @see Eleve#getNom()
         */
	private String nom = "";
 
	/**
         * Le prénom de l'élève. Il est modifiable
         * @see Eleve#setPrenom(String)
         * @see Eleve#getPrenom()
         */
	private String prenom = "";
 
	/**
         * Le tableau de notes de l'élève. Il est modifiable
         * @see Eleve#addNote(double)
         * @see Eleve#getNote()
         */
	ArrayList<Double> note = new ArrayList<Double>();
 
	/**
         * La moyenne de l'élève. Elle est modifiable
         */
	private double moyenne = 0;
 
	/**
                * Permet d'éviter de recalculer à chaque affichage toutes les moyennes
                * de tous les élèves. Il faut recalculer les moyennes seulement lors d'un
                * ajout de notes
                */
	private boolean recalculerMoyenne;
 
 
	/**
         * Constructeur Eleve
         * <p>
         * À la construction d'un objet Eleve, les noms et prénoms sont fixés
         * </p>
         *
         * @param nom
         *      Le nom de l'élève
         *
         * @param prenom
         * Le prénom de l'élève
         *
         * @see Eleve#nom
         * @see Eleve#prenom
         */
	public Eleve(String nom, String prenom) {
		setNom(nom);
		setPrenom(prenom);
	}
 
 
	/**
         * Constructeur Eleve
         * <p>
         * À la construction d'un objet Eleve, les noms et prénoms sont fixés. La moyenne
         * est initialisée à 0 et un tableau de notes est initialisé
         * </p>
         *
         * @param nom
         *      Le nom de l'élève
         *
         * @param prenom
         * Le prénom de l'élève
         *
         * @param note
         *
         * @see Eleve#nom
         * @see Eleve#prenom
         * @see Eleve#note
         * @see Eleve#moyenne
         */
	public Eleve(String nom, String prenom, double note[]) {
		setNom(nom);
		setPrenom(prenom);
		for(int i = 0; i < note.length; ++i) {
			addNote(note[i]);
		}
	}
 
	/**
         * Elle calcule la moyenne de l'élève seulement s'il existe des notes dans le tableau
         *
         * @see Eleve#moyenne
         */
	private void calculMoyenne() {
		if(!recalculerMoyenne) {
			return;
		}
		if(note.size() > 0) {
			double somme = 0;
 
			for(int i = 0; i < note.size(); ++i) {
				somme += note.get(i);
			}
			this.moyenne = (somme / note.size());
		}
		recalculerMoyenne = false;
	}
 
	/**
                * Elle permet de savoir si deux élèves sont identiques afin d'éviter les doublons
                *
                * @param o
                *
                * @return vrai ou faux
                */
	@Override
	public boolean equals(Object o) {
		if(o == this)
			return true;
		if(o instanceof Eleve) {
			Eleve eleve = (Eleve) o;
 
			if(!this.nom.equals(eleve.getNom())) {
				return false;
			}
			if(!this.prenom.equals(eleve.getPrenom())) {
				return false;
			}
			return true;
		}
		return false;
	}
 
	/**
                * Elle permet de comparer deux élèves entre eux pour un classement alphabétique
                *
                * @param eleve
                *
                * @return -1, 0 ou 1 en fonction du classement
                */
	@Override
	public int compareTo(Eleve eleve) {
		int compare = nom.compareTo(eleve.nom);
		if(compare == 0)
			compare = prenom.compareTo(eleve.prenom);
 
		return compare;
	}
 
	/**
                * Retourne le nom de l'élève
                *
                * @return le nom de l'élève
                *
                * @see Eleve#nom
                */
	public String getNom() {
		return nom;
	}
 
	/**
                * Retourne le prénom de l'élève
                *
                * @return le prénom de l'élève
                *
                * @see Eleve#prenom
                */
	public String getPrenom() {
		return prenom;
	}
 
	/**
                * Retourne la moyenne de l'élève
                *
                * @return la moyenne de l'élève de type double
                *
                * @see Eleve#moyenne
                */
	public double getMoyenne() {
		return moyenne;
	}
 
	/**
                * Retourne la liste des notes de l'élève
                *
                * @return la liste des notes de l'élève de type double
                */
	public List<Double> getNote() {
		return Collections.unmodifiableList(note);
	}
 
	/**
                * Met à jour le nom de l'élève
                *
                * @param nom
                *               Le nouveau nom de l'élève de type String
                */
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	/**
                * Met à jour le prénom de l'élève
                *
                * @param prenom
                *               Le nouveau prénom de l'élève de type String
                */
	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}
 
	/**
                * Ajoute une note comprise entre 0 et 20 inclus
                *
                * @param note
                *               La nouvelle note de l'élève de type double
                */
	public void addNote(double note) {
		if(note >= 0 && note <= 20) {
			this.note.add(note);
			recalculerMoyenne = true;
		}
	}
 
	/**
                * Retourne toutes les informations concernant l'élève
                *
                * @return Chaine de caractères contenant toutes les informations concernant l'élève
                */
	public String toString() {
		int taille_chaine = 0;
		StringBuilder str;
 
		if(note.size() == 0 ) {
			taille_chaine = nom.length() + prenom.length() + 1;
			str = new StringBuilder(taille_chaine);
			str.append(nom + " " + prenom);
		}
		else {
			calculMoyenne();
			taille_chaine = 4 + nom.length() + prenom.length() + note.size() * 2 + 4;
			str = new StringBuilder(taille_chaine);
			str.append(nom + " " + prenom + " |" + ((double)((int)(moyenne * 100)))/100 + "| ");
			for(int i = 0; i < note.size(); ++i)
				str.append(String.valueOf(note.get(i)) + " ");
		}
		return String.valueOf(str);
	}
}

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
import java.util.Collections;
import java.util.TreeSet;
import java.util.Iterator;
import java.util.List;
import java.io.Serializable;
 
/**
        * Classe est la classe représentant une classe d'une école
        * avec des élèves. Elle n'a qu'un seul attribu à savoir un
        * TreeSet contenant les élèves formant la classe
        *
        * @author Chipster
        * @version 0.3
        */
public class Classe implements Serializable {
 
	/**
                * treeEleve de type TreeSet contenant les élèves. Il est modifiable
                * @see Classe#addEleve
                * @see Classe#delEleve
                */
	private TreeSet<Eleve> treeEleve;
 
	/**
                * Constructeur Classe.
                * <p>
                * À la création d'un objet Classe, il initialise un tableau treeEleve
                * </p>
                *
                * @see Classe#treeEleve
                */
	public Classe() {
		this.treeEleve = new TreeSet<Eleve>();
	}
 
	/**
                * Elle ajoute eleve à treeEleve
                *
                * @param eleve
                *
                * @see Classe#treeEleve
                */
	public void addEleve(Eleve eleve) {
		treeEleve.add(eleve);
	}
 
	/**
                * Elle supprime eleve à treeEleve
                *
                * @param eleve
                *
                * @see Classe#treeEleve
                */
	public void delEleve(Eleve eleve) {
		treeEleve.remove(eleve);
	}
 
	/**
                * Elle permet de savoir si eleve est contenu dans treeEleve
                *
                * @param eleve
                *
                * @return vrai ou faux
                *
                * @see Classe#treeEleve
                */
	public boolean existEleve(Eleve eleve) {
		return treeEleve.contains(eleve);
	}
 
	/**
                * Elle permet de connaitre le nombre d'élève contenu dans treeEleve
                *
                * @return le nombre d'élève
                */
	public int getNbEleve() {
		return treeEleve.size();
	}
 
	/**
                * Elle permet de récupérer les notes d'un élève déjà présent
                *
                * @param un objet de type Eleve
                *
                * @return le tableau de notes de l'élève présent dans la liste.
                * Il est non modifable
                */
	public List<Double> getNote(Eleve eleve) {
		Object[] tab    = treeEleve.toArray();
		boolean trouver = false;
		int i;
 
		for(i = 0; i < tab.length && trouver == false; ++i) {
			if(tab[i].equals(eleve))
				trouver = true;
		}
		return Collections.unmodifiableList(((Eleve)(tab[i])).getNote());
	}
 
	/**
                * Retourne toutes les informations concernant la classe
                *
                * @return Chaine de caractères contenant toutes les informations concernant la classe
                */
	public String toString() {
		int taille_tableau = treeEleve.size();
		// On concidère qu'il y aura 40 caractères par élève
		StringBuilder str = new StringBuilder(taille_tableau * 40);
		Iterator it = treeEleve.iterator();
		while(it.hasNext()) {
			str.append(it.next() + "\n");
		}
		return String.valueOf(str);
	}
}

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
import java.io.*;
 
public class LireObjet {
	private String nomFichier         = "";
	private ObjectInputStream lecture = null;
 
	public LireObjet(String nom) {
		setNomFichier(nom);
		try {
			lecture = new ObjectInputStream(new FileInputStream(nomFichier));
		}
		catch(IOException e) {
			System.out.println("Erreur d'E/S");
			System.exit(1);
		}
	}
 
	public static boolean existFichier(String nomFichier) {
		if(new File(nomFichier).exists())
			return true;
		else
			return false;
	}
 
	public static void creerFichier(String nomFichier) {
		if(!existFichier(nomFichier)) {
			EcrireObjet nouveauFichier = new EcrireObjet(nomFichier);
			nouveauFichier.close();
		}
	}
 
	public Classe getObjet() {
		Classe classe = null;
		try {
			classe = (Classe)lecture.readObject();
		}
		catch(EOFException e) {
			return null;
		}
		catch(IOException e) {
			System.out.println("Erreur d'E/S");
			System.exit(1);
		}
		catch(ClassNotFoundException e) {
			System.out.println("Objet inconnu");
			System.exit(1);
		}
		return classe;
	}
 
	public void close() {
		try {
			lecture.close();
		}
		catch(IOException e) {
			System.out.println("Erreur d'E/S");
			System.exit(1);
		}
	}
 
	public void setNomFichier(String nomFichier) {
		this.nomFichier = nomFichier;
	}
}

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
import java.io.*;
 
public class EcrireObjet {
	private String nomFichier           = "";
	private ObjectOutputStream ecriture = null;
 
	public EcrireObjet(String nom) {
		setNomFichier(nom);
		try {
			ecriture = new ObjectOutputStream(new FileOutputStream(nom));
		}
		catch(FileNotFoundException e) {
			System.out.println("Fichier introuvable");
			System.exit(1);
		}
		catch(IOException e) {
			System.out.println("Erreur d'E/S");
			System.exit(1);
		}
	}
 
	public void write(Classe Objet) {
		try {
			ecriture.writeObject(Objet);
		}
		catch(IOException e) {
			System.out.println("Erreur d'E/S");
			System.exit(1);
		}
	}
 
	public void close() {
		if(ecriture != null) {
			try {
				ecriture.flush();
				ecriture.close();
			}
			catch(IOException e) {
				System.out.println("Erreur d'E/S");
				System.exit(1);
			}
		}
	}
 
	public String getNomFichier() {
		return this.nomFichier;
	}
 
	public void setNomFichier(String nomFichier) {
		this.nomFichier = nomFichier;
	}
}

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
175
176
import java.util.List;
import java.util.ArrayList;
 
/**
        * Classe principale qui permet d'ajouter supprimer des élèves
        * dans la classe. Elle possède les attributs suivants :
        * <ul>
        * <li> Une classe
        * <li> Un élève qui sert de stockage tampon
        * <li> Un String de caractère pour les options passées en paramètre
        * <li> Un String contenant le nom du fichier dans lequel nous allons charger et sauver
        * les infos concernant la classe
        * <li> Un entier i qui va nous permettre de parcourir des tableaux
        * </ul>
        *
        * @author Chipster
        * @version 0.3
        */
public class zEcole {
	public static void main(String[] args) {
		Classe classe       = null;
		Eleve eleve         = null;
		String option       = "";
		String nomFichier   = "";
		int i;
 
		// On récupère les arguments en paramètre
		try {
			nomFichier = args[0];
			option     = args[1];
		}
		// Si le nombre d'argument ne correspondant pas on lance la fonction help()
		catch(ArrayIndexOutOfBoundsException e) {
			System.err.println("Nom d'argument invalide");
			help();
		}
 
		// Si l'option passée en paramètre est -a alors on ajoute un élève sans notes dans la classe
		if("-a".equals(option)) {
			try {
				eleve = new Eleve(args[2], args[3]);
			}
			catch(ArrayIndexOutOfBoundsException e) {
				System.err.println("Nom d'argument invalide");
				help();
			}
			classe = chargementClasse(nomFichier);
			classe = ajouterEleve(classe, eleve);
			ecrireFichier(classe, nomFichier);
		}
		// Si l'option est -c alors on crée le fichier passé en paramètre
		else if("-c".equals(option)) {
			creerFichier(nomFichier);
		}
		// Si l'option est -d alors on supprimer l'élève de la classe passé en paramètre
		else if("-d".equals(option)) {
			try {
				eleve = new Eleve(args[2], args[3]);
			}
			catch(ArrayIndexOutOfBoundsException e) {
				System.err.println("Nom d'argument invalide");
				help();
			}
			classe = chargementClasse(nomFichier);
			classe = supprimerEleve(classe, eleve);
			ecrireFichier(classe, nomFichier);
		}
		// Si l'option est -h alors on lance la fonction help()
		else if("-h".equals(option)) {
			help();
		}
		// Si l'option est -l alors on liste les élèves de la classe
		else if("-l".equals(option)) {
			classe = chargementClasse(nomFichier);
			System.out.print(classe);
		}
		// Si l'option est -n alors on ajoute l'élève passé en paramètre avec ses notes
		else if("-n".equals(option)) {
			// On vérifie que des notes sont passées en paramètre avant de poursuivre
			int nbArgument = args.length - 4;
			if(nbArgument <= 0)
				help();
			try {
				eleve = new Eleve(args[2], args[3]);
			}
			catch(ArrayIndexOutOfBoundsException e) {
				System.err.println("Nom d'argument invalide");
				help();
			}
			classe = chargementClasse(nomFichier);
			List<Double> note = new ArrayList<Double>();
			// On vérifie que l'élève n'existe pas déjà dans la classe. S'il existe on récupère
			// ses notes avant de le supprimer de la classe et de le re-rajouter
			if(classe.existEleve(eleve)) {
				try {
					note = recupererNote(classe, eleve);
				}
				catch(ArrayIndexOutOfBoundsException e) {
					note = new ArrayList<Double>();
				}
				classe = supprimerEleve(classe, eleve);
			}
			classe = ajouterEleve(classe, eleve, note, args);
			ecrireFichier(classe, nomFichier);
		}
		// Si l'option passée en paramètre n'est pas reconnu alors on lance la fonction help()
		else {
			System.err.println("Argument " + option + " inconnu");
			help();
		}
	}
 
	public static void creerFichier(String nomFichier) {
		LireObjet.creerFichier(nomFichier);
	}
 
	// Elle permet de charger la classe contenu dans le fichier
	public static Classe chargementClasse(String nomFichier) {
		LireObjet source = new LireObjet(nomFichier);
		Classe classe = source.getObjet();
		source.close();
		if(classe == null)
			classe = new Classe();
		return classe;
	}
 
	// Permet d'ajouter un élève à la classe
	public static Classe ajouterEleve(Classe classe, Eleve eleve) {
		classe.addEleve(eleve);
		return classe;
	}
 
	// Permet d'ajouter un élève avec ses notes à la classe en suchargeant la classe précédente
	public static Classe ajouterEleve(Classe classe, Eleve eleve, List<Double> note, String[] args) {
		int i;
 
		for(i = 0; i < note.size(); ++i)
			eleve.addNote(note.get(i));
		for(i = 4; i < args.length; ++i)
			eleve.addNote(Double.valueOf(args[i]));
 
		classe.addEleve(eleve);
		return classe;
	}
 
	// Permet de supprimer un élève de la classe
	public static Classe supprimerEleve(Classe classe, Eleve eleve) {
		classe.delEleve(eleve);
		return classe;
	}
 
	// Permet de récupérer les notes d'un élève déjà présent
	public static List<Double> recupererNote(Classe classe, Eleve eleve) {
		return classe.getNote(eleve);
	}
 
	// Permet de sauvegarder les données modifiées de la classe
	public static void ecrireFichier(Classe classe, String nomFichier) {
		EcrireObjet cible = new EcrireObjet(nomFichier);
		cible.write(classe);
		cible.close();
	}
 
	// On défini l'aide du programme
	public static void help() {
		System.out.println("Usage : zEcole file <option>");
		System.out.println("  <option> :");
		System.out.println("             -a nom prénom               : Ajoute un élève\n"
										 + "             -c                          : Crée un fichier élève\n"
			               + "             -d nom prénom               : Supprime un élève\n"
										 + "             -h                          : Cette aide\n"
								 		 + "             -l                          : Liste les élèves\n"
							 			 + "             -n nom prénom note note ... : Ajoute des notes");
		System.exit(0);
	}
}

Voilà