异常机制

异常机制（Exception）

• 分类：

  • 检查性异常（非运行时错误）：例如用户输入错误的异常等。是程序员无法预见的
  • 运行时异常：是程序员最可能避免的异常，但是在编译时常常被忽略
  • 错误（Error）：错误不是异常！是脱离程序员控制的问题

• 异常体系结构：

  • Java把异常当作对象来处理（定义了一个基类java.lang.Throwable作为所有异常的超类）

  • 在Java API中已经定义了许多异常类，分为两大类：

    • 错误（Error）：通常是灾难性的致命错误，是程序无法控制和处理的，Java虚拟机（JVM）一般会选择终止线程
    • 异常（Exception）：一般是由程序逻辑错误引起的，通常可以被程序处理的，应该尽可能在程序中处理这些异常（可以选择捕获）

    

• 异常处理机制：

  • 抛出异常

  • 捕获异常

  • 异常处理的5个关键字：try, catch, finally, throw, throws

  • Demo:

    package com.exception;
    
    public class Test {
        public static void main(String[] args) {
            int a=1;
            int b =0;
    
            //假设要捕获多种异常类型：范围要从小到大！
            try{  //try监控区域
                System.out.println(a/b);
            }catch(ArithmeticException e){
                System.out.println("程序出现ArithmeticException：变量b不能为0！");
            }catch(Error e){
                System.out.println("Error");
            }catch(Throwable e){
                System.out.println("Throwable");
            }finally { //处理善后工作
                System.out.println("finally");
            }
            //try,catch必须有！finally可以不要（当需要关闭资源，例如Scanner、IO流时必须有）
        }
    }
    

    package com.exception;
    
    public class Test2 {
        public static void main(String[] args) {
            int a =1;
            int b =0;
    
            //快捷键：Ctrl+Alt+T，选择try/catch/finally
            try {
                System.out.println(a/b);
            }catch (Exception e) {
                e.printStackTrace(); //打印错误的栈信息
            } finally {
            }
        }
    }
    

    package com.exception;
    
    public class Test03 {
        public static void main(String[] args) {
            try {
                new Test03().test(1,0);
            } catch (ArithmeticException e) {
                e.printStackTrace();
            }
        }
    
        //throws：假设在方法中处理不了异常，则在方法上抛出异常
        public void test(int a,int b) throws ArithmeticException{
            if(b==0){
                throw new ArithmeticException(); //throw：主动抛出异常，一般在方法中使用
            }
            System.out.println(a/b);
        }
    }
    

• 自定义异常

  • Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户可以自定义异常类，只需继承Exception类即可

  • 自定义异常类的步骤：

    1. 创建自定义异常类
    2. 在方法中通过throw关键字抛出异常对象
    3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛给方法调用者的异常，继续进行下一步操作
    4. 在调用方法时出现异常的调用者要捕获并处理异常

  • Demo:

    package com.exception.demo02;
    
    //自定义的异常类
    public class MyException extends Exception {
        //传递数字>10，则抛出异常
        private int detail;
    
        public MyException(int a) {
            this.detail=a;
        }
    
        //toString：
        @Override
        public String toString() {
            return "MyException{" + detail + '}';
        }
    }
    

    package com.exception.demo02;
    
    public class Test {
        //可能会存在异常的方法
        static void test(int a) throws MyException {
            System.out.println("传递的参数为："+a);
            if(a>10){
                throw new MyException(a);  //选择不在方法中捕获，通过方法抛出
            }
            System.out.println("ok");
            //如果异常没有被捕获并处理，程序会终止当前方法的执行，并继续向上抛出，直到找到一个合适的异常处理器或程序终止
        }
    
        public static void main(String[] args) {
            try {
                test(11);
            } catch (MyException e) {
                System.out.println("MyException:"+e);
            }
            System.out.println("finish");
        }
    }
    

  • 实际应用中的经验总结:

    1. 在处理运行时异常时，尽量梳理逻辑以合理规避，并辅助采用try-catch处理
    2. 在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常
    3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常
    4. 尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出
    5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定
    6. 尽量添加finally语句块去释放占用的资源