Discussion :

[johnny3]

Bonjour,

j'essaie, dans mon programme, de bien mettre en place les setter et les getter. J'y suis bien parvenu dans ce programme:

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
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
 
/*
 Un téléphone portable est décrit par un poids et une sensibilité 
 (exprimée de 1 à 10). On réalise une étude sur 20 gammes de portables. 
 Ecrire un algorithme qui réalise la saisie des données dans un tableau, 
 calcule et affiche le poids moyen, la sensibilité moyenne, le poids maximum 
 et la sensibilité maximale.
 L’algorithme demandera les données d’une nouvelle gamme et affichera des 
 appréciations en comparant les nouvelles données aux données moyennes.
 */
 
class cellular {
	private int poids;
 
	private int sensibilite;
 
	// cette méthode est expliquée un peu plus bas.
	public void setPoidsRandom() {
		this.poids = 1 + (int) (Math.random() * 200);
	}
 
	public void setPoids() {
		do {
			try {
				System.out.println("Donnez le poids:");
				this.poids = Terminal.lireInt();
				if (this.poids <= 0) {
					throw new ArrayIndexOutOfBoundsException();
				}
			} catch (ArrayIndexOutOfBoundsException e) {
				System.out.println("Le poids ne peut être négatif ou nul");
				System.out.println();
			} catch (Exception e2){
                                System.out.println("Mauvaise saisie.");}
		} while (this.poids <= 0);
	}
 
	// cette méthode est expliquée un peu plus bas
	public void setSensibiliteRandom() {
		this.sensibilite = 1 + (int) (Math.random() * 10);
	}
 
	public void setSensibilite() {
		do {
			try {
				System.out.println("Donnez la sensibilité (entre 1 et 10):");
				this.sensibilite = Terminal.lireInt();
				if ((this.sensibilite < 1) || (this.sensibilite > 10)) {
					throw new ArrayIndexOutOfBoundsException();
				}
			} catch (ArrayIndexOutOfBoundsException e) {
				System.out
						.println("La sensibilité ne peut être comprise qu'entre 1 et 10");
				System.out.println();
			}
		} while ((this.sensibilite < 1) || (this.sensibilite > 10));
	}
 
	public int getPoids() {
		return this.poids;
	}
 
	public int getSensibilite() {
		return this.sensibilite;
	}
 
	static cellular lirePortable() {
		final cellular res = new cellular();
		//res.setPoidsRandom(); si l'on veut que l'ordinateur choisisse lui-même
		res.setPoids(); //si l'on veut nous même saisir les données comme demandé dans l'énoncé
		//res.setSensibiliteRandom(); si l'on veut que l'ordinateur choisisse lui-même
		res.setSensibilite(); // si l'on veut nous même saisir les données comme demandé dans l'énoncé
		return res;
	}
 
	//méthode qui n'a de sens que si on exécute setPoidsRandom() et setSensibiliteRandom()
	static cellular lirePortableRajoute() {
		final cellular res = new cellular();
		res.setPoids();
		res.setSensibilite();
		return res;
	}
 
	void AffichageDonnees() {
		System.out.println("Poids du portable: " + getPoids() + " g.");
		System.out.println("Sensibilité du portable: " + getSensibilite());
		System.out.println();
	}
}
 
class Test {
	private double PoidsMoyen;
 
	private double SensibiliteMoyenne;
 
	private double sommePoids;
 
	private double sommeSensibilite;
 
	public cellular[] Gamme = new cellular[21];
 
	int nbPortables = 0;
 
	public void setPoidsMoyen(cellular[] Gamme) {
		for (int i = 0; i < this.nbPortables; i++) {
			this.sommePoids = this.sommePoids + this.Gamme[i].getPoids();
			this.PoidsMoyen = this.sommePoids / 20;
		}
		System.out.println("Le poids moyen des portables est de: " + this.PoidsMoyen
				+ " g");
	}
 
	public void setPoidsMax(cellular[] Gamme) {
		int max = Gamme[0].getPoids();
		for (int i = 0; i < this.nbPortables; i++) {
			if (this.Gamme[i].getPoids() > max) {
				max = this.Gamme[i].getPoids();
			}
		}
		System.out.println("Le portable le plus lourd a un poids de: " + max
				+ " g");
	}
 
