☾ Java / Gestion des exceptions

Le deuxième d'une série pour laquelle je ne suis pas doué pour toujours.

✴︎ Qu'est-ce qu'une exception?

Même si le programme se compile avec succès, une erreur peut se produire lors de son exécution. En Java, les erreurs qui se produisent lors de l'exécution sont appelées ** exceptions **. L'occurrence d'une exception est appelée ** une exception est levée **.

✴︎ Gestion des exceptions

Lorsqu'une exception est levée, ** le programme sera interrompu de force ** si le programme ne décrit rien pour l'exception.

Le Sample.java suivant déclenche une exception car il accède en dehors des éléments du tableau préparé.

1¥Sample.java

public class Sample {
  public static void main(String[] args) {
    int[] num = {10, 20, 30};
    for (int i=0; i<4; i++) {
      System.out.print("num :" + num[i]);
      System.out.println(" : " + (i+1) + "Deuxième boucle"); 
    }
    System.out.println("--end--");
  }
}

Résultat d'exécution

num : 10 :1ère boucle
num : 20 :Deuxième boucle
num : 30 :3e boucle
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        at Sample.main(Sample.java:5)

Dans cet Sample.java, un tableau est préparé et chaque élément est généré à l'aide de l'instruction for. Cependant, l'environnement d'exécution Java lève une exception car la quatrième boucle accède en dehors des éléments du tableau. En regardant le résultat de l'exécution, vous pouvez voir que le programme s'est terminé à mi-chemin car le "--end--" sur la 8ème ligne n'est pas sorti. Les applications qui continuent de s'exécuter ne doivent pas être interrompues en raison d'éventuelles erreurs d'exécution. Par conséquent, Java utilise un mécanisme appelé ** gestion des exceptions **. La gestion des exceptions décrit ce qu'il faut faire si une exception se produit, ce qui permet au programme de continuer l'exécution sans être tué.

✴︎ exceptions cochées et non cochées

Les classes d'exceptions Java sont divisées en deux types: ** exceptions vérifiées ** et ** exceptions non vérifiées . L'exception vérifiée est une exception qui se produit en raison d'un environnement autre que l'environnement d'exécution Java tel que DB. D'un autre côté, les exceptions non vérifiées sont des exceptions qui se produisent en raison d'un programme en cours d'exécution ( exception d'exécution **) et des exceptions qui ne peuvent pas être récupérées par le traitement des exceptions de programme telles qu'une mémoire insuffisante. Une caractéristique des exceptions vérifiées est que ** la gestion des exceptions est obligatoire **. Les exceptions non cochées, en revanche, signifient que la gestion des exceptions est ** facultative plutôt qu'obligatoire **. En outre, les classes d'exception sont classées dans les trois types suivants.

• Classe d'erreur et ses sous-classes (exception non cochée) --RuntimeException classe et ses sous-classes (exception non cochée) --Sous-classes d'exception autres que la classe RuntimeException (exception vérifiée)

La classe ** Throwable ** est la classe racine de la classe d'exception. Les classes ** Error ** et ** Exception ** sont fournies en tant que sous-classes de la classe Throwable. La classe Error exprime une erreur fatale qui se produit dans l'environnement d'exécution Java, telle qu'une mémoire insuffisante, et il est difficile pour l'application de gérer cette exception, de sorte que le traitement de l'exception de cette classe et de cette sous-classe est ** facultatif ** Il est devenu. La classe Exception exprime une erreur qui se produit dans une application, telle que «un programme a essayé d'écrire dans un fichier mais le fichier n'existait pas» ou «accédé en dehors d'un élément du tableau». Cependant, pour réussir la compilation, il existe deux cas où vous devez décrire le traitement de ces exceptions et le cas où vous n'avez pas besoin de le décrire. Cette décision n'est pas prise par ce qui est fait, mais par ** quelles classes d'exceptions peuvent se produire à la suite du traitement **. ** Facultatif ** pour la classe RuntimeException et ses sous-classes, ** Obligatoire ** pour les sous-classes d'exceptions autres que la classe RuntimeException.

✴︎ Principales classes d'exceptions

Voici quelques-unes des classes d'exception fournies par Java, en se concentrant sur le nom de la classe d'exception et si elle est incluse dans les exceptions non cochées ou cochées. De plus, comme les classes d'exceptions écrites en ** gras ** ont une fréquence élevée de questions, il est judicieux de vérifier quand l'exception se produit.

1. Sous-classe d'erreur (exception non cochée: la gestion des exceptions est facultative)

2. Sous-classe de RuntimeException (exception non cochée: la gestion des exceptions est facultative)

3. Sous-classes d'exceptions autres que RuntimeException (exception cochée: la gestion des exceptions est requise)

✴︎ Définition de la classe d'exception d'origine

Java fournit de nombreuses classes d'exceptions, mais les programmeurs peuvent également définir leurs propres classes d'exceptions. Généralement, il est défini comme une classe publique qui hérite de la classe Exception.

Sample.java

[Qualificatif]classe nom de classe étend l'exception{ }
Exemple) la classe publique MyException étend l'exception{ }

