异常处理

一、异常的概念

　　

在Java中把所有的非正常情况分为两种：异常（Exception）和错误（Error），他们都继承Throwable
父类。
Error，一般是指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败等，这种错误无法恢
复或不能捕获，将导致应用程序中断。通常应用程序无法处理这些错误，因此应用程序不能试图使用
catch块来捕获Error对象，在定义方法时也无须其throws子句中声明该方法可能抛出Error及其任何子
类。

Exception异常指的是运行期出现的错误，也就是当程序开始执行以后执行期出现的错误。出现错误时观察错误的名字和行号最为重要。

Java的异常机制主要依赖于try、catch、finally、throw和throws五个关键字。其中try关键字后面紧跟
着一个花括号括起来的代码块，它里面放置可能会引发异常的代码块。catch后面对应异常类型和一个
代码块，用于表明该catch块用于处理这种类型的代码块，多个catch块后面还可以跟一个finally块，用
于回收在try块里打开的物理资源，异常机制会保证finally块总会被执行。throws关键字主要在方法签名
中使用，用于声明该方法可能抛出的异常；而throw用于抛出一个实际的异常，throw可以单独作为语
句使用，抛出一个具体的异常对象。
Java的异常处理机制可以让程序具有极好的容错性，让程序更加健壮。当程序出现意外情形时，系统会
自动生成一个Exception对象来通知程序，从而实现将“业务功能实现代码”和“错误处理代码”分离，提供
更好的可读性。

 int arr[]={1,2,3};
                 System.out.println(arr[2]);
                  /*
                   这里使用try……catch来捕获除以0产生的异常，其基本格式是：
                   try{
                         statements;//可能产生异常的语句
                         ……
                     }
                     catch(Throwable-subclass e){//异常参数e
                         statements;//异常处理程序
                         ……
                    }
                  */
                 try{
                     System.out.println(arr[2]/0);
                 }catch(ArithmeticException ae){//这里是这个异常参数的类型声明，即声明这个异常是属于哪种类型的异常
                     System.out.println("出错啦！");
                    
                     ae.printStackTrace();
                     /*
                      * 这里使用printStackTrace()方法把这个错误的堆栈信息打印出来。
                      * 所谓的“错误堆栈信息”指的是这个错误有可能是上一个错误引起的，
                      * 而上一个错误又有可能是由另外一个错误引起的。到底是由哪个错误引起的，
                      * 把所有的错误信息全都打印出来就知道了。这种信息往往能给我们程序员调试错误的提示。
                      * 这些信息很有用，因此我们往往使用这个方法把错误信息打印出来。
                      * 默认打印错误提示信息采用的也是使用这种方法打印出来的
                      */
                     ae.getMessage();//返回该异常的详细描述字符串。
                     
                 }

　异常是运行期间出现的错误，运行期间出现错误以后JAVA处理这种错误的方式是首先会找相应的catch代码，看看有没有使用catch去捕获异常，如果有catch存在，那么JAVA就会自动跳到catch那里去处理异常，如果没有catch，那么JAVA将会把这个错误抛出去，然后将相关的错误信息打印出来。想用catch捕获异常时必须要写try，没有try就不能用catch，try里面写的是有可能产生异常的语句，catch里面写的是当try里面的语句运行时出现了异常的处理方式。

　　方法声明的时候可以指明这个方法有可能会抛出的异常类型，使用throw抛出异常，声明方法后面有throws声明的可能出现的异常一定要去捕获。

 

 二、异常的捕获和处理

 

 

 

 

 

 

三、try...cath...finally语句

 

 

 

 

 

 异常简单练习

public class TaskException {

    /**
           * 任何方法往外抛能处理的异常的时候都有一种简单的写法：“throws Exception”，
           * 因为Exception类是所有能处理的异常类的根基类，因此抛出Exception类就会抛出所有能够被处理的异常类里了。
          * 使用“throws Exception”抛出所有能被处理的异常之后，这些被抛出来的异常就是交给JAVA运行时系统处理了，
           * 而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。
           * @throws Exception
           */
    public static void fn() throws Exception {
              
          }
          
          /**
           * 在知道异常的类型以后，方法声明时使用throws把异常往外抛
           * @param i
          * @throws ArithmeticException
           */
          public static void m1(int i)  throws ArithmeticException {
              
          }
          
          public static  void m2(int i) {
              if (i == 0) {
                  //这种做法就是手动抛出异常，使用“throw+new出来的异常对象”就可以把这个异常对象抛出去了。
                  //这里是new了一个异常对象，在构建这个对象的时候还可以指定他相关的信息，如这里指明了异常信息“i不能等于0”
                 //这个对象抛出去的时候使用getMessage()方法拿到的就是“i不能等于0”这种信息。
                 throw new ArithmeticException("i不能等于0");
              }
          }
          