	public void setSensibiliteMoyenne(cellular[] Gamme) {
		for (int i = 0; i < this.nbPortables; i++) {
			this.sommeSensibilite = this.sommeSensibilite
					+ this.Gamme[i].getSensibilite();
			this.SensibiliteMoyenne = this.sommeSensibilite / 20;
		}
		System.out.println("La sensibilité moyenne des portables est de: "
				+ this.SensibiliteMoyenne);
	}
 
	public void setSensibiliteMax(cellular[] Gamme) {
		int max = Gamme[0].getSensibilite();
		for (int i = 0; i < this.nbPortables; i++) {
			if (this.Gamme[i].getSensibilite() > max) {
				max = this.Gamme[i].getSensibilite();
			}
		}
		System.out
				.println("Le portable le plus sensible a une sensibilité de: "
						+ max);
	}
 
	public void getDonnees(cellular[] Gamme) {
		for (int i = 0; i < this.nbPortables; i++) {
			(this.Gamme[i]).AffichageDonnees();
		}
	}
 
	public void ajouter(cellular C) {
		this.Gamme[this.nbPortables] = C;
		this.nbPortables++;
	}
 
	// méthode qui n'a de sens que si on exécute setPoidsRandom() et setSensibiliteRandom()
	public void ajouterPortable(cellular C) {
		this.Gamme[20] = C;
	}
 
	public void comparaison(cellular[] Gamme) {
		if (Gamme[20].getPoids() > this.PoidsMoyen) {
			System.out
					.println("Le poids du portable rentré est plus élevé que la moyenne");
		} else {
			System.out
					.println("Le poids du portable rentré est inférieur à la moyenne");
		}
		if (Gamme[20].getSensibilite() > this.SensibiliteMoyenne) {
			System.out
					.println("La sensibilité du portable rentré est plus élevée que la moyenne");
		} else {
			System.out
					.println("La sensibilité du portable rentré est inférieure à la moyenne");
		}
	}
 
	public void ecrireTableauPortables() {
		for (int i = 0; i < this.nbPortables; i++) {
			(this.Gamme[i]).AffichageDonnees();
		}
	}
}
 
public class telephone {
	public static void main(final String[] args) {
		Test C = new Test();
		for (int i = 0; i < 20; i++) {
			C.ajouter(cellular.lirePortable());
		}
		C.ecrireTableauPortables();
		C.setSensibiliteMax(C.Gamme);
		C.setSensibiliteMoyenne(C.Gamme);
		C.setPoidsMax(C.Gamme);
		C.setPoidsMoyen(C.Gamme);
		System.out.println();
		System.out.println("Vous allez rajouter un portable"); // n'a de sens que si on exécute setPoidsRandom() et setSensibiliteRandom()
		C.ajouterPortable(cellular.lirePortableRajoute()); // idem
		C.comparaison(C.Gamme);
	}
}

avec les set qui ne renvoient rien et les get qui renvoient la valeur return this.***, sauf pour le getDonnees qui ne renvoyait rien.

Mais là, dans le programme suivant pour lequel j'ai déjà sollicité de l'aide pour une fonction (encore merci au passage), je ne parviens pas à mettre correctement place getTemps et setTemps:

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
/*
 * Dans une course de motos, on demande au candidat de réaliser une série de tests jusqu’à ce qu’il
 * obtienne 10 essais différents. Les 10 essais , dont le temps est exprimé en secondes, seront
 * stockés dans un tableau . A chaque saisie d’un temps, on examine s’il a été déjà réalisé ; si tel
 * est le cas, le candidat est invité à refaire un essai ; sinon , le temps est homologué et stocké
 * dans le tableau . Déterminer ensuite le temps moyen des essais du candidat et son record .
 * 
 */
public class moto {
	private final int NB_ESSAIS = 10;
	private double temps = 0;
	private static final double [] tabTemps = new double[10];
	private double moyenne = 0;
	private int record = 0;
 
	public int getNbEssais()
	{
		return this.NB_ESSAIS;
	}
 
	double getMoyenne()
	{
		return this.moyenne;
	}
 
	int getRecord()
	{
		return this.record;
	}
 
