Java程序中的异常处理机制实例分析

异常处理机制的底层原理

• 抛出异常，在执行一个方法时，如果发送了异常，则这个方法生成代表该异常的一个对象，停止当前执行的 路径，并把异常提交给jre。

• 捕获异常：jre得到该异常后，虚招相应的代码来处理该异常。jre在方法的调用栈中查找，从生成异常的 方法开始回溯，直到找到相应的异常处理代码为止。

异常的继承关系图

欧克，我们现在知道异常的定义是什么，那我们就应该如何去捕捉异常，然后去处理异常。

异常的处理

一、try-catch-finally 结构

首先我们先看一段代码：

package AbnormalTest;

import java.util.InputMismatchException;
import java.util.Scanner;

public class test1 {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        try {
            System.out.print("请输入被除数：");
            int a = input.nextInt();
            System.out.print("请输入除数：");
            int b = input.nextInt();
            int sum = b/a;
            System.out.println("结果是："+sum);
            System.out.println("程序无异常，执行完毕！");
        }catch (Exception e){               //通用异常
        	//printStackTrace()方法是将堆栈异常的错误信息打印出来(后期学习框架后我们一般提交或 者回滚事务)
            e.printStackTrace();
            System.out.println("程序异常，请重试！");
            return ;
        }finally {
            //不管是否发生了异常，都会执行finally内的代码，通常用于资源的关闭
            System.out.println("------------------------------");
            System.out.println("程序结束，资源已经关闭，欢迎再次使用");
            input.close();   //关闭Scanner对象，节省资源
        }
    }

}

代码解释：

上述代码中有try-catch-finally结构，他们分别的作用是什么？

try：我们把可能出现异常的代码用try去包括起来

catch ：只要try代码块里面的代码运行时发生了异常，就会进入catch来捕捉异常

finally：不管之前代码怎么执行，都会执行finally的代码块！！

运行结果示例：

正常时：

异常时:

当被除数为0时，将会触发异常，进入catah内进行捕捉，但是不管有没有异常，都会执行finally内的程序输出：程序结束，资源已经关闭，欢迎再次使用

二、多catch处理不同的异常：

我们知道，在一段代码中可能不止一个异常，比如上述代码，可能存在被除数为0的异常，也可能输入字符进行计算的输入异常，或者可能存在数字格式化异常等等，这样我们就可以使用多catch来捕捉异常：

还是以上面的代码为例：

import java.util.InputMismatchException;
import java.util.Scanner;
public class test1 {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        try {
            System.out.print("请输入被除数：");
            int a = input.nextInt();
            System.out.print("请输入除数：");
            int b = input.nextInt();
            int sum = b/a;
            System.out.println("结果是："+sum);
            System.out.println("程序无异常，执行完毕！");

        }catch (InputMismatchException  e){                    //多重catch结构，这里捕捉输入异常
            e.printStackTrace();
            System.out.println("程序输入异常，请重试！");
        }catch (Exception e){                                 //这里捕捉通用异常（其他异常都可以在这里进行捕捉）            
            e.printStackTrace();
            System.out.println("程序异常，请重试！");
            return ;
        }finally {
            //不管是否发生了异常，都会执行finally内的代码，通常用于资源的关闭
            System.out.println("------------------------------");
            System.out.println("程序结束，资源已经关闭，欢迎再次使用");
            input.close();   //关闭Scanner对象，节省资源
        }
    }

}

当输入不是为数字的时候：

这样我们可以看出，在第一个catch内就已经捕捉到了

三、throws 声明异常/throw 抛出异常：

假设我定义了一个方法，告知该方法可能会发送某种异常（声明异常），调用者调用该方法的时候就务必要对该异常进行处理。

首先我们定义一个错误类：

学生类：

package ExceptionText;

/**
 * 异常测试
 */

public class Student {

    private String name;
    private int age;
    private char sex;


    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public char getSex() {
        return sex;
    }

    public void setAge(int age) throws Exception {
        if (age < 101 && age > 0) {
            this.age = age;
        } else {
            throw new Exception("年龄输入有误！");
        }
    }
    public void setSex(char sex) throws Exception {
        if (sex == '男' || sex == '女') {
            this.sex = sex;
        } else {
            throw new Exception("性别输入有误");
        }

    }
}

测试类：

package ExceptionText;

public class TestMain {
    public static void main(String[] args) {

        Student stu = new Student();
        stu.setName("小红");
        try {
            stu.setAge(50);
            stu.setSex('k');
            System.out.println("我叫："+stu.getName()+"年龄："+stu.getAge()+"我的性别是："+stu.getSex());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

当出入都正确的时候：

当年龄输入不正确的时候：

当性别输入不正确的时候：

注意：如果存在多个异常，那么会抛出第一个出现的异常。

四、自定义异常：

当RuntimeException的运行时异常的子类无法满足我们的需求的时候，我们也可以自定义运行时异常和抛出自定义的异常信息来满足我们的需求，但是要注意：自定义的运行时异常要继承RuntimeException！！！

自定义异常类：

//这个类是继承了RuntimeException
public class AgeException extends RuntimeException {
   //构造方法
   public AgeException(String message) {
       super(message);
   }
}

学生信息类：

package CustomizeException;

public class Student {

    private String name;
    private int age;
    private char sex;

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public char getSex() {
        return sex;
    }
    //方法
    //使用throws 来声明异常，就是这个方法内可能存在异常，先事先声明
    public void setAge(int age) throws Exception {
        if (age < 101 && age > 0) {
            this.age = age;
        } else {            //如果不符合上面的if判断
            throw new Exception("年龄输入有误！");   //这里就要用thrwo 来抛出异常，
        }
    }

    public void setSex(char sex) throws Exception {
        if (sex == '男' || sex == '女') {
            this.sex = sex;
        } else {
            throw new AgeException("这是自定义异常，性别输入有误");
        }
    }
}

测试类：

package ExceptionText;
public class TestMain {
    public static void main(String[] args) {

        Student stu = new Student();
        stu.setName("小红");
        try {
            stu.setAge(18);
            stu.setSex('女');
            System.out.println("我叫："+stu.getName()+"年龄："+stu.getAge()+"我的性别是："+stu.getSex());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这个部分的代码和上面第三部分的一致，可以参考上面的示例。

五、常见的异常