Une brève introduction aux exceptions et à l'architecture Java

Cet article partage principalement l'introduction et l'architecture des exceptions Java, qui ont une certaine valeur de référence. Les amis intéressés peuvent se référer à

Introduction aux exceptions Java

Les exceptions Java sont un mécanisme cohérent fourni par Java pour identifier et répondre aux erreurs.

Le mécanisme d'exception Java peut séparer le code de

gestion des exceptions et le code métier normal dans le programme, garantissant que le code du programme est plus élégant et améliorant la robustesse du programme. Lorsque les exceptions sont utilisées efficacement, les exceptions peuvent répondre clairement aux trois questions quoi, où, pourquoi : le type d'exception répond à "ce qui" a été généré et la trace de la pile d'exceptions répond "où" elle a été générée. le message d'exception répond "pourquoi" il est émis. Plusieurs mots-clés utilisés dans le mécanisme d'exception Java :
essayer, attraper, enfin, lancer, lancers. • essayez — pour la surveillance. Placez le code à surveiller (code qui peut
lever une exception ) dans le bloc instruction try Lorsqu'une exception se produit dans le bloc d'instruction try, l'exception sera levée. • catch -- utilisé pour intercepter les exceptions. catch est utilisé pour intercepter les exceptions qui se produisent dans le bloc d'instruction try.
• final -- Le bloc final sera toujours exécuté. Il est principalement utilisé pour recycler les ressources physiques (telles que les connexions à la base de données, les connexions réseau et les fichiers disque) ouvertes dans les blocs try. Seul le bloc final, une fois l'exécution terminée, reviendra pour exécuter l'instruction return ou throw dans le bloc try ou catch. Si une instruction telle que return ou throw est utilisée dans le bloc final, elle ne reviendra pas à l'exécution et. arrêter directement.
• throw -- utilisé pour lancer des exceptions.
• throws -- utilisé dans les signatures de méthode pour déclarer les exceptions qui peuvent être levées par la méthode.

Ce qui suit est une brève compréhension de ces mots-clés à travers plusieurs exemples.

Exemple 1 : Comprendre l'utilisation de base de try and catch

public class Demo1 {

  public static void main(String[] args) {
    try {
      int i = 10/0;
       System.out.println("i="+i); 
    } catch (ArithmeticException e) {
       System.out.println("Caught Exception"); 
      System.out.println("e.getMessage(): " + e.getMessage()); 
      System.out.println("e.toString(): " + e.toString()); 
      System.out.println("e.printStackTrace():");
      e.printStackTrace(); 
    }
  }
}

Résultat d'exécution :

Exception détectée e.getMessage() : / par zéro
e.toString() : java.lang.ArithmeticException : / par zéro
e.printStackTrace():
java.lang.ArithmeticException : / par zéro
à Demo1.main(Demo1.java:6)

Description du résultat : il y a une opération de division par 0 dans le bloc d'instruction try, qui lancera java .lang .ArithmeticException. Attrapez l'exception via catch.

En observant les résultats, nous avons constaté que System.out.println("i="+i) n'a pas été exécuté. Cela montre qu'après qu'une exception se produit dans le bloc d'instructions try, le contenu restant du bloc d'instructions try ne sera plus exécuté.

Exemple 2 : Comprendre l'utilisation de base definally Sur la base de « Exemple 1 », nous ajoutons l'instruction final.

public class Demo2 {

  public static void main(String[] args) {
    try {
      int i = 10/0;
       System.out.println("i="+i); 
    } catch (ArithmeticException e) {
       System.out.println("Caught Exception"); 
      System.out.println("e.getMessage(): " + e.getMessage()); 
      System.out.println("e.toString(): " + e.toString()); 
      System.out.println("e.printStackTrace():");
      e.printStackTrace(); 
    } finally {
      System.out.println("run finally");
    }
  }
}

Résultat d'exécution :

Exception interceptéee.getMessage() : / par zéro
e.toString() : java.lang.ArithmeticException : / par zéro
e.printStackTrace():
java.lang.ArithmeticException : / par zéro
à Demo2.main(Demo2.java:6)
exécuter enfin

Description du résultat : Le bloc d'instructions final est enfin exécuté.

Exemple 3 : Comprendre l'utilisation de base de throws et throwThrows est utilisé pour déclarer des exceptions levées, tandis que throw est utilisé pour lancer des exceptions.

class MyException extends Exception {
  public MyException() {}
  public MyException(String msg) {
    super(msg);
  }
}

public class Demo3 {

  public static void main(String[] args) {
    try {
      test();
    } catch (MyException e) {
      System.out.println("Catch My Exception");
      e.printStackTrace();
    }
  }
  public static void test() throws MyException{
    try {
      int i = 10/0;
       System.out.println("i="+i); 
    } catch (ArithmeticException e) {
      throw new MyException("This is MyException"); 
    }
  }
}

