gestion des exceptions Java

Les exceptions sont quelques erreurs dans le programme, mais toutes les erreurs ne sont pas des exceptions, et parfois des erreurs peuvent être évitées.

Par exemple, votre code moins un point-virgule, puis exécutez sur les résultats est d'inciter mal java.lang.Error; si vous utilisez System.out.println (11/0), puis vous faites parce que vous utilisez un diviseur 0 Il sera jeté java.lang.ArithmeticException exception.

Il y a plusieurs raisons pour une exception se produit, contient généralement les catégories suivantes:

• entrée de l'utilisateur des données illégales.
• Pour ouvrir un fichier n'existe pas.
• connexion de communication de réseau est un dépassement de mémoire interrompu ou JVM.

Ces exceptions soit à cause de l'erreur de l'utilisateur causé quelques erreurs de procédure ont causé parce qu'il ya d'autres erreurs physiques. -

Pour comprendre la gestion des exceptions Java est de savoir comment cela fonctionne, vous devez avoir les trois types d'exceptions suivantes:

• exception Vérifié: le plus représentatif vérifié exception est une exception due à une erreur de l' utilisateur ou d' un problème, il est le programmeur imprévisible. Par exemple, lorsque vous voulez ouvrir un fichier n'existe pas, une exception se produit, l'exception ne peut pas être simplement ignorée au moment de la compilation.
• Exception est susceptible d'être un programmeur pour éviter un fonctionnement anormal: run-time exception. Contrairement à l'exception vérifiée, l'exception d'exécution peut être ignorée au moment de la compilation.
• Erreur: erreur est pas anormal, mais à partir de la question du contrôle du programmeur. Erreur dans le code sont généralement ignorées. Par exemple, quand un débordement de pile, une erreur se produit, ils ne peuvent pas vérifier au moment de la compilation.

hiérarchie de classe d'exception

Toutes les classes d'exceptions héritent de java.lang.Exception sous-classe.

classe Exception est une sous-classe de la classe Throwable. En plus de la classe Exception, Throwable il y a une sous-classe d'erreur.

Les programmes Java ne sont généralement pas attraper l'erreur. Une erreur se produit généralement quand une faute grave, ils sont visibles en dehors de Java traitement du programme.

environnement d'exécution d'erreur utilisé pour indiquer une erreur se produit.

Par exemple, JVM débordement de mémoire. D'une manière générale, le programme ne récupère pas l'erreur.

classe Exception a deux sous-catégories principales: la classe IOException et classe RuntimeException.

Intégré dans la classe Java (la prochaine sera expliqué), il a la plupart des contrôles habituels et exception non contrôlée.

Built-in Java classe d'exception

langage Java définit plusieurs classes d'exception dans le package java.lang standard.

Standard classes d'exception d'exécution sont des sous-classes de classes d'exceptions les plus courantes. Depuis package java.lang est chargé par défaut à tous les programmes Java, donc la plupart des classes d'exception d'exécution des anomalies héréditaires peuvent être utilisés directement.

Selon diverses bibliothèque de classes Java définit également un certain nombre d'autres exceptions, le tableau suivant répertorie l'exception décochée Java.

Le tableau suivant indique le Java défini dans le package java.lang vérifié classes d'exception.

anomalie

La liste suivante est la principale méthode de classe Throwable:

Attrapez l'exception

Utilisez des mots-clés essayer et de capture peut intercepter l'exception. try / catch block en place des exceptions qui pourraient survenir.

Syntaxe du code try / catch block est appelé un code de protection en utilisant try / catch est la suivante:

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

déclaration de capture contient une exception pour capturer le type de déclaration. Lorsque le bloc de code de protection lorsqu'une exception se produit, essayez de l'arrière du bloc catch sera vérifiée.

Si l'exception contenue dans le bloc catch, l'exception sera transmis au bloc catch, et passer un paramètre à cette méthode est la même.

Exemples

L'exemple suivant a déclaré un tableau à deux éléments, lorsque le code tente d'accéder au troisième élément du tableau quand il va lancer une exception.

// 文件名 : 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");
   }
}

