捕获和抛出异常及自定义异常

逃离我推掉我的手 2022-10-23 11:10 133阅读 0赞

## 捕获和抛出异常 ##

**异常处理机制:**

1.  异常处理的5个关键字：try、catch、finally、throw、throws
2.  捕获异常

> 说到异常，我们当然会想到try catch  
> finally。当然如果用这个的话，被try块包围的代码说明这段代码可能会发生异常，一旦发生异常，异常便会被catch捕获到，然后需要在catch块中进行异常处理。

try{//try监控区域
            }catch(){//catch捕获异常
            }finally{//处理善后工作，不是必须的，但假如IO流，资源，需要在fianlly做close的操作
            }

public class Test1 {
        public static void main(String[] args) {
            //捕获异常
            int a=1;
            int b=0;
            try {// try 监控区域
                System.out.println(a/b);
            }catch (ArithmeticException e){//ArithmeticException 算数运算异常
                System.out.println("b不能为0");
            }finally {//处理善后工作
                System.out.println("finally");
            }
    
    //快捷键:ctrl + alt + T 快捷生成try catch finally
            //捕获多个异常
            /*int a=1;
            int b=0;
            try {// try 监控区域
                System.out.println(a/b);
            }catch (Error e){//catch()异常类型应从小到大写
                System.out.println("Error");
            }catch (Exception e){
                System.out.println("Exception");
            }catch (Throwable t){
                System.out.println("Throwable");
            }finally {//处理善后工作
                System.out.println("finally");
            }*/
        }
    }

**抛出异常**

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

**捕获异常**

//捕获异常
    //throws：声明是哪种类型的异常，使它的调用者可以捕获这个异常
    public class Test3 {
        public static void main(String[] args) {
            try {
                new Test3().test(1,0);//即在此处调用test方法就要捕获这个异常
            } catch (ArithmeticException e) {
                e.printStackTrace();//在命令行打印异常信息在程序中出错的位置及原因
            }
        }
        public void test(int a,int b) throws ArithmeticException{
            System.out.println(a/b);
        }
    }

## 自定义异常 ##

1.  用户自定义异常类，只需继承Exception类即可
2.  自定义异常类的步骤：

> 创建自定义异常类

> 在方法中通过throw关键字抛出异常对象

> 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作

> 在出现异常方法的调用者中捕获并处理异常

//自定义的异常类
    public class MyException extends Exception{
        private int detail;
        public MyException(int a){
            this.detail=a;
        }
        @Override
        public String toString(){
            return "MyExcepyion{"+detail+"}";
        }
    }

//利用自定义的异常类捕获异常
    public class Test {
        //可能会存在异常的方法
        static void test(int a) throws MyException {
            System.out.println("传递的参数为："+a);
            if (a>10){
                throw new MyException(a);//抛出
            }
            System.out.println("OK");
        }
        public static void main(String[] args) {
            try {
                test(11);
            } catch (MyException e) {
                System.out.println("MyException:"+e);
            }
        }
    }

**经验小结**

1.  处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
2.  在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常
3.  对于不确定的代码，也可以加上try-catch 处理潜在的异常
4.  尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出
5.  具体如何处理异常，要根据不同的业务需求和异常类型去决定
6.  尽量添加fianlly语句块去释放占用的资源