Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Les exceptions

La Programmation Orientée Objet en Java : Les exceptions

Une exception est un problème qui se pose lors de l'exécution d'un programme. Une exception peut se produire pour plusieurs raisons différentes, y compris les suivantes:

  • Un utilisateur a saisi des données non valides.
  • Un fichier qui doit être ouvert ne peut pas être trouvé.
  • Une connexion réseau a été perdue au milieu des communications ou la JVM n'a plus de mémoire.

Certaines de ces exceptions sont causées par l'erreur de l'utilisateur, d'autres par l'erreur du programmeur et d'autres par des ressources physiques qui ont échoué d'une manière ou d'une autre.

Pour comprendre comment la gestion des exceptions fonctionne en Java, vous devez comprendre les trois catégories d'exceptions:

  • Exceptions vérifiées : une exception contrôlée est une exception qui est généralement une erreur d'utilisateur ou un problème qui ne peut pas être prévu par le programmeur. Par exemple, si un fichier doit être ouvert, mais le fichier ne peut pas être trouvé, une exception survient. Ces exceptions ne peuvent être simplement ignorées au moment de la compilation.
  • Exceptions d'exécution: une exception d'exécution est une exception qui a probablement été évitée par le programmeur. Par opposition aux exceptions vérifiées, les exceptions d'exécution sont ignorées au moment de la compilation.
  • Erreurs: ce ne sont pas des exceptions, mais des problèmes qui échappent au contrôle de l'utilisateur ou du programmeur. Les erreurs sont généralement ignorées dans votre code car vous pouvez rarement faire une erreur. Par exemple, si un débordement de pile survient, une erreur surgira. Ils sont également ignorés au moment de la compilation.

Hiérarchie d'exception

Toutes les classes d'exception sont des sous-types de la classe java.lang.Exception . La classe d'exception est une sous-classe de la classe Throwable. Outre la classe d'exception, il existe une autre sous-classe appelée Erreur dérivée de la classe Throwable.

Les erreurs ne sont normalement pas prises en charge dans les programmes Java. Ces conditions se produisent normalement en cas de pannes graves, qui ne sont pas traitées par les programmes java. Des erreurs sont générées pour indiquer les erreurs générées par l'environnement d'exécution. Exemple: JVM est hors mémoire. Normalement, les programmes ne peuvent pas se remettre des erreurs.

La classe Exception comporte deux sous-classes principales: Classe IOException et Classe RuntimeException.

Ici, une liste des exceptions Java intégrées les plus courantes et non vérifiées.

Méthodes de la classe Exception

Voici la liste des méthodes importantes disponibles dans la classe Throwable.

SN

Méthodes avec description

1

public String getMessage()
Renvoie un message détaillé sur l'exception qui s'est produite. Ce message est initialisé dans le constructeur Throwable.

2

public Throwable getCause()
Renvoie la cause de l'exception telle que représentée par un objet Throwable.

3

public String toString()
Renvoie le nom de la classe concaténée avec le résultat de getMessage()

4

public void printStackTrace()
Affiche le résultat de toString() avec la trace de la pile vers System.err , le flux de sortie d'erreur.

5

public StackTraceElement[] getStackTrace()
Renvoie un tableau contenant chaque élément sur la trace de la pile. L'élément à l'index 0 représente le haut de la pile d'appels et le dernier élément du tableau représente la méthode en bas de la pile d'appels.

6

public Throwable fillInStackTrace()
Remplit la trace de la pile de cet objet Throwable avec la trace de la pile en cours, en ajoutant à toute information précédente dans la trace de la pile.

Intercepter les exceptions

Une méthode attrape une exception en utilisant une combinaison des mots clés try and catch. Un bloc try/catch est placé autour du code qui pourrait générer une exception. Le code dans un bloc try/catch est appelé code protégé et la syntaxe d'utilisation de try/catch ressemble à la suivante:

try{
   //Protected code
}catch(ExceptionName e1){
   //Catch block
}

Une déclaration de capture implique de déclarer le type d'exception que vous essayez d'attraper. Si une exception se produit dans un code protégé, le bloc de capture (ou blocs) qui suit le try est attrapé. Si le type d'exception qui s'est produite est répertorié dans un bloc catch, l'exception est transmise au bloc catch tant qu'un argument est passé dans un paramètre de méthode.

Exemple:

Voici un tableau qui est déclaré avec 2 éléments. Ensuite, le code tente d'accéder au 3ème élément du tableau qui lance une exception.

