Java中异常捕获和抛出

1. 异常机制

1.1. 主要三种类型的异常

a.检查性异常
最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。

b.运行时异常

运行时异常是可能被程序员避免的异常，与检查性异常相反，运行时异常可以在编译时被忽略

c.错误error

错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它在编译时也检查不到。

1.2. 异常体系结构

Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。在Java API中已经定义了许多异常类，这些异常类分为两大类，错误ERROR和异常Exception。

例如：

StackOverFlowError：栈溢出

OutOfMemoryError：内存溢出异常

FileNotFoundException：找不到文件异常

ArithmeticException：算术异常

MissingResourceException：缺少资源异常

ClassNotFoundException：类找不到异常

NullPointerException：空指针异常

IllegalArgumentException：不合法的参数异常

ArrayIndexOutOfBoundsException：数组下标越界异常

Error和Exception的区别：Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会终止线程。Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

2. 捕获异常

关键字：try、catch、finally

2.1. 捕获异常

package exception;
 
public class demo1 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try{//try监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch（想要捕获的异常类型）捕获异常
            System.out.println("程序出现异常，变量b不能为0"); //程序出现异常，变量b不能为0
        }finally {//可以不要finally,处理善后工作
            System.out.println("finally");//finally
        }
    }
}

2.2. 多个异常选择

package exception;
 
public class demo1 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        //捕获多个异常，从小到大
        try{//try监控区域
            System.out.println(a/b);
        }catch (Error e){
            System.out.println("error");
        }catch (Exception e){
            System.out.println("exception"); //exception
        }catch (Throwable t){
            System.out.println("throwable");
        } finally {//可以不要finally,处理善后工作
            System.out.println("finally");//finally
        }
    }
}

2.3. 快捷键（mac）

package exception;
 
public class demo1 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        //快捷键option+command+t
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();//打印错误的栈信息
        }finally {
             
        }
 
    }
}

3. 抛出异常

关键字：throw、throws

3.1. 主动抛出异常

throw : 将产生的异常抛出(强调的是动作)，抛出的既可以是异常的引用，也可以是异常对象。（位置: 方法体内）

package exception;
 
public class demo1 {
    public static void main(String[] args) {
       new demo1().test(1,0);
    }
 
    public void test(int a,int b) {
        if(b==0){
            throw new ArithmeticException();//主动抛出异常，一般在方法中使用
        }
    }
}

3.2. 方法上抛出异常

throws : 如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异常（可以是一种类型，也可以是多种类型，用逗号隔开）（位置: 写在方法名 或方法名列表之后 ，在方法体之前。）

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

4. 自定义异常

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常，只需要继承Exception类即可。
在程序中使用自定义异常类，步骤如下：
1）、创建自定义异常类
2）、在方法中通过throw关键字抛出异常对象
3）、如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
4）、在出现异常方法的调用者中捕获并处理异常。

package exception.demo;
 
public class MyException extends Exception {
    //传递数字>10；抛出异常
    private int detail;
    public MyException(int a){
        this.detail =a;
    }
    //toString:异常的打印信息
    @Override
    public String toString(){
        return "MyException{"+"detail="+detail+"}";
    }
}

package exception.demo;
 
public class test {
    //可能会存在异常的方法
    static void test(int a) throws MyException {
        System.out.println("参数为"+a);
        if(a>10){
            throw new MyException(a);
        }
        System.out.println("通过");
    }
 
    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("MyException=>"+e);
        }
    }
}