java 的异常处理

一、异常的概念：

java 中的异常通常指的是在运行期出现的错误，这样的错误也是比较难以调试的，解决问题的时候注意观察出现错误的名字和行号最重要

下面看这个例子：

import java.io.*;

public class TestEx {
    public static void main(String[] args) {
        int[] arr = {, , };
        System.out.println(arr[]);
        }
}

在这个例子当中将arr数组的下标第四个元素取出来，在java当中会报这样的错误

java在运行期间，加入会出现上面代码的异常事件，那么就会生成一个异常类的对象，然后将这个对象封装的异常事件信息交给java的运行时系统，java的运行时系统默认的处理是将异常信息在命令行上打印出来，要想解决，就要在交给运行时系统之前把异常信息抓住进行处理也就是当java运行时系统接受到异常对象时，会寻找能处理这一异常的代码并把当前的异常对象交给其处理，这一过程称为捕获（catch）异常，

下面看怎么捕获异常这个例子：

import java.io.*;

public class TestEx{

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

在与上面的代码相比，我加了一句try...catch 由于在执行System.out,printfln(2/0)的时候会出现这样的异常事件

所以在 catch 括号当中写的是 ArithmeticException ae 而ae是ArithenticException类型的。而printstackTrace()方法是将错误的堆信息打印出来，所谓的堆信息就是可能这个错误是上一个错误引起的，我们不知道是哪个错误引起的，把堆信息打印出来就知道了

小结：

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

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

二、异常的分类：

　　

三、异常的捕获和处理:

五个有关异常的关键字 try 、catch、finally、throw、throws

、

下面看一段代码：

try {
    //这个地方容易报FileNotFoundException 异常
    in = new FileInputStream("myfile.txt");
    int b;
   //这个地方容易报IOException 异常
    b = in.read();
    while (b != -) {
        System.out.print((char) b);
        b = in.read();
    }
} catch (IOException e) {
  System.out.println(e.getMessage());

} catch (FileNotFoundException e) {
    e.printStackTrace();
} finally {
    try {
        /*
         * 关闭文件
        可能会报IOException异常
        */
       in.close(); //文件关闭
   } catch (IOException e) {
      e.printStackTrace();
  }
}

假如readFile方法抛了某种异常，在这个方法的内部不想处理没关系，下面method1调用了readFile方法，method1不想处理再抛出，由method2调用method1 方法，一直到try.....catch，加入在main方法里面也不想处理可以再进行抛出，下面就交给了运行时系统处理了也就到“最终级”了，运行时系统就会把相关的错误堆栈信息打印出来,但是不提倡main方法将Exception抛给运行时系统的写法，这是不负责任的表现，也是不正规的写法。

下面看一个例子：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestException {

    /**
     * 任何方法往外抛能处理的异常的时候都有一种简单的写法：“throws Exception”，
     * 因为Exception类是所有能处理的异常类的根基类，因此抛出Exception类就会抛出所有能够被处理的异常类里了。
     * 使用“throws Exception”抛出所有能被处理的异常之后，这些被抛出来的异常就是交给JAVA运行时系统处理了，
     * 而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。
     * @throws Exception
     */
    void fn() throws Exception {

    }

    /**
     * 在知道异常的类型以后，方法声明时使用throws把异常往外抛
     * @param i
     * @throws ArithmeticException
     */
    void m1(int i)  throws ArithmeticException {

    }

    void m2(int i) {
        if (i == ) {
            //这种做法就是手动抛出异常，使用“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
     */
    void f() throws FileNotFoundException, IOException {
        //这里有可能会产生FileNotFoundException异常
        FileInputStream fis = new FileInputStream("MyFile.txt");
        //这里有可能会产生IOException异常
        int b = fis.read();
        while (b != -) {
            System.out.println((char)b);
            b = fis.read();
        }
    }

    /**
     * 在f2()方法里面调用f()方法时必须要处理f()方法抛出来的异常，
     * 当然，如果f2()方法也没有办法处理f()方法抛出来的异常，那么f2()方法也可以使用throws把异常抛出，
     * 交给下一个调用了f2()的方法去处理f()方法抛出来的异常。
     * 这里f2()调用f()方法时，选择不处理f()方法中可能抛出的异常，将异常继续抛出
     * @throws Exception
     */
    void f2() throws Exception {
        f();
    }

    /**
     * f3方法调用f方法捕获f()方法抛出的2个异常并进行处理
     */
    void f3() {
        try {
            f();
        } catch (FileNotFoundException e) {
            System.out.println(e.getMessage());//处理的方法是把错误信息打印出来
        } catch (IOException e) {
            e.printStackTrace();//处理的方法是使用printStackTrace()方法把错误的堆栈信息全部打印出来。
        }
    }

    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("MyFile.txt");
            int b = fis.read();//这个有可能会抛出IOException异常
            while (b != -) {
                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();
            }
        }
    }
}

当捕获到异常以后一定要做出处理，哪怕是把这个异常的错误信息打印出来，这是一种良好的编程习惯。如果不处理，那就是把这个错误悄悄地隐藏起来了，可是这个错误依然是存在的，只不过看不到了而已。这是一种非常危险的编程习惯，绝对不能这样做，捕获到异常就一定要做出处理，实在处理不了就把异常抛出去，让别的方法去处理。总之就是不能捕获到异常之后却又不做出相应的处理，这是一种非常不好的编程习惯。

　　任何方法往外抛能处理的异常的时候都有一种简单的写法：“throws Exception”，因为Exception类是所有能处理的异常类的根基类，因此抛出Exception类就会抛出所有能够被处理的异常类里了。使用“throws Exception”抛出所有能被处理的异常之后，这些被抛出来的异常就是交给JAVA运行时系统处理了，而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。除了在做测试以外，在实际当中编程的时候，在main方法里抛Exception是一个非常不好的编程习惯，应该使用try……catch去捕获异常并处理掉捕获后的异常。不能直接在main方法里把Exception抛出去交给JAVA运行时系统出力就完事了，这是一种不负责任的表现。如果想把程序写得特别健壮，使用try……catch去捕获异常并处理掉捕获后的异常是必不可少的做法。

