Discussion :

[olivier252]

Hello,

J'ai 2 questions

Je pense avoir compris le traitement d'une exception grace aux clauses try/catch où l'on assigne un traitement dans le bloc catch en cas d'erreur décelée dans l'exécution du bloc try, mais je ne comprends pas le concept de propagation d'une exception d'une part, et l'utilité de créer des exceptions personnalisées.

Je me suis efforcé de créer un petit exercice qui lève une exception personnalisée ou une ArithmeticException ici :

Exception personnalisée

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
package exceptionProjectBis;
 
public class ExceptionDivision {
 
	private int x;
	private int y;
 
	public ExceptionDivision(int x, int y)  {
		super();
		this.x = x;
		this.y = y;
	}
 
	//Une méthode qui lève une exception inclut la clause "throws" et nom_E
	public int diviser() throws DivisionByZeroException {
		if(y==0) throw new DivisionByZeroException();
		int res =  x/y;
		return res;	
	}
 
	public class DivisionByZeroException extends Exception{
 
		public DivisionByZeroException() {
			super();
			// TODO Auto-generated constructor stub
		}
 
	}
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			ExceptionDivision ed = new ExceptionDivision(5, 0);
			System.out.println(ed.diviser());
 
		} catch(DivisionByZeroException e) {
			System.out.println(e.getMessage()+"Erreur ! Division par zéro impossible");
			//e.printStackTrace();
		}
 
		finally {
			System.out.println("Veuillez saisir de nouvelles valeurs");
		}
	}
}

Avec ArithmeticException

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
public class ExceptionTer {
	private int x;
	private int y;
 
	public ExceptionTer(int x, int y)  {
		super();
		this.x = x;
		this.y = y;
	}
 
	//Une méthode qui lève une exception inclut la clause "throws" et nom_E
	public int diviser() throws ArithmeticException {
		if(y==0) throw new ArithmeticException();
 
		int res =  x/y;
		return res;	
	}
 
	public static void main(String[] args) {
		try {
			ExceptionTer ed = new ExceptionTer(5, 0);
			System.out.println(ed.diviser());
 
		} catch(ArithmeticException e) {
			System.out.println("Erreur");
			//e.printStackTrace();
		}
 
		finally {
			System.out.println("Veuillez saisir de nouvelles valeurs");
		}
	}
}

Par commodité j'ai groupé les différentes classes sur un même script

Merci

[PhilippeGibault]

Une exception doit (à minima) étendre la classe Exception ( https://docs.oracle.com/javase/7/doc...Exception.html )

par ailleurs, contrairement à ce que l'on croit, les exceptions Java, c'est un sujet difficile.

Dans le Joshua Bloch ( https://www.amazon.fr/Effective-Java...FPXMEWVWVN96Y2 ), il y a 9 chapitres sur le sujet.

Je vais essayer de les résumer.

1. Il faut utiliser les exceptions pour les choses "exceptionnelles".
En gros, il ne faut jamais faire ça:

Code :

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

1
2
3
4
5
6
7
8
 
try{
 int i = 0;
 while(true){
     range[i++].climb();
 }
}catch(ArrayIndexOutOfBoundsException e){
}

Il faut coder:

Code :

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

1
2
3
4
 
for(Mountain m : range){
m.climb();
}

2. Il existe deux types d'exceptions, les Exceptions standard (Exception) et les Runtime (RuntimeException https://docs.oracle.com/javase/7/doc...Exception.html ).
Les RuntimeException peuvent être jetées sans être déclaré, voir levées lors de l’exécution (comme NullPointerException).
En général, il faut utiliser les RuntimeException pour des erreurs de code et les exceptions standards pour des erreurs utilisateurs.

3. Toujours traiter une exception. La commande throws est un traitement comme un autre.

4. Utiliser, de préférence, une exception déjà existente.

Cordialement.

[Cincinnatus]

Salut,

Pour compléter la réponse de PhilippeGibault, le livre EffectiveJava est à lire après un peu d'expérience de Java, sinon, gare au mal de crâne...

Et la propagation d'exception est une façon de traiter une exception levée dans une méthode lorsque cette méthode n'est pas la meilleure pour y réagir.

Par exemple, une classe d'accès aux données va indiquer qu'elle ne peut se connecter à la base via une RuntimeException. Elle remontera l'information à la classe métier qui l'a appelée et qui pourra lancer une exception personnalisée au niveau proche de l'utilisateur (contrôleur, interface utilisateur, ...). Au niveau d'accès aux données, l'info disponible ne serait pas utile à l'utilisateur (erreur réseau ? listener qui ne répond pas ? l'utilisateur veut juste savoir si sa commande est réalisée).

[OButterlin]

Pour ce qui est des exceptions personnalisées, c'est très utile dans bien des cas applicatifs, les exceptions standards étant par nature génériques.

Un exemple où l'exception spécifique est utile est la détection d'une erreur de validation avec la liste des causes.

Dans un EJB, une seule exception peut être levée à la fois, un traitement de contrôle ne pourrait donc, à priori, envoyer qu'une cause à la fois, dans l'ordre du codage des contrôles... autant dire, pas exploitable !
On pourrait bien sûr créer un message contentant toutes les causes mais il resterait le problème de l'internationalisation des messages.
Créer une Exception contenant une liste de causes permettra de faire une passe globale de contrôle et d'envoyer la liste des problèmes avec ou sans paramètres et de laisser l'IHM s'occuper de formater le message par rapport à des fichiers properties.

Bref, c'est un exemple parmi d'autres

[olivier252]

Merci à vous pour ces réponses très complètes qui auront le mérite de donner de la matière à mes révisions. En effet les exception ne sont pas faciles à appréhender et sera l'objet de mes révisions pour la semaine prochaine.