JavaSE14-异常和异常处理机制

目录

• 一、异常
• 二、异常处理机制
• 三、自定义异常

一、异常

• 异常是指在程序运行中出现的不期而至的各种状况，如文件找不到，网络连接失败、非法参数等。
• 异常发生在程序运行期间，它影响正常的程序执行流程。

简单分类：

• 检查性异常：用户错误或问题引起的异常等，程序员无法预见。例如，要打开一个不存在的文件，就会发生一个异常。
• 运行时异常：程序运行时发生的异常，程序编译时被忽略（在IDE编程时不提示错误），在运行时发生异常。
• 错误：错误不是异常，是脱离了程序员控制的问题。例如，当栈溢出时，一个错误就发生了，在编译时也检查不到。

异常体系结构：

• Java把异常当作对象来处理，并定义了一个基类java.lang.Throwable作为所有异常的超类。
• 异常类分为两大类：错误Error和异常Exception。

Error：

• 对象由Java虚拟机生成并抛出，大多数与代码编写者所执行的操作无关
• Java虚拟机运行错误，Java虚拟机一般会选择终止

Exception：

• 异常一般是由程序逻辑错误引起的，程序员应该从逻辑角度尽可能避免这类异常的发生
• Error通常是灾难性的错误，是程序无法控制和处理的
• Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

二、异常处理机制

• 抛出异常
• 捕获异常
• 异常处理关键字：try、catch、finally、throw、throws

1. try-catch-finally

   public class Test {
       public static void main(String[] args) {
           int a = 1;
           int b = 0;
   
           //ctrl+alt+T -->try-catch-finally
   
   //        System.out.println(a/b);  //java.lang.ArithmeticException: / by zero
           try {  //监控区域
               System.out.println(a/b);
           } catch (ArithmeticException arithmeticException) {
               //catch可以捕获多个异常，异常级别要从小到大，只执行最符合的异常（小）
               System.out.println("catch arithmeticException");  //catch arithmeticException
           } catch(Exception exception){
               System.out.println("catch exception");  //不执行
           } catch(Throwable throwable){
               System.out.println("catch throwable");  //不执行
           } finally {  //可选
               System.out.println("finally");  //finally
           }
       }
   }
   

2. throw

   public class Test2 {
   
       public static void main(String[] args) {
   
           int a = 1;
           int b = 0;
           //没有异常代码（a/b），但发生了异常
           new Test2().test(a,b);  //java.lang.ArithmeticException
       }
   
       public void test(int num1,int num2){
           if (num2 == 0){
               throw new ArithmeticException();  //主动抛出异常
           }
       }
   }
   

3. throws

   public class Test3 {
   
       public static void main(String[] args) {
   
           int a = 1;
           int b = 0;
   
           try {
               new Test3().test(a,b);
           } catch (Exception ArithmeticException) {
               System.out.println("处理异常");  //处理异常
           }
       }
   
       //假设这方法中处理不了这个异常，方法上抛出异常，交给外部处理
       public void test(int num1,int num2) throws ArithmeticException{
           System.out.println(num1/num2);
           }
   }
   

三、自定义异常

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

自定义异常类：

• 创建自定义异常类
• 在方法中通过throw抛出异常对象
• 在抛出异常的方法中处理异常，否则在方法的声明处通过throws抛出异常
• 在出现异常方法调用的地方捕获并处理异常

自定义异常类

public class MyException extends Exception{
		//返回 "MyException {" + "detail=" + detail + '}'
    private int detail;

    //有参构造
    public MyException(int a) {
        this.detail = a;
    }

    //toString:异常的打印信息
    @Override
    public String toString() {
        return "MyException {" + "detail=" + detail + '}';
    }
}

主测试类

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

        try {
            test(11);  //传递的参数：11
        } catch (MyException e) {
            System.out.println("处理异常："+e);  //处理异常：MyException {detail=11}
        }
    }

    //可能存在异常的方法
    public static void test(int a) throws MyException{

        System.out.println("传递的参数："+a);

        if (a>10){
            throw new MyException(a);
        }
        System.out.println("ok");
    }
}

实际中的经验总结

• 处理运行时异常，可以采用逻辑去合理规避同时辅助try-catch处理
• 在多层catch后面，加一个catch（Exception）来处理可能会被遗漏的异常
• 对于不确定的代码，也可以加上try-catch，处理潜在的异常
• 尽量去处理异常
• 尽量使用finally语句块去释放占用的资源