Chapitre d'amélioration Java (16) -----Exception (1)

La philosophie de base de Java est « un code mal structuré ne fonctionnera pas » ! ! ! ! !

S'il est absent, il n'est pas défavorisé.

Da Ying Ruoyong, c'est sans fin.

Il n'y a pas de chose parfaite dans ce monde. Peu importe à quel point la pensée parfaite est méticuleuse et prudente, nous ne pouvons pas considérer tous les facteurs. L'homme sage fera une erreur à chaque fois qu'il réfléchira. De la même manière, le monde informatique n’est pas parfait. Des situations anormales peuvent survenir à tout moment. Il suffit d’éviter les exceptions qui peuvent être évitées et de gérer celles qui ne peuvent être évitées. Ici, je vais enregistrer comment utiliser les exceptions pour programmer un « monde parfait ».

 

1. Pourquoi utiliser des exceptions

Tout d'abord, nous pouvons préciser que le mécanisme de gestion des exceptions peut garantir la robustesse de notre programme. et améliorer la disponibilité du système. Même si nous n’aimons pas particulièrement le voir, nous ne pouvons nous empêcher de reconnaître son statut et son rôle. Les anomalies indiquent qu'il y a un problème avec le programme, ce qui nous aide à le corriger à temps. Dans notre programmation, des exceptions peuvent survenir à tout moment et n'importe où pour quelque raison que ce soit. Lorsqu'il n'y a pas de mécanisme d'exception, voici comment nous le gérons :

 : Utilisez la valeur de retour de la fonction pour déterminer si une exception a eu lieu. s'est produite (cette valeur de retour est généralement convenue.) Le programme appelant la fonction est responsable de la vérification et de l'analyse de la valeur de retour. Bien que les problèmes d'exception puissent être résolus, cela présente plusieurs défauts :

 1. S'il est convenu que la valeur de retour est -11111, cela indique une exception, alors que se passe-t-il si le résultat final du calcul du programme est réellement -1111 ?

                                                                                                                            . Mélanger le code de gestion des exceptions avec le code du programme rendra le code moins lisible.

3. L'analyse des exceptions en appelant des fonctions nécessite que les programmeurs aient une compréhension approfondie des fonctions de la bibliothèque.

     

Le mécanisme de gestion des exceptions fourni dans OO est un moyen puissant de fournir la robustesse du code. L'utilisation du mécanisme d'exception peut réduire la complexité du code de gestion des erreurs. Si vous n'utilisez pas d'exceptions, vous devez rechercher des erreurs spécifiques et les gérer à de nombreux endroits du programme. sur le site d'appel, car le mécanisme d'exception garantira que l'erreur est détectée et que l'erreur ne doit être traitée qu'à un seul endroit, ce qu'on appelle le gestionnaire d'exceptions. Cette approche permet non seulement d'enregistrer le code, mais sépare également le code qui décrit ce qu'il faut faire lors d'une exécution normale du code qui dit « que faire en cas de problème ». En résumé, le mécanisme d'exception rend la lecture, l'écriture et le débogage du code plus organisés que les méthodes de gestion des erreurs précédentes. (Extrait de « Pensez en java》).

Dans la première école, j'écoute toujours le professeur qui dit qu'on se souvient des endroits qui peuvent faire des erreurs pour y faire face, maintenant je continue. pour approfondir et écrire plus de codes, je comprends petit à petit que les exceptions sont très importantes.

2. Définition de base

Dans "Think in java", les exceptions sont définies comme ceci :

Une exception fait référence à un problème qui empêche la méthode ou la portée actuelle de continuer à s'exécuter . Une chose doit être claire ici : le code d'exception est erroné dans une certaine mesure. Bien que Java dispose d'un mécanisme de gestion des exceptions, nous ne pouvons pas examiner les exceptions d'un point de vue « normal ». La raison du mécanisme de gestion des exceptions est de vous dire : quelque chose. peut ou s'est déjà produit ici. Si une erreur se produit, votre programme a une situation anormale, ce qui peut entraîner l'échec du programme !

                                                                                                                                                                                                   Alors, quand une anomalie apparaîtra-t-elle ? Ce n'est que si le programme ne peut pas s'exécuter normalement dans votre environnement actuel, c'est-à-dire s'il ne peut plus résoudre le problème correctement, qu'il sortira de l'environnement actuel et lèvera une exception. Après avoir levé une exception, il effectue d'abord quelques opérations. Tout d'abord, il utilisera new pour créer un objet d'exception, puis terminera le programme à l'emplacement où l'exception est générée et affichera la référence à l'objet d'exception à partir de l'environnement actuel. Le mécanisme de gestion des exceptions prendra en charge le programme et commencera à chercher un endroit approprié pour continuer à exécuter le programme. Cet endroit approprié est le gestionnaire d'exceptions. Sa tâche est de récupérer le programme de l'état d'erreur afin que le programme puisse être exécuté dans. d'une autre manière. Ou continuez.

De manière générale, le mécanisme de gestion des exceptions est que lorsqu'une exception se produit dans le programme, il termine de force le programme, enregistre les informations d'exception et alimente ces informations. revenons à nous. Déterminons s'il faut gérer l'exception.

3. Système d'exception