	public double setTemps()
	{
		do
		{
			try
			{
				Terminal.ecrireStringln("Donnez le temps réalisé en secondes.");
				this.temps = Terminal.lireDouble();
				if (this.temps <= 0) {throw new ArrayIndexOutOfBoundsException(); }
			} catch (ArrayIndexOutOfBoundsException e)
			{
				Terminal.ecrireStringln("Le temps ne peut être négatif ou nul");
				Terminal.sautDeLigne();
			} catch (Exception e2)
			{
				Terminal.ecrireStringln("mauvaise saisie");
			}
		} while (this.temps <= 0);
		return this.temps;
	}
 
	public void affichage(double [] tabTemps)
	{
		Terminal.sautDeLigne();
		for (int i = 0; i < tabTemps.length; i++)
		{
			Terminal.ecrireStringln("Temps réalisé au tour " + (i + 1) + ": " + (int) tabTemps[i] + " secondes.");
		}
		Terminal.sautDeLigne();
	}
 
	public boolean trouve(double temps, double [] tabTemps)
	{
		for (double element : tabTemps)
		{
			if (element == temps) return true;
		}
		return false;
	}
 
	public double calculMoyenne(double [] tabTemps)
	{
		double somme = 0;
		for (double element : tabTemps)
		{
			somme = somme + element;
		}
		this.moyenne = somme / tabTemps.length;
		return this.moyenne;
	}
 
	public int record(double [] tabTemps)
	{
		this.record = (int) tabTemps[0];
		for (double element : tabTemps)
		{
			if (element < this.record) this.record = (int) element;
		}
		return this.record;
	}
 
	public double [] tableauTemps()
	{
		for (int i = 0; i < this.getNbEssais(); i++)
		{
			Terminal.ecrireStringln("Essai " + (i + 1) + ".");
			while (this.trouve(this.setTemps(), tabTemps))
			{
				Terminal.sautDeLigne();
				Terminal.ecrireStringln("Valeur déjà donnée.");
			}
			tabTemps[i] = this.temps;
			Terminal.sautDeLigne();
		}
		return tabTemps;
	}
 
	public static void main(String [] args)
	{
		moto m = new moto();
		m.tableauTemps();
		m.affichage(tabTemps);
		m.calculMoyenne(tabTemps);
		m.record(tabTemps);
		Terminal.ecrireStringln("La moyenne réalisée est de " + m.getMoyenne() + " secondes.");
		Terminal.sautDeLigne();
		Terminal.ecrireStringln("La meilleure performance est de " + m.getRecord() + " secondes.");
	}
}

Normalement, mon setTemps ne devrait rien retourner, mais si je créé une fonction getTemps qui retourne this.temps et que, dans public double [] tableauTemps(), j'écris

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
public double [] tableauTemps()
	{
		for (int i = 0; i < this.getNbEssais(); i++)
		{
			Terminal.ecrireStringln("Essai " + (i + 1) + ".");
			while (this.trouve(this.setTemps(), tabTemps))
			{
				Terminal.sautDeLigne();
				Terminal.ecrireStringln("Valeur déjà donnée.");
			}
			tabTemps[i] = this.temps;
			Terminal.sautDeLigne();
		}
		return tabTemps;
	}

cela fonctionne. Mais, bien sûr, si je remplace setTemps par getTemps (en créant un getTemps) et en ne retournant rien pour setTemps, ça ne fonctionne plus. Comment faire?

Merci d'avance,
johnny3

[djsnipe]

Les getter et setter que tu décrit ne pas de la forme dont on les entend en général. Dans la terminologie des JavaBean, il s'agit juste de méthodes pour lire et écrire une valeur dans un objet.
Dans l'exemple que tu donnes "setTemps()", le "setter" s'occupe également de gérer les saisies de l'utilisateur et la validation des données. Au passage, la ArrayOutOfBoundException est mal utilisée, d'abord parce que sont nom ne correspond absolument pas au problème, et d'autre part, pourquoi cette exception alors que le if est suffisant juste à côté ? De plus, un setter qui renvoi une donnée n'a pas de sens, cette méthode n'est pas un setter, mais une saisie utilisateur, et surtout, elle ne modifie absolument pas un attribut de ta classe (au passage, par convention, un nom de classe commence par une majuscule, et une variable par une minuscule en Java).

[johnny3]