          /**
           * 正常情况下如果这里不写try……catch语句那么程序编译时一定会报错，
          * 因为这里有可能会产生两个个必须要处理的异常：FileNotFoundException和IOException。
           * 但由于在声明方法f()时已经使用throws把可能产生的这两个异常抛出了，
          * 所以这里可以不写try……catch语句去处理可能会产生的异常。
           * f()方法把抛出的异常交给下一个要调用它的方法去处理
           * @throws FileNotFoundException
           * @throws IOException
          */
        public static  void f() throws FileNotFoundException, IOException {
              //这里有可能会产生FileNotFoundException异常
              FileInputStream fis = new FileInputStream("MyFile.txt");
              //这里有可能会产生IOException异常
             int b = fis.read();
              while (b != -1) {
                 System.out.println((char)b);
                  b = fis.read();
              }
          }
          
         /*
          * 在f2()方法里面调用f()方法时必须要处理f()方法抛出来的异常，
          * 当然，如果f2()方法也没有办法处理f()方法抛出来的异常，那么f2()方法也可以使用throws把异常抛出，
          * 交给下一个调用了f2()的方法去处理f()方法抛出来的异常。
           * 这里f2()调用f()方法时，选择不处理f()方法中可能抛出的异常，将异常继续抛出
           * @throws Exception
           */
        public static void f2() throws Exception {
              f();
          }
         
          /*
           * f3方法调用f方法捕获f()方法抛出的2个异常并进行处理
           */
        public static  void f3() {
              try {
                  f();
              } catch (FileNotFoundException e) {
                 System.out.println(e.getMessage());//处理的方法是把错误信息打印出来
             } catch (IOException e) {
                 e.printStackTrace();//处理的方法是使用printStackTrace()方法把错误的堆栈信息全部打印出来。
              }
         }

FileInputStream fis = null;
                        try {
                              fis = new FileInputStream("MyFile.txt");
                             int b = fis.read();//这个有可能会抛出IOException异常
                              while (b != -1) {
                                 System.out.println((char)b);
                                 b = fis.read();
                             }
                          } catch (FileNotFoundException e) {
                            //使用catch捕获FileNotFoundException类异常的异常对象e。并让异常对象e自己调用printStackTrace方法打印出全部的错误信息
                             e.printStackTrace();
                         } catch (IOException e) {
                             //再次使用catch捕获IOException类的异常对象e，并让异常对象e自己调用getMessage()方法将错误信息打印出来。
                             System.out.println(e.getMessage());;
                         }finally{
                             try {
                                 /**
                                * 前面已经把一个文件打开了，不管打开这个文件时有没有错误发生，即有没有产生异常，最后都一定要把这个文件关闭掉，
                                 * 因此使用了finally语句，在finally语句里面不管前面这个文件打开时是否产生异常，在finally这里执行in.close()都能把这个文件关闭掉，
                                  * 关闭文件也有可能会产生异常，因此在finally里面也使用了try……catch语句去捕获有可能产生的异常。
                                  */
                                fis.close();
                             } catch (IOException e) {
                                e.printStackTrace();
                             }
                         }
                    }

四、声明并抛出异常

 

 五、使用自定义异常

 

 

package task;
   /*
          * 自定义的一个异常类MyException，且是从Exception类继承而来
     */
public class MyException  extends Exception {
          private int id;
     
          /*
                      * 自定义异常类的构造方法
          * @param message
          * @param id
          */
         public MyException(String message,int id) {
             super(message);//调用父类Exception的构造方法
             this.id = id;
         }
         
         /*
                     * 获取异常的代码
          * @return
          */
         public int getId() {
             return id;
         }
        
     }

package task;

import java.text.MessageFormat;

public class TaskMyException {
     //throws MyException,抛出我们自定义的MyException类的异常。
        public void regist(int num) throws MyException {
             if (num < 0) {
                 //使用throw手动抛出一个MyException类的异常对象。
                 throw new MyException("人数为负值，不合理", 1);
             }
             /*
             * 注意：当我们抛出了异常之后，
              * System.out.println(MessageFormat.format("登记人数：{0}",num));是不会被执行的。
              * 抛出异常之后整个方法的调用就结束了。
              */
             System.out.println(MessageFormat.format("登记人数：{0}",num));
         }
         
         public void manage() {
             try {
                 regist(-100);
             } catch (MyException e) {
                 System.out.println("登记失败，错误码："+e.getId());
                 e.printStackTrace();
             }
            System.out.println("操作结束");
        }
         
         
         public static void main(String[] args) {
             TaskMyException t = new TaskMyException();
             t.manage();
        }
    
     }