Résultat d'exécution :

Attraper mon exceptionMyException : ceci est MyException
sur Demo3.test(Demo3.java:24)
at Demo3.main(Demo3.java:13)

Description du résultat :

MyException est une sous-classe héritée d'Exception. Une exception ArithmeticException (le diviseur est 0) est générée dans le bloc d'instruction try de test(), et l'exception est capturée dans catch, puis une exception MyException est levée. La méthode main() capture la MyException lancée dans test().

Cadre d'exception Java

Schéma d'architecture d'exception Java

1. Throwable

Throwable est la super classe de toutes les erreurs ou exceptions dans le langage Java.

Throwable contient deux sous-classes : Error et Exception. Ils sont souvent utilisés pour indiquer que quelque chose d’inhabituel s’est produit.
Throwable contient un instantané de la pile d'exécution du thread lorsque son thread est créé. Il fournit des interfaces telles que printStackTrace() pour obtenir des données de trace de pile et d'autres informations.

2. Exception

Exception et ses sous-classes sont une forme de Throwable, qui souligne les conditions raisonnables qui l'application veut capturer.

3. RuntimeException

RuntimeException est une superclasse d'exceptions qui peuvent être levées lors du fonctionnement normal de la machine virtuelle Java.
Le compilateur ne vérifiera pas RuntimeException. Par exemple, lorsque le diviseur est nul, une ArithmeticException est levée. RuntimeException est la superclasse d'ArithmeticException. Lorsque le code est divisé par zéro, il peut toujours être compilé s'il ne "lance pas d'ArithmeticException via la déclaration throws" ni "gère l'exception via try...catch...". C'est ce que nous entendons par « le compilateur ne vérifie pas RuntimeException » !
Si le code génère une RuntimeException, vous devez modifier le code pour l'éviter. Par exemple, si une division par zéro se produit, vous devez l'éviter via le code !

4. Error

Comme Exception, Error est également une sous-classe de Throwable. Il est utilisé pour indiquer des problèmes graves que des applications raisonnables ne devraient pas tenter de détecter ; la plupart de ces erreurs sont des conditions exceptionnelles.
Comme RuntimeException, le compilateur ne recherchera pas d'erreur.

Java divise les structures jetables en trois types : Checked Exception, RuntimeException et Error.

(01) Exception d'exécution

Définition : RuntimeException et ses sous-classes sont appelées exceptions d'exécution.
Fonctionnalité : le compilateur Java ne le vérifiera pas. En d'autres termes, lorsque ce type d'exception peut se produire dans le programme, si elle n'est ni levée via l'instruction throws ni interceptée avec une instruction try-catch, elle sera quand même compilée. Par exemple, ArithmeticException générée lorsque le diviseur est zéro, IndexOutOfBoundsException générée lorsque le tableau franchit la limite, ConcurrentModificationException générée par le mécanisme fail-fail, etc., sont toutes des exceptions d'exécution.
Bien que le compilateur Java ne vérifie pas les exceptions d'exécution, nous pouvons également le déclarer via des lancers ou l'attraper via try-catch.
Si une exception d'exécution se produit, vous devez modifier le code pour l'éviter. Par exemple, si une division par zéro se produit, vous devez l'éviter via le code !

(02) Exception vérifiée

définition : classe Exception elle-même et autres sous-classes des sous-classes d'exception à l'exception de "l'exception d'exécution" C'est une exception vérifiée.
Fonction : le compilateur Java le vérifiera. De telles exceptions doivent être soit déclarées et lancées via des lancers, soit interceptées et gérées via try-catch, sinon elles ne peuvent pas passer la compilation. Par exemple, CloneNotSupportedException est une exception vérifiée. Lorsqu'un objet est cloné via l'interface clone() et que la classe correspondant à l'objet n'implémente pas l'interface Cloneable, une exception CloneNotSupportedException sera levée.
Les exceptions vérifiées sont généralement récupérables.

(03) Définition d'erreur

 : Classe d'erreur et ses sous-classes.
Fonctionnalités : comme les exceptions d'exécution, le compilateur ne recherchera pas les erreurs.
Lorsque les ressources sont insuffisantes, que les contraintes échouent ou que d'autres conditions surviennent qui empêchent le programme de continuer à s'exécuter, une erreur se produit. Le programme lui-même ne peut pas corriger ces erreurs. Par exemple, VirtualMachineError est une erreur.
Selon la convention Java, nous ne devons implémenter aucune nouvelle sous-classe Error !
Pour les trois structures ci-dessus, laquelle devons-nous utiliser lors du lancement d'une exception ou d'une erreur ? Le conseil donné dans "Effective Java" est d'utiliser des exceptions vérifiées pour les conditions récupérables et des exceptions d'exécution pour les erreurs de programme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!