Java异常机制02：异常处理机制

一、异常处理机制

• 抛出异常：
  在方法声明的位置上，使用throws关键字，抛给上一级。（谁调用我，我就抛给谁。抛给上一级。）
• 捕获异常：
  使用try…catch语句进行异常的捕捉。（捕捉了异常后则不用继续抛给上一级。）
• 异常对象的常用方法：
  1. getMessage():获取异常简单的描述信息

     String msg = exception/*异常对象*/.getMessage();
     

  2. printStackTrace():打印异常追踪的堆栈信息

     exception/*异常对象*/.printStackTrace();
     
     

• 异常发生之后，如果选择了上抛，抛给调用者，调用者需要对这个异常继续处理 ，调用者处理这个异常同样有两种处理方式：上抛或捕获；（如果将异常继续上抛，抛给了main方法，main方法继续上抛，抛给了调用者JVM，JVM知道这个异常发生，只有一个结果：终止java程序的执行）
• 异常处理五个关键字：try（监控、试验）、catch（捕捉）、finally（最后）、throw（<方法体>抛出异常）、throws（<函数方法>抛出异常）
  • try、catch、finally一般连着使用，快捷键：Ctrl+Alt+T
  • try、catch是异常处理必须要的东西，finally可以不要
  • finally必须和try一起出现，不能单独编写，即使try语句块中的代码出现了异常，finally中代码也会正常执行（一般是处理善后工作，如IO，资源等需要关闭，会把关闭的方法放到finally中）
  1. final、finally、finalize的区别：
     —— final是一个关键字：表示最终的、不变的
     —— finally是一个关键字：和try联合使用，使用在异常处理机制中，在finally语句块中的代码是一定会执行的
     —— finalize()是标识符：是Object类中的一个方法，作为方法名出现
  • 假设要多个catch捕获多个异常：异常范围应从小到大（throwable最大）
• 在开发中，处理编译时异常时，如何选择上抛还是捕捉：
  如果希望调用者来处理异常，选择throws上抛，其他情况使用捕捉的方式

示例

//测试
public class Test {

    public static void main(String[] args) {

        int a = 1;
        int b = 0;

        System.out.println("===========try、catch、finally介绍===========");
        //try、catch、finally一般连着使用
        //try、catch是异常处理必须要的东西，finally可以不要
        //finally一般是处理善后工作，如IO，资源等需要关闭，会把关闭的方法放到finally中

        try {//try 监控(试验)区域
            System.out.println(a/b);
        }catch (ArithmeticException e ){//catch（想要捕获的异常类型） 捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally{//处理善后工作
            System.out.println("finally处理善后");
        }

        System.out.println("=================多个catch介绍===============");

        //假设要多个catch捕获多个异常：异常范围应从小到大（throwable最大）
        try {
           // new Test().a(); //输出：Error
            System.out.println(a/b);//输出：Exception
        } catch (Error e) {
            System.out.println("Error");
        } catch (Exception e) {
            System.out.println("Exception");
        } catch (Throwable e) {
            System.out.println("Throwable");
        } finally {
            System.out.println("finally处理善后");
        }

        System.out.println("===================快捷键====================");

        //一键try、catch、finally快捷键：Ctrl+Alt+T
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            //e.printStackTrace();//打印错误的栈信息
            System.out.println("e.printStackTrace();//打印错误的栈信息");
        } finally {
        }

        System.out.println("=============throws使用方法测试=============");

        try {
            new Test().throwsTest(6,0); //输出：ArithmeticException (Test.java:52)
        } catch (Exception e) {
            e.printStackTrace();
        }

        //重复是为了测试：有try、catch时，抛出异常不会终止下面的操作
        try {
            new Test().throwsTest(6,2);//输出：3
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("=============throw使用方法测试==============");

        new Test().throwTest(2,0);//输出：ArithmeticException (Test.java:66)

        //重复是为了测试：没有try、catch时，抛出异常直接终止下面的操作，程序终止
        new Test().throwTest(2,1);//输出：2



    }
    //方法
    public void a(){
        b();
    }
    public void b(){
        a();
    }

    //throw测试
    public void throwTest(int a,int b){
        if (b == 0) {
            throw new ArithmeticException();//主动抛出算术异常，一般在方法体中使用
        } else {
            System.out.println(a/b);
        }
    }

    //throws测试
    //假设这方法体中，处理不了这个异常，则在方法上抛出异常
    //在方法上使用throws抛出异常时，main方法调用时必须对其进行捕获或声明以便抛出
    public void throwsTest(int a,int b) throws Exception{
        if (b == 0) {
            throw new ArithmeticException();//主动抛出算术异常，一般在方法体中使用
        } else {
            System.out.println(a/b);
        }
    }
}