//File Name : ExcepTest.java
import java.io.*;
public class ExcepTest{
   public static void main(String args[]){
      try{
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

 Cela produirait le résultat suivant:

Exception thrown : java.lang.ArrayIndexOutOfBoundsException: 3

Out of the block

 Blocs de capture multiples

Un bloc try/catch peut être suivi de blocs de capture multiples. La syntaxe des blocs de capture multiples ressemble à la suivante:

try{
   //Protected code
}catch(ExceptionType1 e1){
   //Catch block
}catch(ExceptionType2 e2){
   //Catch block
}catch(ExceptionType3 e3){
   //Catch block
}

Les déclarations précédentes démontrent trois blocs de capture, mais vous pouvez en avoir un certain nombre après un seul try. Si une exception se produit dans le code protégé, l'exception est lancée sur le premier bloc de capture dans la liste. Si le type de données de l'exception lancée correspond à ExceptionType1, il est pris ici. Sinon, l'exception passe à la deuxième instruction catch. Cela se poursuit jusqu'à ce que l'exception soit prise ou tombe à travers toutes les prises, auquel cas la méthode actuelle arrête l'exécution et l'exception est rejetée à la méthode précédente sur la pile d'appel.

Exemple:

Voici un segment de code montrant comment utiliser plusieurs instructions try/catch.

try{
   file = new FileInputStream(fileName);
   x = (byte) file.read();
}catch(IOException i){
   i.printStackTrace();
   return -1;
}catch(FileNotFoundException f) //Not valid!{
   f.printStackTrace();
   return -1;
}

Les  mots-clés throws/throw

Si une méthode ne gère pas une exception contrôlée, la méthode doit la déclarer en utilisant le mot-clé throws. Le mot-clé throws apparaît à la fin de la signature d'une méthode.

Vous pouvez lancer une exception, une nouvelle instancie ou une exception que vous venez de capturer, en utilisant le mot-clé throw. Essayez de comprendre les différents entre throws/throw.

La méthode suivante déclare qu'elle lance une RemoteException :

import java.io.*;
public class className
{
   public void deposit(double amount) throws RemoteException
   {
      //Method implementation
      throw new RemoteException();
   }
   //Remainder of class definition
}

Une méthode peut déclarer qu'elle lance plus d'une exception, auquel cas les exceptions sont déclarées dans une liste séparée par des virgules. Par exemple, la méthode suivante déclare qu'elle lance une RemoteException et une InsufficientFundsException :

import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       //Method implementation
   }
   //Remainder of class definition
}

Le mot-clé finally

Le mot-clé finally est utilisé pour créer un bloc de code qui suit un bloc try. Un bloc de code finally s'exécute toujours, qu'il s'agisse ou non d'une exception.

L'utilisation d'un bloc final vous permet d'exécuter des instructions de type nettoyage que vous souhaitez exécuter, peu importe ce qui se passe dans le code protégé.

Un bloc final apparaît à la fin des blocs de capture et possède la syntaxe suivante:

try{
   //Protected code
}catch(ExceptionType1 e1){
   //Catch block
}catch(ExceptionType2 e2){
   //Catch block
}catch(ExceptionType3 e3){
   //Catch block
}finally{
   //The finally block always executes.
}

Exemple:

public class ExcepTest{
   public static void main(String args[]){
      int a[] = new int[2];
      try{
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      finally{
         a[0] = 6;
         System.out.println("First element value: " +a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

Cela produirait le résultat suivant:

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3

First element value: 6

The finally statement is executed

 Notez ce qui suit:

  • Une clause catch ne peut pas exister sans une instruction try.
  • Il n'est pas obligatoire d'avoir le bloc finally quand un bloc try/catch est présent.
  • Le bloc try ne peut être présent sans aucune clause catch ou finally.
  • Tout code ne peut pas être présent entre le try, le catch, finally.

Déclarer votre propre exception

Vous pouvez créer vos propres exceptions en Java. Gardez les points suivants à l'esprit lors de l'écriture de vos propres classes d'exception:

  • Toutes les exceptions doivent être un enfant de Throwable.
  • Si vous souhaitez écrire une exception vérifiée qui est automatiquement appliquée par la règle Handle ou Declare, vous devez étendre la classe Exception.
  • Si vous souhaitez écrire une exception d'exécution, vous devez étendre la classe RuntimeException.

Nous pouvons définir notre propre classe d'exception comme ci-dessous:

class MyException extends Exception{
}

 Il vous suffit d'étendre la classe Exception pour créer votre propre classe Exception. Ceux-ci sont considérés comme des exceptions contrôlées. La classe InsufficientFundsException suivante est une exception définie par l'utilisateur qui étend la classe Exception, ce qui en fait une exception vérifiée. Une classe d'exception est comme toute autre classe, contenant des champs et des méthodes utiles.

Exemple:

//File Name InsufficientFundsException.java
import java.io.*;
public class InsufficientFundsException extends Exception
{
   private double amount;
   public InsufficientFundsException(double amount)
   {
      this.amount = amount;
   }
   public double getAmount()
   {
      return amount;
   }
}

 Pour démontrer l'utilisation de notre exception définie par l'utilisateur, la classe CheckingAccount suivante contient une withdraw( ) qui lance une InsufficientFundsException .

//File Name CheckingAccount.java
import java.io.*;
public class CheckingAccount
{
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
   public void deposit(double amount)
   {
      balance += amount;
   }
   public void withdraw(double amount) throws
                              InsufficientFundsException
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   public double getBalance()
   {
      return balance;
   }
   public int getNumber()
   {
      return number;
   }
}

 Le programme BankDemo suivant démontre l'invocation des méthodes de deposit( ) et de withdraw() de CheckingAccount .

//File Name BankDemo.java
public class BankDemo
{
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)
      {
         System.out.println("Sorry, but you are short $" + e.getAmount());
         e.printStackTrace();
      }
    }
}

Compilez tous les trois fichiers ci-dessus et exécutez BankDemo, cela produirait le résultat suivant:

Depositing $500...

 

Withdrawing $100...

 

Withdrawing $600...

Sorry, but you are short $200.0

InsufficientFundsException

        at CheckingAccount.withdraw(CheckingAccount.java:25)

        at BankDemo.main(BankDemo.java:13)

 Exceptions communes

En Java, il est possible de définir deux attributions d'exceptions et d'erreurs.

  • Exceptions JVM: - Ce sont des exceptions/erreurs qui sont exclusivement ou logiquement lancées par la JVM. Exemples: NullPointerExceptionArrayIndexOutOfBoundsExceptionClassCastException,
  • Exceptions programmatiques: - Ces exceptions sont lancées explicitement par l'application ou les programmeurs API Exemples: IllegalArgumentExceptionIllegalStateException.

 




Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Les exceptions