La compilation et de code ci-dessus courent le résultat suivant:

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

Plusieurs blocs de capture

Une pluralité de blocs de code de capture après le bloc de code est appelé un essai à suivre la capture multiple.

syntaxe multiple de bloc catch est la suivante:

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }

L'extrait de code ci-dessus contient trois blocs catch.

Vous pouvez ajouter un nombre quelconque de blocs catch derrière l'instruction try.

Si une exception se produit dans le code de protection, une exception est levée au premier bloc catch.

Si vous jetez le type de données mismatch exception de ExceptionType1, où il sera capturé.

Sinon, il sera transféré au second bloc catch.

Donc, jusqu'à ce que l'exception est interceptée par toute capture ou bloc.

Exemples

Cet exemple montre comment l'utilisation de plusieurs 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;
}

lancers / throw Mots-clés:

Si une méthode ne tient pas compte d'une exception vérifiée, la méthode doit utiliser le mot clé throws à déclarer. jette mot-clé placé à la fin de la signature de la méthode.

Vous pouvez également utiliser le mot-clé jet lancer une exception, que ce soit nouveau ou nouvellement instancié capturé.

La déclaration de méthode suivante lève une exception 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 être déclarée à jeter plusieurs exceptions, séparés par une virgule entre plusieurs exceptions.

Par exemple, la déclaration de méthode suivante throws RemoteException et InsufficientFundsException:

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

enfin mot-clé

enfin mot-clé est utilisé pour créer les blocs de code après le bloc de code essayer d'effectuer.

Que ce soit ou non une exception se produit, enfin le code de bloc de code sera toujours exécuté.

Dans le bloc finally, vous pouvez exécuter le nettoyage au lendemain de la nature du type de déclaration se terminant.

enfin bloc apparaît dans le bloc catch Enfin, la syntaxe est la suivante:

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }finally{
    // 程序代码
 }
 

Exemples

 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");
      }
   }
}

Les exemples ci-dessus les résultats compilés sont les suivants:

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

Notez que les questions suivantes:

• prises ne peut pas exister indépendamment de l'essai.
• Dans le try / catch block n'a pas ajouté après les exigences finalement obligatoires.
• Pas après le bloc try catch ni ne finalement bloquer.
• essayer, attraper, enfin ne peut pas ajouter un code entre les blocs.

Déclaration exception personnalisée

En Java, vous pouvez personnaliser exception. Les points suivants doivent se rappeler d'écrire vos propres classes d'exception.

• Toutes les exceptions doivent être sous-classes Throwable.
• Si vous voulez écrire une classe d'exception vérifiée, vous avez besoin d'hériter de la classe d'exception.
• Si vous voulez écrire une classe d'exception d'exécution, vous avez besoin d'hériter de la classe RuntimeException.

Vous pouvez définir votre propre classe d'exception comme ceci:

class MyException extends Exception{
}

Seulement classe Exception héritent de créer des classes d'exception sont vérifiés classes d'exception.

La classe InsufficientFundsException suivante est une classe d'exception définie par l'utilisateur qui hérite de Exception.

Une classe d'exception et toutes les autres classes, contient des variables et des méthodes.

Exemples

// 文件名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 montrer comment utiliser notre classe d'exception personnalisée,

Dans la classe CheckingAccount suivante contient une méthode retirer () renvoie une InsufficientFundsException d'exception.

// 文件名称 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 suivant montre comment appeler gisement de classe BankDemo CheckingAccount () et retirer () méthode.

//文件名称 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();
      }
    }
}

Compiler les trois fichiers ci-dessus, et exécuter le BankDemo programme, obtenir les résultats comme suit:

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)

exception générale

Il définit deux types d'exceptions et des erreurs dans Java.

• JVM (Java Virtual Machine) exception: exception levée par la JVM ou d' erreurs. Par exemple: classe NullPointerException, classe ArrayIndexOutOfBoundsException, classe ClassCastException.
• niveau du programme exception: programme d'API par le programme ou jetés. Par exemple IllegalArgumentException de classe, classe IllegalStateException.