Les getter et setter que tu décrit ne pas de la forme dont on les entend en général. Dans la terminologie des JavaBean, il s'agit juste de méthodes pour lire et écrire une valeur dans un objet.
Dans l'exemple que tu donnes "setTemps()", le "setter" s'occupe également de gérer les saisies de l'utilisateur et la validation des données. Au passage, la ArrayOutOfBoundException est mal utilisée, d'abord parce que sont nom ne correspond absolument pas au problème, et d'autre part, pourquoi cette exception alors que le if est suffisant juste à côté ? De plus, un setter qui renvoi une donnée n'a pas de sens, cette méthode n'est pas un setter, mais une saisie utilisateur, et surtout, elle ne modifie absolument pas un attribut de ta classe (au passage, par convention, un nom de classe commence par une majuscule, et une variable par une minuscule en Java).

Oui, je m'y perds encore un peu dans le nommage.

En fait, je ne désire pas renommer les exceptions juste pour les renommer. Je veux dire, le nom ne correspond pas, mais cette exception gère ce que je demande, c'est à dire le fait de ne pas sortir d'un créneau de valeurs. On m'a appris (mais peut-être par erreur) qu'il n'était pas forcément utile de renommer une exception si on pouvait employer un nom d'origine, s'il remplissait les mêmes fonctions. Mais c'était peut-être effectivement un très mauvais conseil.