 四、使用自定义的异常：

现在系统已经有各种异常了，那咱们能不能自己自定义属于自己的异常呢，答案肯定是当然可以的了，只要再某一个exception类继承就可以了，一般情况下再java.lang.exception里面继承，然后声明自己的异常类就可以了，或者是Runtime Exception说也可以，甚至其他的Exception，那种的就是比较少见了，区别是如果是前者的话，必须要try...catch....了，或者的话，可以try....catch....，假如说，在网页上的用户名密码不对，用户名不对我们可以声明notfounduser exception,用户名对了，但是密码不对，可以定义passerrror exception，这些当然是自己定义的异常，然后就可以往外抛，catch到这种的exception怎么办，catch到另一种exception怎么办，当然，又引起另一个问题，如果遇到两种exception，尽量是分开写catch不同的exception

看下面一个小例子：

/**
 * 自定义的一个异常类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; //这个地方问什么有id呢，是c语言遗留下来的问题，知道就可以了不需要掌握的
    }

    /**
     * 获取异常的代码
     * @return
     */
    public int getId() {
        return id;
    }

}

测试类：

public class TestMyException {

    //throws MyException,抛出我们自定义的MyException类的异常。
    public void regist(int num) throws MyException {
        if (num < ) {
            //使用throw手动抛出一个MyException类的异常对象。
            throw new MyException("人数为负值，不合理", );
        }
        /**
         * 注意：当我们抛出了异常之后，
         * System.out.println(MessageFormat.format("登记人数：{0}",num));是不会被执行的。
         * 抛出异常之后整个方法的调用就结束了。
         */
        System.out.println(MessageFormat.format("登记人数：{0}",num));
    }

    public void manage() {
        try {
            regist(-);
        } catch (MyException e) {
            System.out.println("登记失败，错误码："+e.getId());
            e.printStackTrace();
        }
        System.out.println("操作结束");
    }

    public static void main(String[] args) {
        TestMyException t = new TestMyException();
        t.manage();
    }

}

结果：

下面一个问题就是异常与继承之间的关系了：

总结：

养成良好的编程习惯，不要把错误给吞噬掉（即捕获到异常以后又不做出相应处理的做法，这种做法相当于是把错误隐藏起来了，可实际上错误依然还是存在的）， 也不要轻易地往外抛错误，能处理的一定要处理，不能处理的一定要往外抛。往外抛的方法有两种，一种是在知道异常的类型以后，方法声明时使用throws把 异常往外抛，另一种是手动往外抛，使用“throw+异常对象”你相当于是把这个异常对象抛出去了，然后在方法的声明写上要抛的那种异常。