3. Déclenchement d'une exception

Une exception peut être déclenchée de deux façons :
  • l'exécution du programme ne se déroule pas de la façon prévue, et la machine Java génère une exception ;
  • le programme décide lui-même de déclencher une exception, afin de signaler à la méthode appelante que quelque chose ne se déroule pas comme prévu

3.1. Exceptions déclenchées par la JVM

Nous avons déjà vu des exemples de déclenchement non prévu d'exception. Voici un exemple pour déclencher quelques exceptions et erreurs.

Exemple 106. Déclenchement d'exceptions par la JVM

// Exemple 1
 int i =  0 ;
 int j =  0 ;
 int k = i / j ;  // déclenche une java.lang.ArtithmeticException

 // Example 2
String bonjourLeMonde = null ;
 int l = s.length()  // déclenche la célèbre java.lang.NullPointerException

 // Example 3
 int [] quelquesEntier =  new  int [] {  3,  1,  4,  1,  5,  9 } ;
 int k = quelquesEntier[1000] ;  // déclenche java.lang.IndexOutOfBoundsException

Ces trois exemples sont des erreurs : il n'y a pas besoin d'écrire de code pour les gérer. Nous verrons dans la suite que ce n'est pas le cas de toutes les exceptions.

3.2. Exceptions déclenchées par l'application

Il est également possible de déclencher nos propres exceptions, qu'elles soient instances de classes fournies par l'API Java, ou de nos propres classes. Voyons cela sur l'exemple suivant.

Exemple 107. Déclenchement manuel d'une exception

if (temperature >  40) {
    throw (new Exception("Il fait trop chaud !")) ;
}

Le mot-clé throw fait partie des mots-clés réservés du langage Java, et il permet de forcer la génération d'une exception, représentée par l'objet qu'on lui passe en paramètre. Si une méthode porte en elle le déclenchement, même conditionnel, d'une exception, elle doit le déclarer dans sa signature. C'est le cas par exemple de la plupart des méthodes des classes qui gèrent les fichiers. La classe FileReader, qui permet de lire des fichiers, déclare par exemple l'exception suivante :
 public FileReader(String fileName) throws FileNotFoundException
Cette exception est déclarée sur le constructeur (ce qui est parfaitement légal). Si l'on tente de construire une instance de FileReader en fournissant un nom de fichier qui n'existe pas, notre objet ne sera pas construit, et une exception du type FileNotFoundException sera générée. On notera la différence entre la génération manuelle d'une exception qui utilise le mot-clé throw (sans s ), et la déclaration au niveau de la signature d'une méthode, qui utilise le mot-clé throws (avec un s ). Dire que la déclaration des exceptions fait partie de la signature d'une méthode est un abus de langage : en toute rigueur, elle n'en fait pas partie. Notons enfin que l'on peut également générer manuellement des runtime exception . Ces exceptions n'ont pas à être déclarées avec la signature de la méthode. Dans un programme Java, toute exception jetée explicitement doit être soit propagée vers la méthode appelante, soit traitée localement. La propagation d’une exception se fait simplement dans la déclaration de la méthode, comme dans l’exemple suivant.

Exemple 108. Propagation d'un exception

public  void jeLisUnFichier(String nomDeFichier)  throws FileNotFoundException {
   FileReader =  new FileReader(nomDeFichier) ;
}