Exception est important car elle gère les mauvaises saisies (si tu tapes une lettre au lieu d'un nombre, par exemple) A moins que tu ne voulais dire, pourquoi une arrayindex...exception alors que j'ai un if? Oui, c'est vrai que je pourrais juste écrire un if...else. J'utilise peut-être à tort des exceptions.

En fait, on écrit des setter et des getter de la sorte, c'est cela?

Code :

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

1
2
3
4
5
6
7
int getPoids(){
return poids;
}
 
void setPoids(int p){
this poids = p;
}

Je crois que ça devient plus clair dans mon esprit. Merci pour ton aide.

[gifffftane]

Oui, ton get/setPoids ressemble déjà mieux à un getter/setter classique.

Concernant ton exception, et son renommage éventuel, il me semble que tu as tout à fait raison dans le principe. Simplement le ArrayIndexOutOfBoundsException concerne plutôt un dépassement dans un tableau java (comme int[] toto), et je n'ai pas l'impression que ce soit le cas ici. Mais tout est affaire de convention ; si ta convention considère que cette exception se rapporte à d'autres types de données, que tu arrives à la suivre, que d'autres arrivent à te comprendre, et que tu trouves ça bien, alors c'est bien.

Perso pour ce genre de choses j'emploie plutot IllegalStateException, mais c'est vraiment une exception passe partout qui dénote une attitude de fénéant.

[johnny3]

Oui, ton get/setPoids ressemble déjà mieux à un getter/setter classique.

Concernant ton exception, et son renommage éventuel, il me semble que tu as tout à fait raison dans le principe. Simplement le ArrayIndexOutOfBoundsException concerne plutôt un dépassement dans un tableau java (comme int[] toto), et je n'ai pas l'impression que ce soit le cas ici. Mais tout est affaire de convention ; si ta convention considère que cette exception se rapporte à d'autres types de données, que tu arrives à la suivre, que d'autres arrivent à te comprendre, et que tu trouves ça bien, alors c'est bien.

Perso pour ce genre de choses j'emploie plutot IllegalStateException, mais c'est vraiment une exception passe partout qui dénote une attitude de fénéant.

Je ne connaissais pas cette exception. Merci!

Par contre, quand je disais "on m'a appris"; je parlais de mon beau frère qui est ingénieur et qui me disait, quand on fait, par exemple class NPasBon extends Exception {}

Par contre, au CNAM (tu l'as deviné, la classe Terminal étant un produit du CNAM, c'est là où je fais mes études), il y a des corrections très contradictoires. Des fois, ils renomment les exceptions, des fois non. Du coup, je me suis souvent demandé si c'était utile. Je te mets ici deux corrigés d'exercices de NFA002 (programmation objet) de la même séance d'ED. Dans le premier exercice... aucun renommage, et dans le second... uniquement des noms particuliers! Du coup, on s'embrouille.

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
 
class Exo18_1_1{
 
   static int[] tableau = {17, 12, 15, 38, 29, 157, 89, —22,0, 5};
   static i n t division(int indice, int diviseur){
      return tableau[indice]/diviseur;
}
   public static void main(String [] args){ i n t x, y;
      boolean ok = true;
     do{
          try{
             Terminal.ecrireString(”Entrez l’indice de l’entier a diviser: ”);
              x = Terminal.lireInt(); Terminal.ecrireString(”Entrez le diviseur: ”);
              y = Terminal.lireInt();
              Terminal .ecrireStringln(”Le resultat de la division est: ”); 
              Terminal .ecrireIntln(division(x,y));
 
           }catch(ArithmeticException e){
                  Terminal.ecrireStringln (”Le diviseur  ne doit pas etre  nul .”);
                  ok = false;
           }catch (ArrayIndexOutOfBoundsException e){
                   Terminal.ecrireString (”L’ indice doit etre compris entre 0 ”);          
                   Terminal .ecrireStringln(”et ” + (tableau.length -1) + ”.”);
                   ok = false; 
            }catch(TerminalException e){
                  Terminal .ecrireStringln(”Vous devez entrer un nombre entier.”);   
                   ok = false;
            }
       } while (! ok);
}

Mais effectivement, on parle d'un tableau, comme tu le disais. Et ici:

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
 
class Exo_18_3 {
	public static void main(String [] args)
	{
		String [] st1 = { "Partir loin", "Rester au lit", "Se lever" };
		String [] st2 = { "Rouge", "Vert", "Bleu", "Jaune", "Violet" };
		String [] st3 = { "Canard", "Poule", "Pintade", "Oie", "Dinde", "Pleiad" };
		Menu [] mt = new Menu[3];
		boolean saisieOk;
		try
		{
			mt[0] = new Menu("Que voulez-vous faire? ", st1);
			mt[1] = new Menu("Quelle est votre couleur ´e´e´eprfre?", st2);
			mt[2] = new Menu("Trouvez l’intrus.", st3);
		} catch (NPasBon ex)
		{
		}
		for (int i = 0; i < 5; i++)
		{
			do
			{
				try
				{
					saisieOk = true;
					mt[i % 3].executerMenu();
				} catch (HorsIntervalle ex)
				{
					Terminal.ecrireString("Vous devez entrer un");
					Terminal.ecrireStringln(" des choix ´eproposs.");
					saisieOk = false;
				} catch (PasNombre ex)
				{
					Terminal.ecrireStringln("Vous devez entrer un nombre.");
					saisieOk = false;
				}
			} while (!saisieOk);
		}
	}
}
class NPasBon extends Exception {}
class PasNombre extends Exception {}
class HorsIntervalle extends Exception {}
class Menu {
	String [] tabChoix;
	String question;
 
	Menu (String q, String [] t) throws NPasBon
	{
		if (t.length > 9) { throw new NPasBon(); }
		this.tabChoix = t;
		this.question = q;
	}
 
	void affiche()
	{
		Terminal.ecrireStringln(question);
		for (int i = 0; i < tabChoix.length; i++)
		{
			Terminal.ecrireStringln(tabChoix[i] + ": tapez " + (i + 1));
		}
		Terminal.ecrireString("Entrez votre choix: ");
	}
 
	int charToInt(char c) throws PasNombre
	{
		if (c == '1')
		{
			return 1;
		} else if (c == '2')
		{
			return 2;
		} else if (c == '3')
		{
			return 3;
		} else if (c == '4')
		{
			return 4;
		} else if (c == '5')
		{
			return 5;
		} else if (c == '6')
		{
			return 6;
		} else if (c == '7')
		{
			return 7;
		} else if (c == '8')
		{
			return 8;
		} else if (c == '9')
		{
			return 9;
		} else if (c == '0') { return 0; }
		throw new PasNombre();
	}
 
	int saisir() throws PasNombre, HorsIntervalle
	{
		char rep = Terminal.lireChar();
		int repInt;
		repInt = this.charToInt(rep);
		if ((repInt == 0) || (repInt > this.tabChoix.length)) { throw new HorsIntervalle(); }
		return repInt;
	}
 
	int executerMenu() throws PasNombre, HorsIntervalle
	{
		this.affiche();
		return this.saisir();
	}
}

Ici, on renomme, mais on étend juste Exception, en fait.

Mais effectivement, je pense qu'il vaut mieux que je commence à renommer mes exceptions, pour le jour où je me mettrai à travailler. Merci du conseil!

[gifffftane]

L'habitude de mettre TotoException avec Exception comme suffixe n'est qu'une convention, pas une nécessité ; ce qui fait que c'est une exception est extends Exception.

Sinon, bonne réussite dans tes études.