En héritant de la classe Exception, vous hériterez des méthodes fournies par la classe Exception et sa superclasse, la classe Throwable. La classe Throwable fournit des méthodes pour extraire les messages d'erreur des exceptions et des méthodes pour suivre les erreurs et identifier où elles se produisent (suivi des erreurs).

Méthodes principales jetables

✴︎ bloc try-catch-finally

Il existe deux façons de gérer les exceptions en Java.

• Gestion des exceptions de bloc try-catch-finally
• Gestion des exceptions par mot-clé throws

Dans cette section, nous examinerons la gestion des exceptions en utilisant le bloc ** try-catch-finally **. Le bloc try-catch-finally se compose d'un bloc try, d'un bloc catch et d'un bloc finally, et chaque bloc décrit le processus comme suit.

Sample.java

void method() {
  try {
Traitement susceptible de provoquer une exception;
  } catch (Nom de la classe d'exception Nom de la variable) {
Que faire lorsqu'une exception se produit;
  } finally {
Le processus que vous souhaitez exécuter;
  }
}

Le rôle de chaque bloc est le suivant.

--try block: entoure l'endroit où une exception est susceptible de se produire avec un bloc try --catch block: définit le traitement lorsqu'une exception se produit dans le bloc catch --finally block: définissez le processus que vous souhaitez exécuter dans le bloc finally, qu'une exception se produise ou non.

C'est le rôle du bloc try-catch-finally de recevoir les objets d'exception lancés depuis l'environnement d'exécution Java. Le bloc catch est écrit avec la syntaxe suivante.

Sample.java

