Solutions du chapitre 14

Solutions du chapitre 14
Traitement des exceptions
14.16
Sous quelles circonstances utiliseriez-vous l’instruction suivante?
catch ( Exception e ) { throw e; }
RÉP.: Cette instruction sert à capturer toute exception et à la relancer pour qu’elle soit gérée par un gestionnaire d’exception
placé dans un appel de méthode précédent dans la pile d’appel de méthodes.
14.17
reurs.
Dénombrez les bénéfices qu’apporte le traitement des exceptions par rapport aux méthodes habituelles de traitement des er-
14.18
Décrivez une technique orientée objets de gestion d’exceptions apparentées.
RÉP.: Créer une superclasse pour toutes les exceptions liées. Dans cette classe, placer toutes les fonctionnalités que les exceptions possèdent en commun. À partir de cette classe, dériver toutes les classes d’exceptions nécessaires. Une fois la hiérarchie de classes établie, les exceptions de cette hiérarchie sont ensuite susceptibles d’une capture soit sous la forme du type
d’exception de la superclasse, soit comme l’un des types de sous-classe de cette exception.
14.19 Jusqu’à ce chapitre, nous avons considéré que la gestion des erreurs détectées par les constructeurs est quelque peu malaisée.
Expliquez pourquoi le traitement des exceptions est une voie efficace qui permet la gestion des échecs des constructeurs.
RÉP.: Une exception levée transmet au monde extérieur des informations relatives au constructeur défaillant et la responsabilité de gérer la défaillance. Les exceptions levées dans les constructeurs provoquent le marquage pour une éventuelle collecte d’ordures des objets construits et faisant partie de l’objet en cours de construction.
14.20 Supposez qu’un programme lance une exception et que le gestionnaire d’exception adéquat commence à s’exécuter. Supposez à présent que le gestionnaire d’exception lui-même lance la même exception. Ceci provoque-t-il une récursion infinie? Détaillez
votre réponse.
RÉP.: Non. L’exception précédente est perdue et l’exception la plus récente est levée dans le bloc catch.
14.21 Utilisez l’héritage pour créer une superclasse d’exception et diverses sous-classes d’exception. Écrivez un programme de démonstration que le catch qui spécifie la superclasse intercepte aussi les exceptions des sous-classes.
RÉP.:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Solution de l’exercice 14.21.
// Demo.java
// Ce programme montre qu’une superclasse d’exception
// capture les exceptions de ses sous-classes.
import javax.swing.*;
class ExceptionA extends Exception {}
class ExceptionB extends ExceptionA {}
class ExceptionC extends ExceptionB {}
public class Demo {
public static void main( String args[] )
{
try {
throw new ExceptionC();
COPYRIGHT 2001 LES ÉDITIONS REYNALD GOULET INC. TOUTE REPRODUCTION INTERDITE.
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
}
catch( ExceptionA a ) {
JOptionPane.showMessageDialog(
null, a.toString(), "Exception",
JOptionPane.INFORMATION_MESSAGE );
}
try {
throw new ExceptionB();
}
catch( ExceptionA b ) {
JOptionPane.showMessageDialog(
null, b.toString(), "Exception",
JOptionPane.INFORMATION_MESSAGE );
}
System.exit( 0 );
}
}
14.22 Écrivez un programme en Java qui montre que tous les finaliseurs des objets construits dans un bloc ne sont pas nécessairement appelés après la levée d’une exception à partir de ce bloc.
RÉP.:
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
//
//
//
//
Solution de l’exercice 14.22.
Demo.java
Ce programme montre que tous les finaliseurs ne sont pas nécessairement
appelés lorsqu’une exception apparaît.
class ExceptionA extends Exception {}
public class Demo {
private final static int DELAI = 40;
public static void main( String args[] )
{
Objet1 obj = new Objet1( "Robert" );
obj =
new Objet1( "Marielle" );
// Essayer de forcer la collecte d’ordures.
System.gc();
System.gc();
try {
throw new ExceptionA();
}
catch( ExceptionA a ) {
System.out.println( "ExceptionA s’est produite" );
System.exit( 0 );
}
System.exit( 0 );
}
}
class Objet1 {
private String nom;
COPYRIGHT 2001 LES ÉDITIONS REYNALD GOULET INC. TOUTE REPRODUCTION INTERDITE.
36
37
38
39
40
41
42
43
44
public Objet1( String n ) {
nom = n;
System.out.println( "Créé un objet1 appelé " + nom );
}
protected void finalize() {
System.out.println( "Détruit un objet1 appelé " + nom );
}
}
Créé un objet1 appelé Robert
Créé un objet1 appelé Marielle
Détruit un objet1 appelé Robert
ExceptionA s’est produite
14.23
Écrivez un programme en Java qui démontre comment diverses exceptions sont capturées par l’expression:
catch ( Exception e )
RÉP.:
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
// Solution de l’exercice 14.23.
// Demo2.java
// Ce programme montre la capture d’une Exception e.
class ExceptionA extends Exception {}
class ExceptionB extends ExceptionA {}
public class Demo2 {
public static void main( String args[] )
{
try {
throw new ExceptionA();
} catch( Exception e ) {
System.out.println( e.toString() );
}
try {
throw new ExceptionB();
} catch( Exception e ) {
System.out.println( e.toString() );
}
try {
throw new NullPointerException();
} catch( Exception e ) {
System.out.println( e.toString() );
}
}
}
ExceptionA
ExceptionB
java.lang.NullPointerException
14.24 Écrivez un programme en Java qui montre que l’ordre des gestionnaires d’exception est important. Si vous essayez de capturer une exception d’un type de superclasse avant un type de sous-classe, le compilateur génère des erreurs. Expliquez pourquoi
ces erreurs apparaissent.
RÉP.:
COPYRIGHT 2001 LES ÉDITIONS REYNALD GOULET INC. TOUTE REPRODUCTION INTERDITE.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Solution de l’exercice 14.24, partie II.
// ErreurDeCompilation.java
// Ce programme génère une erreur de compilation.
import java.io.*;
public class ErreurDeCompilation {
public static void main( String args[] )
{
try {
throw new IOException();
}
catch ( Exception e ) {
e.printStackTrace();
}
catch ( IOException io ) {
System.err.println( "IOException" );
}
}
}
ErreurDeCompilation.java:15: catch not reached.
catch ( IOException io ) {
^
1 error
14.25 Écrivez un programme en Java qui montre un constructeur passant des informations relatives à un échec à la construction,
à un gestionnaire d’exception situé après un bloc try.
RÉP.:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Solution de l’exercice 14.25.
// Demo3.java
// Ce programme montre un constructor qui lève une exception.
class QuelquException {
public QuelquException() throws Exception
{
throw new Exception();
}
}
public class Demo3 {
public static void main( String args[] )
{
QuelquException o;
try {
o = new QuelquException();
} catch( Exception e ) {
System.out.println( e.toString() );
}
}
}
java.lang.Exception
14.26
1
2
Écrivez un programme en Java qui illustre le relancement d’une exception.
RÉP.:
// Solution de l’exercice 14.26.
// Demo4.java
COPYRIGHT 2001 LES ÉDITIONS REYNALD GOULET INC. TOUTE REPRODUCTION INTERDITE.
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
// Ce programme montre le relancement d’une exception.
import javax.swing.*;
public class Demo4 {
public static void main( String args[] )
{
try {
methodeQuelconque();
}
catch( Exception e ) {
JOptionPane.showMessageDialog(
null, "Gérée dans main: " + e, "Exception",
JOptionPane.INFORMATION_MESSAGE );
}
System.exit( 0 );
}
public static void methodeQuelconque() throws Exception
{
try {
methodeQuelconque2();
}
catch( Exception e ) {
throw e;
// Relancer l’exception.
}
}
public static void methodeQuelconque2() throws Exception
{ throw new Exception(); }
}
14.27 Écrivez un programme en Java qui montre qu’une méthode qui a son propre bloc try n’est pas obligée de capturer toute
erreur possible, générée au sein du try. Quelques exceptions peuvent passer à travers les mailles du filet et se voir traitées sous
d’autres étendues.
RÉP.:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Solution de l’exercice 14.27.
// Demo5.java
// Ce programme montre comment relancer une exception.
import javax.swing.*;
class ExceptionA extends Exception {}
public class Demo5 {
public static void main( String args[] )
{
try {
methodeQuelconque();
}
catch( Exception e ) {
JOptionPane.showMessageDialog(
null, "Gérée dans main: " + e, "Exception",
JOptionPane.INFORMATION_MESSAGE );
}
System.exit( 0 );
COPYRIGHT 2001 LES ÉDITIONS REYNALD GOULET INC. TOUTE REPRODUCTION INTERDITE.
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
}
public static void methodeQuelconque() throws Exception
{
try {
methodeQuelconque2();
}
catch( ExceptionA e ) {
// Ne capture pas Exception, mais seulement ExceptionA.
JOptionPane.showMessageDialog(
null, "Handled execeptionA in methodeQuelconque: " + e, "Exception",
JOptionPane.INFORMATION_MESSAGE );
}
}
public static void methodeQuelconque2() throws Exception
{ throw new Exception(); }
}