l'architecture anormale, exception mécanisme de traitement; Exceptions Les exceptions de temps compiler et exécuter, la méthode classique, Throwable exception personnalisée (Java Jour 17)

Tout d'abord, anormale

Vue d'ensemble: Le sens littéral est pas normal. Apparu au processus de compilation ou d'exécuter du code Java ne compilera pas ou le résultat de l'exécution dans les cas concernés sont tous anormaux.
Reflect: classe de classe en utilisant les différents phénomène anormal décrit [cause de l'anomalie, la position, le type, la description et d'autres attributs]
Utilisation: l'objet de classe d'objet renvoie une objets de la classe d'exception contiennent la cause de l'anomalie se produit, le lieu, le type, la description détaillée d'autres données spécifiques.
système anormal
système:

throwable
erreur
exception
RuntimeException

explication:

Throwable: l'exception est tout parent de niveau supérieur, extrait tous les attributs communs et un comportement anormal
Erreur: l'erreur; exception appartenant à une grande branche, un moyen que le programmeur ne saisit pas le traitement d'exception peut être effectuée. Par exemple: débordement de mémoire, débordement pile
Exception: anormale, sont anormaux dans autre branche principale, des moyens que nous pouvons utiliser les prises de code d'un objet d'exception liée au traitement anormal. Par exemple: une exception de pointeur null, anomalie telle qu'une division par zéro anomalies
RuntimeException: fonctionnement anormal, ce sont ceux compilés sans problèmes, en cours d'exécution phénomène anormal se produit. Par exemple, une fracture exception de pointeur null par zéro anomalie

Gestion des exceptions

La gestion des exceptions: qui est la façon dont nous résolvons des objets insolites
Traitement: manutention manuelle, processus jvm

manutention manuelle: nous avons besoin de posséder le code lié à l' approche anormale.

Avertissement exception: quand il est venu à l'exception qu'ils ne sont pas traités, le type de déclarations d'exception à quelqu'un d'autre pour faire face à [la] utiliser le mot-clé jeter une exception jette une exception après la déclaration du type de déclarations de méthode
Scène: la méthode du corps de la méthode peut avoir un événement anormal
Format: Nom de la méthode (liste des paramètres) throws Exception {méthode} Type de celui - ci

Remarque:

