Java异常机制

异常基本概念

• 什么是异常？

  Java 中的错误大致可以分为两类：

  1. 一类是编译时错误，一般是指语法错误。

  2. 另一类是运行时错误。

  Java 中有一组专门用来描述各种不同的运行时异常，叫做异常类，Java 结合异常类提供了处理错误的机制。

  具体步骤是当程序出现错误时，会创建一个包含错误信息的异常类的实例化对象，并自动将该对象提交给系统，由系统转交给能够处理异常的代码进行处理。

  异常可以分为两类：

  1. Error 是指系统错误，JVM 生成，我们编写的程序无法处理。

  2. Exception 指程序运行期间出现的错误，我们编写的程序可以对其进行处理。

  Error 和 Exception 都是 Throwable 的子类，Throwable、Error、Exception 都是存放在 java.lang 包中。

• 异常的使用

  异常的使用需要用到两个关键字 try 和 catch，并且这两个关键字需要结合起来使用，用 try 来监听可能会抛出异常的代码，一旦捕获到异常，生成异常对象并交给 catch 来处理，基本语法如下所示。

   try{
       //可能抛出异常的代码
   }catch(Exception e){
       //处理异常
   }

   package com.jarreet.exception;
   ​
   public class Test {
       public static void main(String[] args) {
           try {
               int num = 10/10;
           }catch (Exception e) {
               // TODO: handle exception
               if(e.getMessage().equals("/ by zero")) {
                   System.err.println("分母不能为0");
               }
           }
       }
   }

  除了 try 和 catch，还可以使用 finally 关键字来处理异常，无论程序是否抛出异常，finally 代码块中的代码一定都会执行，finally 一般跟在 catch 代码块的后面，基本语法如下所示

   try{
       //可能抛出异常的代码
   }catch(Exception e){
       //处理异常
   }finally{
       //必须执行的代码
   }

异常类

Java 将运行时出现的错误全部封装成类，并且不是一个类，而是一组类。同时这些类之间是有层级关系的，由树状结构一层层向下分级，处在最顶端的类是 Throwable，是所有异常类的根结点。

Throwable 有两个直接子类：

• Error

  • VirtualMachineError

    • StackOverflowError（栈内存溢出）

    • OutOfMemoryError（堆内存溢出）

  • AWTError

  • IOError

• Exception。

  • IOException

  • SQLException

  • FileLockInterruptionException

  • FileNotFoundException

  • NoSuchFileException

  • NoSuchMethodException

  • RuntimeException

    • ArithmeticException（算数异常）

    • llegalArggumentException（参数不合法）

    • ArrayIndexOutOfBoundsException（数组越界）

    • NullPointerException（空指针）

    • NumberFormatException（数字格式异常）

throw和throws

throw 和 throws 是 Java 在处理异常时使用的两个关键字，都可以用来抛出异常，但是使用的方式和表示的含义完全不同。 Java 中抛出异常有 3 种方式：

• try-catch

• 使用 throw 是开发者主动抛出异常，即读到 throw 代码就一定抛出异常，基本语法：throw new Exception()，是一种基于代码的逻辑而主动抛出异常的方式

   public class Test {
       public static void main(String[] args) {
           int[] array = {1,2,3};
           test(array,2);
       }
   ​
       public static void test(int[] array,int index) {
           if(index >= 3 || index < 0) {
               try {
                   throw new Exception();
               } catch (Exception e) {
                   // TODO Auto-generated catch block
                   e.printStackTrace();
               }
           }else {
               System.out.println(array[index]);
           }
       }
   }

• try-catch 和 throw 都是作用于具体的逻辑代码，throws 是作用于方法的，用来描述方法可能会抛出的异常

  如果方法 throws 的是 RuntimeException 异常或者其子类，外部调用时可以不处理，JVM 会处理; 如果方法 throws 的是 Exception 异常或者其子类，外部调用时必须处理，否则报错。

   public class Test {
       public static void main(String[] args) throws Exception {
           test("123");
       }
   ​
       public static void test(String str) throws Exception {
           int num = Integer.parseInt(str);
       }
   }

异常捕获

• 自动捕获 try-cath

• throw 主动抛出异常

• throws 修饰可能抛出异常的方法

自定义异常

除了使用 Java 提供的异常外，也可以根据需求来自定义异常

 package com.jarreet.exception;
 ​
 public class MyNumberException extends RuntimeException {
     public MyNumberException(String error) {
         super(error);
     }
 }

 package com.jarreet.exception;
 ​
 public class Test {
     public static void main(String[] args){
         Test test = new Test();
         System.out.println(test.add("a"));
     }
     
     public int add(Object object){
         if(object instanceof Integer) {
             int num = (int)object;
             return ++num;
         }else {
             String error = "传入的参数不是整数类型";
             MyNumberException myNumberException = new MyNumberException(error);
             throw myNumberException;
         }
     }
 }