catch (Nom de la classe d'exception Nom de la variable) { }
(Exemple) catch(ArrayIndexOutOfBoundsException e) { …… }

1 \ Sample.java lève une exception appelée ArrayIndexOutOfBoundsException, définissez-la comme dans l'exemple ci-dessus. Il n'est pas nécessaire de décrire tous les blocs de try-catch-finally. Les combinaisons suivantes sont possibles.

• try-finally
• try-catch-finally

Utilisons maintenant le bloc try-catch pour ajouter la gestion des exceptions à l'exemple précédent.

2¥Sample.java

public class Main {
  public static void main(String[] args) {
    int[] num = {10, 20, 30};
    for (int i=0; i<4; i++) {
      try {
        System.out.print("num :" + num[i]);
        System.out.println(" : " + (i+1) + "Deuxième boucle");
      } catch (ArrayIndexOutOfBoundsException e) {    //8ème ligne
        System.out.println("Une exception s'est produite");
      }
    }
    System.out.println("--end--");    //12ème ligne
  }
}

Résultat d'exécution

num : 10 :1ère boucle
num : 20 :Deuxième boucle
num : 30 :3e boucle
Une exception s'est produite
--end--

Similaire à 1 \ Sample.java, l'exception est déclenchée dans la 4ème boucle, mais l'objet d'exception est intercepté dans le bloc catch sur la 8ème ligne. En conséquence, il peut être confirmé que le traitement de la 12e ligne est exécuté en continu sans terminer de force le programme.

Utilisez le bloc `finally s'il y a quelque chose que vous voulez faire, qu'une exception se produise ou non. Par exemple, libérer des ressources (comme fermer une base de données ou fermer un fichier). ''

✴︎ Plusieurs définitions de bloc catch

Vous pouvez définir plusieurs blocs catch pour gérer plusieurs classes d'exceptions pouvant survenir dans un bloc try.

Sample.java

} catch (Nom de la classe d'exception Nom de la variable) {
En traitement;
} catch (Nom de la classe d'exception Nom de la variable) { }

Cependant, s'il existe une relation d'héritage entre les classes d'exceptions spécifiées dans le bloc catch, ** décrire du côté de la sous-classe **. L'écriture à partir d'une super classe entraînera une erreur de compilation.

✴︎ throws En plus de la gestion des exceptions par le bloc try-catch-finally, la gestion des exceptions par le mot clé ** throws ** est possible. Dans cette méthode, spécifiez «** throws exception class name **» lors de la définition d'une méthode susceptible de déclencher une exception. Par conséquent, si un objet de la classe d'exception spécifiée par throws se produit dans la méthode, l'objet d'exception est ** transmis à l'appelant de la méthode **. La syntaxe est la suivante:

Sample.java

[Qualificatif]Type de retour Nom de la méthode(Liste d'arguments)lance le nom de la classe d'exception{ }

Pour le nom de la classe d'exception, spécifiez le nom de la classe d'exception qui peut se produire dans cette méthode et que vous souhaitez transmettre à l'appelant de la méthode. S'il y a plusieurs classes d'exceptions à spécifier, répertoriez les noms de classes d'exceptions séparés par "," (virgule).

3¥Sample.java

class Test {
  void loop() throws ArrayIndexOutOfBoundsException {
    int[] num = {10, 20, 30};
    for (int i=0; i<4; i++) {
      System.out.println("num : " + num[i]);
    }
  }
}

public class Sample {
  public static void main(String[] args) {
    try {
      Test t = new Test();
      t.loop();
    } catch (ArrayIndexOutOfBoundsException e) {
      System.out.println("Une exception s'est produite");
    }
    System.out.println("--end--");
  }
}

Résultat d'exécution

num : 10
num : 20
num : 30
Une exception s'est produite
--end--

La méthode loop () de la classe Test est explicitement définie pour lever une exception ArrayIndexOutOfBoundsException. En regardant le résultat de l'exécution, vous pouvez voir que l'exception qui s'est produite du côté de la méthode loop () est transmise au côté de la méthode main (), et le bloc catch de la méthode main () la reçoit. Même si vous supprimez la partie " throws ArrayIndexOutOfBoundsException ", une exception ArrayIndexOutOfBoundsException sera levée et le résultat de l'exécution sera le même. Cela est dû au fait que la classe d'exception (ArrayIndexOutOfBoundsException) qui s'est produite est une exception non vérifiée et que la gestion des exceptions n'est pas obligatoire, elle peut donc être compilée et exécutée sans problème.

✴︎ throw Les exceptions peuvent être levées non seulement par l'exécutable Java, mais aussi explicitement dans le programme à l'aide du mot clé ** throw **. C'est très similaire au mot clé throws ci-dessus, mais veillez à ne pas vous confondre. Vous pouvez utiliser le mot clé throw pour lancer un objet d'exception qui instancie une classe d'exception fournie par Java ou votre propre classe d'exception n'importe où.

Sample.java

lancer un objet d'exception;
(Exemple 1) lancer une nouvelle IOException();
(Exemple 2) IOException e= new IOException();
　　  throw e;

Ce qui suit définit la classe MyException comme une classe d'exception unique. Et dans la méthode checkAge () de la classe Sample, si une valeur inférieure à 0 est passée en argument, un objet MyException est créé et explicitement lancé avec le mot clé throw.

4¥Sample.java

class MyException extends Exception {    //Classe d'exception propriétaire
  private int age;
  public void setAge(int age) { this.age = age; }
  public int getAge() { return this.age; }
}

public class Sample {
  public static void main(String[] args) {
    try {
      int age = -10;
      checkAge(age);    //11ème ligne
    } catch (MyException e) {    //12ème ligne
      System.out.println("Valeur illégale. âge: " + e.getAge());    //13ème ligne
    }
  }
  public static void checkAge(int age) throws MyException {    //16e ligne
    if (age>=0) {
      System.out.println("OK");
    } else {    //Ligne 19
      MyException e = new MyException();    //20e ligne
      e.setAge(age);
      throw e;    //Ligne 22
    }
  }
}

Résultat d'exécution

Valeur illégale. âge: -10

La ligne 11 appelle la méthode checkAge () définie à la ligne 16. La 17e ligne évalue si la valeur de la variable d'âge reçue en tant qu'argument est égale ou supérieure à 0. S'il n'est pas égal à 0 ou plus, le contrôle passe à la 19e ligne ou moins. Ensuite, la classe d'exception d'origine préparée dans la première ligne est instanciée dans la 20e ligne et explicitement lancée dans la 22e ligne. L'exception levée est interceptée sur la ligne 12 de l'appelant de la méthode checkAge () et le message est imprimé sur la ligne 13.

Les précautions pour passer outre reviennent.