java nous fournit un mécanisme de gestion des exceptions très parfait, nous permettant d'être plus En nous concentrant sur notre programme, nous devons comprendre son architecture avant d'utiliser des exceptions : comme suit (cette image est tirée de : http://www.php.cn/).

De l'image ci-dessus On peut voir que Throwable est la super classe de toutes les erreurs et exceptions du langage Java (tout peut être lancé). Il comporte deux sous-classes : Erreur et Exception.

Où Error est une erreur qui ne peut pas être gérée par le programme, comme OutOfMemoryError, ThreadDeath, etc. Lorsque cela se produit, la seule chose que vous pouvez faire est pour le laisser partir et laisser à la JVM le soin de le gérer, mais la JVM choisira de terminer le thread dans la plupart des cas.

 Une exception est une exception que le programme peut gérer. Il est divisé en deux types de CheckedException (exception vérifiée), l'un est UncheckedException (exception non vérifiée). Parmi eux, CheckException se produit pendant la phase de compilation, et try...catch (ou throws) doit être utilisé, sinon la compilation ne réussira pas. UncheckedException se produit pendant l'exécution et est incertain. Il est principalement dû à des problèmes de logique du programme et est difficile à résoudre. Nous devons généralement examiner la situation globale pour trouver de telles erreurs anormales, nous devons donc être prudents dans la conception du programme. Pensez-y, écrivez bien le code et essayez de gérer les exceptions autant que possible. Même si une exception se produit, vous pouvez essayer de vous assurer que le programme évolue dans une direction favorable.

Donc : Utilisez les exceptions vérifiées (CheckedException) pour les conditions récupérables, pour les erreurs de programme (l'implication est qu'elles ne sont pas récupérables, et une grosse erreur a été créé) ) en utilisant une exception d'exécution (RuntimeException).

                                                                                                Dans mon prochain article de blog, je compilerai des statistiques sur les exceptions qui se produisent souvent en Java. j'espère que vous ferez attention ! !

4. Utilisation anormale

J'ai vu une chose tellement drôle sur les mots Internet : La dépendance la plus véritable au monde, c'est lorsque vous essayez et que je rattrape. Peu importe à quel point vous êtes en colère, je le supporterai en silence et je le gérerai tranquillement. Pour les débutants, les exceptions sont try...catch (je le pensais aussi lorsque je suis entré en contact avec lui pour la première fois, et lorsque je rencontre des exceptions, c'est try...catch). Personnellement, je pense que try...catch est effectivement le plus utilisé et le plus pratique.

Dans l'exception, le bloc try contient le bloc de code qui peut provoquer une exception, et le bloc catch intercepte l'exception et gère l'exception. Regardons d'abord les exemples suivants :

public class ExceptionTest {
    public static void main(String[] args) {
        String file = "D:\\exceptionTest.txt";
        FileReader reader;
        try {
            reader = new FileReader(file);
            Scanner in = new Scanner(reader);  
            String string = in.next();  
            System.out.println(string + "不知道我有幸能够执行到不.....");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("对不起,你执行不到...");
        }  
        finally{
            System.out.println("finally 在执行...");
        }
    }
}

       这是段非常简单的程序，用于读取D盘目录下的exceptionText.txt文件，同时读取其中的内容、输出。首先D盘没有该文件，运行程序结果如下：

java.io.FileNotFoundException: D:\exceptionTest.txt (系统找不到指定的文件。)
    at java.io.FileInputStream.open(Native Method)
    at java.io.FileInputStream.<init>(FileInputStream.java:106)
    at java.io.FileInputStream.<init>(FileInputStream.java:66)
    at java.io.FileReader.<init>(FileReader.java:41)
    at com.test9.ExceptionTest.main(ExceptionTest.java:19)
对不起,你执行不到...
finally 在执行...

       从这个结果我们可以看出这些：

       1、当程序遇到异常时会终止程序的运行（即后面的代码不在执行），控制权交由异常处理机制处理。

       2、catch捕捉异常后，执行里面的函数。

       当我们在D盘目录下新建一个exceptionTest.txt文件后，运行程序结果如下：

1111不知道我有幸能够执行到不.....
finally 在执行...

       11111是该文件中的内容。从这个运行结果可以得出这个结果：不论程序是否发生异常，finally代码块总是会执行。所以finally一般用来关闭资源。

       在这里我们在看如下程序：

public class ExceptionTest {
    public static void main(String[] args) {
        int[] a = {1,2,3,4};
        System.out.println(a[4]);
        System.out.println("我执行了吗???");
    }
}

       程序运行结果：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
    at com.test9.ExceptionTest.main(ExceptionTest.java:14)

       各位请注意这个异常信息和上面的异常信息错误，为了看得更加清楚，我将他们列在一起：

java.io.FileNotFoundException: D:\exceptionTest.txt (系统找不到指定的文件。)
        Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4

       在这里我们发现两个异常之间存在如下区别：第二个异常信息多了Exception in thread"main"，这显示了出现异常信息的位置。在这里可以得到如下结论：若程序中显示的声明了某个异常，则抛出异常时不会显示出处，若程序中没有显示的声明某个异常，当抛出异常时，系统会显示异常的出处。

以上就是java提高篇(十六)-----异常（一）的内容，更多相关内容请关注PHP中文网（www.php.cn）！