déclaration inhabituelle ne représente pas l'objet d'exception sera générée, ce qui entraîne un processus à être jeté dehors, non pas traitée, la déclaration ont encore votre déclaration [déclaration sur l'affaire ne me dérangeait pas compte]
déclaration inhabituelle n'a pas sortie de la console et d'autres effets, seule une déclaration de dire aux gens [anormal] jeter l'effet des résultats anormaux [résumé] type de jet
Exceptions Exception produire une déclaration après la remise à quelqu'un d'autre en cas de manipulation ou de traitement par jvm, le code suivant ne peut pas être exécuté, si les autres gestionnaire d'exception, le code suivant continue à exécuter.

Le code échantillon

com.ujiuye.demo paquet; 
importer un java.io.FileInputStream; 
importation java.io.FileNotFoundException; 
publique  classe Demo_Exception {
     publique  statiques  vides main (String [] args) jette un FileNotFoundException {
         // créer l'objet lors de l' utilisation du procédé de construction, la structure jeter un type méthode FileNotFoundException d'exception
         // qui l' utilisent qui a jeté une méthode principale dans le corps de la méthode devra utiliser le corps pour faire face à cette anomalie
         // principale méthode de traitement , vous pouvez aussi ne veulent pas continuer à jeter l'utilisation de la déclaration inhabituelle 
        SIF de FileInputStream = new new FileInputStream ( « un b.txt \\ » );
         // anormal déclare le corps de la méthode produira l'anormal , il?
        //Lorsque le projet est un \\ b.txt d'erreur en cours d' exécution des moyens que l'objet avait anormal
         // fonctionne quand il y a un \\ b.txt en cours d' exécution ne signifie pas l'objet d'exception d'erreur ne 
    } 
}

Catch la gestion des exceptions: peut se produire lorsque le corps de la méthode anormale, eux - mêmes corps de méthode pour capturer cet objet d'exception et le contenu lié à gérer l'exception, pas jeter les gens face à leur propre [propre] catastrophe mis en colère
Format:

essayer .... attraper
essayez ... catch..finally
essayez ... enfin

Le premier format: try ... catch
Le format spécifique : le try { possible segment de code d'exception } catch ( Type d' exception nom variable ) { exception segment de code de résolution }

essayez: Essayez sens. Essayez d'exécuter susceptibles d'avoir un code anormal
capture: des moyens de capture, si une exception se produit dans l'essai, l'objet d'exception sont capturées et traitées
(): Écriture capturé capture l'objet d'exception à la
{}: L' écriture de code pour gérer les exceptions

Le processus de mise en œuvre:

anomalie du spectacle, le code dont le code ne cherche pas top-down se produit lors de l'exécution du saut de bloc catch [inefficace]
Essayez exception parmi la génération de code, receveur de déclenchement à bloc catch où l'exception est survenue objet anormal, l'exécution de code passera de l'ordre du bloc d'exception est effectuée directement à la capture, le bloc catch est terminée continuer code suivant.
mots de capture entre parenthèses si anormale, il peut également être capturées revendications de poignée de traitement

Le code échantillon

Paquet com.ujiuye.demo; 
Importer un java.io.FileInputStream, l' 
importation java.io.FileNotFoundException, du 
public  classe Demo_Exception02 {
     publics  statiques  vides principaux {(String [] args) 
        . Le système OUT .println ( " commencé " ); // 1
         // cette ligne de code a attiré une anomalie gestion de leur propre traitement de la catastrophe ... la prise try   
        try {
             // fichier est une anomalie ne se produit pas en présence de 
            FileInputStream FIS = nouvelle nouvelle FileInputStream ( « un b.txt \\ » ); 
            système. OUT .println ( "Aucune exécution anormale « );
             // fichier n'existe pas dans l'anomalie se produit sera ici prises à des exceptions de capture, l'exécution de code saute pour attraper 
            le FileInputStream FIS1 = new new FileInputStream ( » B b.txt \\ " ); 
            . Le système OUT .println ( « tentative en cours d' exécution » ); // 2 il n'y aura pas procéder à l'exécution sans exception est 
        } la prise (FileNotFoundException E) { 
            . système oUT .println ( « ce fichier ne peut être trouvé exception, ont été traitées . » ) ; // 4 Intercepter l'exception et exécuter
             // prises dans le code généré une exception que la façon dont nous traitons la façon de traiter éventuelle déclaration peut être capturée 
            essayer {
                FIS FileInputStream = nouvelle nouvelle FileInputStream ( " A b.txt \\ " ); 
            } les prises (un FileNotFoundException E1) { 
                Le système. OUT .println ( " Gestion des exceptions a " ); 
            } 
        } 
        
        . Le système OUT .println ( " le code est terminé! " ); // 3 
    } 
}

Format déformation: une pluralité de format de bloc de capture

try {有可能有异常的代码段} catch（异常对象1）{解决异常1的方案} catch（异常对象2）{解决异常2的方案}....catch（异常对象n）{解决异常n的方案}

注意事项：【掌握的面试的时候经常被问到里面的相关知识点】
多个 catch 块，执行的时候只会执行其中之一或者一个也不执行
多个异常有了同时触发的条件，实际以第一个被触发的异常为准，其他的异常不会被触发，对应执行的是第一个异常的 catch 块，其他 catch 块不管【不执行】
catch 块中不可以写 break，但是可以写 return 提前【异常处理完】结束方法
catch 的多个异常对象之间如果有子父类关系，catch 异常对象的顺序有要求：自上而下遵循由小到大【子类类型对象在前，父类类型对象在后】
捕获的异常对象处理的时候选择catch块时遵循：

优先匹配自己类型的对象的catch块
没有自己类型的对象catch块，就近执行最近的父类的对象的catch块
自己和父类对象的catch块都没有，那就报错

jdk1.7之后，异常捕获时异常类型可以使用|【或】表示【多种不同的异常想要用相同的处理方式的时候可以使用|】

多种异常类型对象，可以使用相同的处理方式
异常类型是相互独立没有关系的类型【不能有继承关系】
 格式：catch（异常类型1 | 异常类型2 |异常类型3 对象名）{ }

代码示例

package com.ujiuye.demo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Scanner;
public class Demo_Exception03 {
    public static void main(String[] args)  {
        System.out.println("开始执行");//1
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num = sc.nextInt();
        //这行代码有异常  进行处理  自己惹来的祸自己处理  try...catch  
        try {
            //文件是存在的不会发生异常  //异常1 FileNotFoundException
            FileInputStream fis = new FileInputStream("a\\b.txt");
            System.out.println("无异常执行");
            //文件是不存在的会发生异常   catch就会到这里捕获异常，代码执行跳转到catch中
            FileInputStream fis1 = new FileInputStream("b\\b.txt");
            System.out.println("尝试执行过程中");//2     有异常不执行了  无异常就执行
            //异常2：除数为0的异常  ArithmeticException
            System.out.println(100/num);//第一个被触发了
        } catch (FileNotFoundException | ArithmeticException | NullPointerException e) {
            System.out.println("这是一个文件无法找到的异常，已经处理");//4  捕获异常并执行
            //break;
            //return ;//结束方法的
        }/*catch (ArithmeticException e) {
            System.out.println("这是一个文件无法找到的异常，已经处理");
            //System.out.println("这是一个除数为0异常");
        }*//*catch (IOException e) {//他是捕获到的异常对象的父类
            System.out.println("这是一个io的异常，已经处理");//4  捕获异常并执行
        }*//*catch (Exception e) {//爷爷类  执行爷爷类
            System.out.println("这是一个编译异常，已经处理");//4  捕获异常并执行
        }*/
        
        System.out.println("代码执行完毕！");//3
    }
}

第二种：try...catch...finally
具体格式： try {有可能产生异常代码} catch（异常对象）{对异常对象的解决方案} finally {无论有无都必须要执行的代码}
特点：finally 里面的代码不管try 当中的代码是否会发生异常它肯定会执行的。
使用场景：io 流对象关闭使用 finally。
注意事项：

中间的 catch 块可以有多个
finally 不可以单独使用，必须跟在 try 代码块后面

代码示例

package com.ujiuye.demo;
import java.io.FileInputStream;
public class Demo_Exception04 {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new  FileInputStream("b\\b.txt");
            //写在这没有异常可以打印输出  有异常输出不了
            //System.out.println(123);
        } catch (Exception e) {
            System.out.println("异常已处理");
            //没有异常 输出不了   有异常输出了
            //System.out.println(123);
            return;
        }finally {
            System.out.println(123);//百分百的保证代码执行
        }
        //必须要在控制台输出一个123
        //如果catch块中产生异常或者有return  有可能输出不了
        //System.out.println(123);
    }
}

第三种处理方式【不处理异常，纯粹的为了finally】
格式：try { 有可能出现异常的代码 } finally { 必须要执行的代码 }
不怎么用；这种格式并不是处理异常的，单纯就是为了finally的使用，异常根本就没有被处理

代码示例

package com.ujiuye.demo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Demo_Exception05 {
    public static void main(String[] args) /*throws FileNotFoundException*/ {
        try {
            try {
                FileInputStream fis = new  FileInputStream("b\\b.txt");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            //FileInputStream fis = new  FileInputStream("b\\b.txt");
        }/* catch (FileNotFoundException e) {
            e.printStackTrace();
        }*/ finally {//finally不能单独使用，必须需要try
            System.out.println("nihaoha,bingdu");
        } 
    }
}

处理异常使用格式注意事项：

try 代码块可以单独使用【单独使用没有意义】变换也不能单独使用
catch 代码块不能单独使用，不能离开 try 代码块。
finally 不能单独使用，要结合 try 代码块使用。

二，jvm的异常处理方式

jvm 是作为执行者，调用的 main 方法；其他方法都需要通过main方法直接或间接的调用，异常一旦产生，自己又不想自己解决采用声明的方式来抛出异常，不停抛抛来抛去最终抛到 jvm，jvm 最后的一个调用者抛不了必须要自己处理。
jvm 的处理方式：先把程序给停止然后捕获异常处理【把异常对象中的相关信息进行打印】。
jvm 异常的处理和捕获处理的区别？

捕获处理异常：catch 块下面的代码可以继续执行出效果【jvm没有停止】
jvm 处理异常：产生异常代码处后面的所有代码都不能够执行了【jvm直接停止】

三，异常分类

编译异常：在代码编译过程中会对相关代码进行格式和语法的检查，如果不满足就会直接报错提示，不会将错误放到运行去。编译异常都属于Exception的子类，必须要进行处理才可能继续执行
运行异常：在编译的时候不会对代码进行一些相关的检查，只有在运行的时候才会发现有问题的异常。运行异常都是RuntimeException的子类，可以处理也可以不处理【交给jvm来处理】一般的运行异常选择不处理

四，异常体系的常用方法

异常体系的方法全部定义在 Throwable 类中，其他异常类没有定义任何的方法，都是继承 Throwable 中的方法。
构造方法：

Throwable（）：创建一个没有任何异常信息的异常对象
Throwable（String message）：创建一个只有异常信息描述的对象
Throwable（Throwable t）：创建一个有异常原因的异常对象
Throwable（String message,Throwable t）：创建一个有异常信息和异常原因的异常对象

普通方法：

getCause：获取异常对象的异常原因
getMessage：获取异常的提示详细信息【常用】
 toString：获取异常对象的详细属性信息
 printStackTrace：打印异常的调用地址信息【常用】

代码示例

package com.ujiuye.demo;
public class Demo {
    public static void main(String[] args) {
        Throwable t1 = new Throwable();
        Throwable t2 = new Throwable("这是一个角标越界异常");
        Throwable t3 = new Throwable(t2);
        Throwable t4 = new Throwable("这是一个类型转换异常",t1);
        System.out.println(t1.getCause());
        System.out.println(t1.getMessage());
        System.out.println(t1.toString());
        t1.printStackTrace();
        System.out.println("===============");
        System.out.println(t2.getCause());
        System.out.println(t2.getMessage());
        System.out.println(t2.toString());
        t2.printStackTrace();
        System.out.println("===============");
        System.out.println(t3.getCause());
        System.out.println(t3.getMessage());
        System.out.println(t3.toString());
        t3.printStackTrace();
        System.out.println("================");
        System.out.println(t4.getCause());
        System.out.println(t4.getMessage());
        System.out.println(t4.toString());
        t4.printStackTrace();
    }
}

l'architecture anormale, exception mécanisme de traitement; Exceptions Les exceptions de temps compiler et exécuter, la méthode classique, Throwable exception personnalisée (Java Jour 17)

Tout d'abord, anormale

système anormal

Gestion des exceptions

manutention manuelle: nous avons besoin de posséder le code lié à l' approche anormale.

Avertissement exception: quand il est venu à l'exception qu'ils ne sont pas traités, le type de déclarations d'exception à quelqu'un d'autre pour faire face à [la] utiliser le mot-clé jeter une exception jette une exception après la déclaration du type de déclarations de méthode

Scène: la méthode du corps de la méthode peut avoir un événement anormal

Catch la gestion des exceptions: peut se produire lorsque le corps de la méthode anormale, eux - mêmes corps de méthode pour capturer cet objet d'exception et le contenu lié à gérer l'exception, pas jeter les gens face à leur propre [propre] catastrophe mis en colère

Le premier format: try ... catch

第二种：try...catch...finally

第三种处理方式【不处理异常，纯粹的为了finally】

二，jvm的异常处理方式

三，异常分类

四，异常体系的常用方法

Je suppose que tu aimes