Dans notre exemple, l'exception que peut générer la construction du FileReader est propagée à la méthode appelante, qui pourra elle-même la traiter ou la propager. Il est possible de déclarer autant d'exceptions que l'on veut dans une clause throws. Il est également possible de déclarer tout objet ancêtre des exceptions jetées, tel que Exception ou même Throwable. Cette façon de faire n'est toutefois pas très astucieuse, dans la mesure où le type de l'exception jetée porte l'information de l'erreur qui a été rencontrée.
Java langage & API
Retour au blog Java le soir
Cours & Tutoriaux
Table des matières
Introduction : un peu d'histoire
1. Java : genèse d'un nouveau langage
Programmer en Java
1. Un premier exemple
1.1. Aperçu général, cycle de vie
1.2. Un premier programme
1.3. Programmes, applets, servlets, etc...
2. Une première classe
2.1. Écriture d'une classe
2.2. Instanciation de cette classe
3. Types de base, classes et objets
3.1. Types de base
3.2. Classes et objets
Classes Object et String
1. Introduction
2. La classe Object
2.1. La méthode toString()
2.2. La méthode clone()
2.3. La méthode equals()
2.4. La méthode hashCode()
2.5. La méthode finalize()
2.6. La méthode getClass()
3. La classe String
3.1. Introduction
3.2. Construction d'un objet de type String
3.3. Concaténation, StringBuffer et StringBuilder
3.4. Concaténations de chaînes de caractères depuis Java 8
3.5. Concaténations de chaînes de caractères depuis Java 11
3.6. Extraction d'une sous-chaîne de caractères
3.7. Comparaison de deux chaînes de caractères
3.8. Méthodes de comparaisons lexicographiques
3.9. Méthode de recherche de caractères
3.10. Méthode de modification de chaîne
3.11. Méthode de duplication
3.12. Support de l'unicode, internationalisation
Structure d'une classe
1. Introduction
2. Classes
2.1. Classes publiques
2.2. Classes internes
2.3. Classe membre
2.4. Classes locales
2.5. Classes anonymes
2.6. Le mot-clé this
3. Éléments statiques
3.1. Champ statique
3.2. Cas des constantes
3.3. Bloc statique
3.4. Classe membre statique
4. Membres d'une classe, visibilité
4.1. Bloc non statique
4.2. Accès à un membre, visibilité
4.3. Les champs
4.4. Signature d'une méthode
4.5. Les méthodes
4.6. Getters et Setters
5. Constructeur, instanciation
5.1. Chargement d'une classe
5.2. Constructeurs d'une classe
5.3. Instanciation d'un objet
5.4. Destruction d'objets
5.5. Le mot-clé final
6. Énumérations
6.1. Déclaration d'une énumération
6.2. Classe énumération
6.3. Méthode toString()
6.4. Méthode valueOf()
6.5. Méthode values()
6.6. Méthode ordinal()
6.7. Méthode compareTo()
6.8. Constructeurs privés
6.9. Classe utilitaire : EnumSet
Noms, opérateurs, tableaux
1. Introduction
2. Identificateurs, noms et expressions
2.1. Identificateurs et noms
2.2. Expressions
3. Opérateurs, ordre d'exécution
3.1. Ordre d'exécution
3.2. Les opérateurs
3.3. Les opérateurs ++ et --
3.4. Les opérateurs % et /
3.5. Les opérateurs <<, >> et >>>
3.6. L'opérateur instanceof
3.7. Les opérateurs &, | et ^
3.8. Les opérateurs && et ||
3.9. L'opérateur ? ... :
3.10. Les opérateurs d'affectation
4. Tableaux
4.1. Création d'un tableau
4.2. Initialisation d'un tableau
4.3. Utilisation d'un tableau comme un Object
4.4. Tableaux de tableaux
4.5. Copie de tableaux
5. Blocs, boucles et contrôles
5.1. Blocs
5.2. Mots-clés réservés
5.3. Tests : if et switch
5.4. Boucles : for, while, do ... while
5.5. Commandes continue et break
5.6. Commandes return et goto
Nombres, précision, calculs
1. Introduction
2. Calculs
2.1. Précision
2.2. Codage des nombres flottants
2.3. Le mot-clé strictfp
2.4. Conversion de types
3. Dépassements de capacité
3.1. Cas des entiers
3.2. Cas des flottants
3.3. Bibliothèques BigInteger et BigDecimal
4. Fonctions mathématiques
4.1. Fonctions usuelles
4.2. Générateurs aléatoires
5. Classes enveloppe
5.1. Associer les types de base à des objets
5.2. Auto-boxing
Héritage, abstraction, interfaces
1. Introduction
2. Abstraction et encapsulation
2.1. Abstraction
2.2. Encapsulation
3. Héritage
3.1. Définition de l'héritage
3.2. Conséquences pour les membres
3.3. Polymorphisme
3.4. Empêcher l'héritage
4. Classes abstraites
5. Interfaces
5.1. Introduction
5.2. Définition
5.3. Java 8 et les interfaces
5.4. Utilisation des interfaces
5.5. Définition de constantes dans les interfaces
5.6. Utilité des interfaces
Packages
1. Introduction
2. Notion de paquet
2.1. Déclaration d’appartenance à un paquet
2.2. Chargement d’une classe
2.3. Choix de nom
3. Archives, chemin de recherche, classpath
3.1. Archives
3.2. Variable CLASSPATH
3.3. Notion de classloader
3.4. Bilan sur les classes chargées
3.5. Visibilité
3.6. Conseils d'écriture, bibliothèque standard
Exceptions
1. Introduction
2. Erreurs et Exceptions
2.1. Classe Throwable, notion de stack trace
2.2. Classe Error
2.3. Classe RuntimException
2.4. Classe Exception
3. Déclenchement d'une exception
3.1. Exceptions déclenchées par la JVM
3.2. Exceptions déclenchées par l'application
4. Capter une exception
4.1. Traiter une exception localement
4.2. Code de captage
5. Créer ses propres exceptions
Entrées / sorties
1. Introduction
2. Notion de fichier
2.1. Introduction
2.2. La classe File
2.3. Construction d'une instance de File
2.4. Méthodes exposées
3. Flux de sortie
3.1. Introduction, notion de flux
3.2. Écriture de caractères, classe Writer
3.3. Bufferisation, construction d'un flux sur un autre
3.4. Utilisation de PrintWriter
3.5. Écriture d'octets, OuputStream
3.6. Écriture de types primitifs : DataOutputStream
3.7. Écriture d'objets : ObjectOutputStream
4. Flux d'entrée
4.1. Introduction
4.2. Lecture de caractères, classe Reader
4.3. Bufferisation, lecture ligne par ligne
4.4. Lecture d'octets : InputStream
4.5. Lecture de types primitifs : DataInputStream
4.6. Lecture d'objets : ObjectInputStream
5. Lecture et écriture de flux croisés
5.1. Introduction
5.2. Lire des caractères sur un flux binaire : classe InputStreamReader
5.3. Écrire des caractères sur un flux binaire : classe OutputStreamWriter
5.4. Remarque sur les jeux de caractères
6. Serialization d'objets
6.1. Enjeu de la sérialization d'objets
6.2. Serialization d'un objet
6.3. Sérialization d'une grappe d'objets
6.4. Première surcharge : méthode writeObject() readObject()
6.5. Deuxième surcharge : utilisation d'un externalizer
6.6. Troisième surcharge : utilisation d'un objet proxy
7. Flux compressés
7.1. Introduction
7.2. Flux de type gzip
7.3. Flux de type zip