Java-异常

异常

什么是异常

异常的简单分类

异常体系结构

Error

Exception

异常处理机制

抛出异常

捕获异常

异常处理五个关键字

​ try,catch,finally,throw,throws

try-catch-finally（捕获异常）

int a = 1;
int b = 0;
System.out.println(a/b);//除数为0,运行时会出现下面的异常
/*
输出结果为：
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.exception.Test.main(Test.java:8)
*/

ackage 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){//catch 捕获异常
            System.out.println("程序出现错误,变量b不能为0");
        }finally {//处理善后工作
            System.out.println("finally");
        }
        //可以不要finally,这个适用于处理善后,比如假设IO,资源,关闭！
    }
}
/*
输出结果为：
程序出现错误,变量b不能为0
finally
*/

//catch(想要捕获的异常类型 异常的实例)
catch(ArithmeticException e)

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");
}catch (Throwable e){
    System.out.println("Throwable");
}
finally {//处理善后工作
    System.out.println("finally");
}
/*
输出结果：
Exception
finally

注意：
可以写多个catch,但是catch括号内的异常类型要由低到高,不然就会编译报错。
可以查看异常体系结构的图,最高异常类型"Throwable"必须在最下面！
当catch从上到下，捕获到其中一个异常类型就直接进入"finally"。
*/

快捷键ctrl+alt+T,选中当前光标中的代码,快速完成try-catch-finally代码.

int a = 1;
int b = 0;
//ctrl+alt+T
try {
    System.out.println(a/b);
} catch (Exception e) {
    e.printStackTrace();//打印错误的栈信息
} finally {
}

throw-主动抛出异常

在这个方法中解决异常

package com.exception;
public class Test {
    public static void main(String[] args) {       
        new Test().test(1,0);
    }
    public void test(int a,int b){
        if(b==0){
            //主动抛出异常,一般在方法中使用
            throw new ArithmeticException();
        }
    }
}
/*
看起来很正常的代码,但是输出结果还是会显示错误,因为主动抛出异常:
Exception in thread "main" java.lang.ArithmeticException
	at com.exception.Test.test(Test.java:35)
	at com.exception.Test.main(Test.java:30)
*/

throws-方法上抛出异常

让在外面调用这个方法的人解决异常

package com.exception;
public class Test {
    public static void main(String[] args) {       
        /*  throws的好处就是当有异常时,配合try-catch-finally尝试解决异常,
            使得代码能够运行下去,否则出现处理不了异常可能会导致程序暂停运行        
         */
        try {//方法上抛出异常后,使用try-catch-finally代码解决这个异常
            new Test().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
        }
    }    
    //假设这方法中,处理不了这个异常,方法上抛出
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){
            //主动抛出异常,一般在方法中使用
            throw new ArithmeticException();
        }
    }
}

自定义异常

package com.exception.demo02;
//自定义异常类：首先要继承Exception类
public class MyException extends Exception {

    //传递数字>10: 假设数字大于10就报异常
    private int detail;

    public MyException(int a) {
        this.detail = a;
    }

    //toString:异常的打印信息
    //alt+insert:->toString()
    //重写toString：可以按照自己想要的格式打印异常信息

    @Override
    public String toString() {
        return "MyException{" + "detail=" + detail + '}';
    }
}

package com.exception.demo02;

public class Test {
    //可能会存在异常的方法
    static void test(int a) throws MyException {
        System.out.println("传递的参数为：" + a);
        if(a>10){
            //此处有两个选择
            //1.在此方法中捕获异常try-catch-finally
            //2.抛出异常,由外面调用这个方法的代码去捕获
            throw new MyException(a);//此处选择抛出
        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        //捕获异常
        try {
            test(11);
        } catch (MyException e) {
            //e.printStackTrace();
            //增加一些处理异常的代码块
            System.out.println("MyException->" + e);//打印信息
        } finally {
        }
    }
}
/*
输出信息：
传递的参数为：11
MyException->MyException{detail=11}
*/

上面第11行代码有快捷键,将光标放在代码上->alt+enter,可以有两种选择:

1. Add exception…(throws 抛出异常)
2. Surround with try/catch(捕获异常)

异常-总结