Java异常

一、异常

异常指程序在运行中出现的不期而至的各种状况，如：文件找不到，网络连接失败，非法参数等。

1.三种类型的异常

• 检查性异常：用户的或错误或问题引起的异常，程序员无法预见的，这些异常编译时不能被简单的忽略。
• 运行时异常：运行时可能被程序员避免的异常，运行时异常可以在编译时被忽略。
• 错误：错误不是异常，而是脱离程序控制的问题，错误在代码中经常被忽略。

2.异常体系结构

异常类（Throwable）分为俩类，

• 异常（Exception）用户程序可能捕获的异常情况或者是程序可以处理的异常。
  • 运行时异常（RuntimeException）：数组下标越界（ArrayIndexOutOfBoundsException），算数异常（ArithemticException）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理，一般由逻辑编辑错误引起。
  • 非运行时异常（运行时异常之外的异常）：（IOException），（SQLException），（用户自定义的Exception），这些异常是必须处理的异常，不处理程序就不能编译通过。
• 错误（Error）不希望被程序捕获或者程序无法处理的异常。出现这种异常，JVM一般会终止线程。
  • 由Java虚拟机生成并抛出，大多数错误和代码编写者所执行的操作无关：Java虚拟机运行错误（Virtual MachineError），类定义错误（NoClassDefFoundError），链接错误（LinkageError），这些错误是不可查的它们在应用程序的控制和处理能力之外，绝大多数是程序运行时不允许出现的状况。

3.检查异常和不受检查异常

• 检查异常：除了运行时异常及其子类以外，其他的异常类及其子类（非运行时异常），编译器要求必须处理的异常（try-catch语句捕获，或者throws抛出）
• 不受检查异常：包括运行时异常及其子类和Error，编译器不要求强制处理的异常。

二、Java异常处理机制

1.抛出异常

遇到异常，当前方法或者作用域无法继续执行下去，进行抛出处理。

2.捕获异常

方法抛出异常后，运行系统转为寻找合适的异常处理器，进行捕获处理。

3.异常处理五个关键字

• try——监听，将要监听的代码放在try语句块中，发生异常，异常就会被抛出。

• catch——捕获异常，捕获try语句块中发生的异常.

• finally——处理善后工作，总会被执行，主要用于收回try语句块中打开的资源。

• throw——抛出异常

• throws——用在方法签名中，声明该方法可能抛出的异常

三、异常处理

1.try-catch

快捷键 Ctrl+Alt+T

//假设要捕获多个异常，异常类型从小到大
try {//try 监控区域
    if(b==0){
        throw new ArithmeticException();//主动抛出异常 throw throws
    }
    System.out.println(a/b);
} catch (Exception e) {//catch（想要捕获的异常类型）  捕获异常
    System.out.println("Exception");
} catch (Error f){
    System.out.println("Error");
} catch (Throwable g){
    System.out.println("Throwable");
} finally {//finally 处理善后工作   可以不要finally   一般用来 资源关闭
    System.out.println("finally");
}

2.throw

该程序两次处理相同的错误，首先， main() 方法设立了一个异常关系然后调用proc()。proc()方法设 立了另一个异常处理关系并且立即抛出一个 NullPointerException 实例， NullPointerException 在 main() 中被再次捕获。

class TestThrow{
    static void proc(){
        try{
            throw new NullPointerException("demo");
        }catch(NullPointerException e){
            System.out.println("Caught inside proc");
            throw e;
        }
    }
    public static void main(String [] args){
        try{
            proc();
        }catch(NullPointerException e){
            System.out.println("Recaught: "+e);
        }
    }
}

3.throws

如果一个方法可以导致一个异常但不处理它，它必须指定这种行为以使方法的调用者可以保护它们自己 而不发生异常。要做到这点，我们可以在方法声明中包含一个 throws 子句。

4.finally

处理善后工作，主要用于收回try语句块中打开的资源，无论有没有异常被抛出都会被执行。

5.执行顺序

1. 执行try,catch,给返回值赋值
2. 执行finally
3. return

四、自定义异常

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

//1.创建自定义异常类
public class MyException extends Exception {
    //传递数字>10
    private int detail;
    public MyException(int a) {
        this.detail = a;
    }
    @Override  //打印异常信息
    public String toString() {
        return "MyException{" + detail + "}";
    }
}

public class Test {
    //可能存异常的方法。
    static void test(int a) throws MyException {//3.throws指明要抛出给方法调用者的异常
        System.out.println("传递的参数为" + a);
        if (a>10){
            throw new MyException(a);//2.throw抛出异常对象
        }
        System.out.println("ok");
    }

    //4.通过try-catch捕获处理异常。
    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("Myexception-->" + e );
        }
    }
}

传递的参数为11
Myexception-->MyException{11}