时间戳

首页 > 技术文章 > 异常基础

异常基础

it-bt 2021-06-06 07:13 原文

异常基础

编译过程和运行过程中的错误和异常，Java提供异常处理机制，提高程序的健壮性。Java中，通过Throwable及其子类描述各种不同的异常类型

1.前言

Throwable→Error(JVM错误) + Exception(RuntimeException+检查异常)

Exception：程序本身可以处理的异常

Unchecked Exception：编译器不要求强制处置的异常，包括RuntimeException类及其子类异常

  • 空指针异常(NullPointerException)
  • 数组下标越界异常(ArrayIndexOutOfBoundsException)
  • 算数异常(ArithmeticException)
  • 类型转换异常(ClassCastException)

Checked Exception(检查型异常)：编译器要求必须处置的异常，是除RuntimeException及其子类以外的其他Exception类的子类，如IOExcetipn + SQLException。编译器会检查这些异常，当程序中可能出现这类异常时，要求必须进行异常处理，否则编译不会通过。

Java异常处理机制：抛出+捕获

  • try-catch-finally
  • throws(声明)、throw(抛出这个动作)

2.例子说明

2.1 Try-Catch-Finally

  • try后可以接0/N个catch块，如果没有catch，则必须跟一个finally块；
  • finally块都会执行，除非 catch中有 System.exit(1)

TryDemoOne.java

package com.imooc.test;
import java.util.InputMismatchException;
import java.util.Scanner;
public class TryDemoOne {
    public static void main(String[] args) {
    /*    //要求:定义两个整数，输出两数之商
        int one=12;
        int two=2;
        System.out.println("one和two的商是:" + (one/two));

    */
         Scanner input=new Scanner(System.in);
         System.out.println("=====运算开始=====");
         try{
             System.out.println("请输入第一个整数:");
             int one=input.nextInt();
             System.out.println("请输入第二个整数:");
             int two=input.nextInt();
             double res = (one/two);
             System.out.println("one和two的商是:" + res);
         }catch(ArithmeticException e) {
             System.exit(1);//终止程序运行
             System.out.println("除数不能为0！");
             e.printStackTrace();
         }catch(InputMismatchException e){
             System.out.println("请输入整数！");
             e.printStackTrace();
         }catch(Exception e) {
             System.out.println("程序错误！");
             e.printStackTrace();
         }
         finally{
             System.out.println("=====运算结束=====");
         }
    }
}

2.2 return关键字的异常处理中的作用

  • 运行顺序式：catch→finally→catch中的return
  • finally里面不要写 return

TryDemoTwo.java

package com.imooc.test;
import java.util.Scanner;

public class TryDemoTwo {
    public static void main(String[] args) {
        int res=test();
        System.out.println("one和two的商是:" + res);
    }
    public static int test(){
        Scanner input=new Scanner(System.in);
        System.out.println("=====运算开始=====");
        try{
            System.out.println("请输入第一个整数:");
            int one=input.nextInt();
            System.out.println("请输入第二个整数:");
            int two=input.nextInt();
            return one/two;
        }catch(ArithmeticException e) {
            //System.exit(1);//终止程序运行
            System.out.println("除数不能为0！");
            return 0;
        } finally {
            System.out.println("=====运算结束=====");
            //这里的return必须去掉，否则程序逻辑就会错误，返回的永远都是 100
            //return 100;
        }
    }
}

2.3 throw & throws

有两种方式：自己抛自己处理，和自己抛让调用的方法处理

这里其实使用抛出异常来完成一些程序的业务逻辑，比如下面的例子就是 酒店的入住人员的年龄限制的代码

1.自己抛自己处理

package com.imooc.test;

import java.util.Scanner;

public class TryDemoFour {
    public static void main(String[] args) {
        testAge();
    }
    public static void testAge(){
        try{
            System.out.println("请输入年龄:");
        	Scanner input = new Scanner(System.in);
            int age = input.nextInt();
            if( age < 18 || age > 80) {
                throw new Exception("年龄小于18或大于80不得入住，需要适龄人员陪同");
            } else {
                System.out.println("欢迎入住本酒店");
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        
    }
}

2.自己抛让调用的人处理

package com.imooc.test;

import java.util.Scanner;

public class TryDemoFour {
    public static void main(String[] args) {
        try{
            testAge();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void testAge() throws Exception{ // Exception可以替换为 Throwable
        System.out.println("请输入年龄:");
        Scanner input = new Scanner(System.in);
        int age = input.nextInt();
        if( age < 18 || age > 80) {
            throw new Exception("年龄小于18或大于80不得入住，需要适龄人员陪同");
        } else {
            System.out.println("欢迎入住本酒店");
        }
    }
}

2.4 自定义异常

  • 通过自定义异常描述特定业务产生的异常类型；
  • 自定义异常，即定义一个类，去继承Throwable类或者它的子类

例如在上例中，可以这么新建一个类 HotelAgeException.java 继承 Exception：

//  HotelAgeException.java
package com.imooc.test;

public class HotelAgeException extends Exception{
    public HotelAgeException(){
        super("年龄小于18或大于80不得入住，需要适龄人员陪同");
    }
}

那么 TryDemoFour.java就需要修改一下：

package com.imooc.test;
import java.util.Scanner;
public class TryDemoFour {
    public static void main(String[] args) {
        try{
            testAge();
        } catch (HotelAgeException e) {
            System.out.println(e.getMessage());
            System.out.println("酒店前台工作人员不允许办理入住登记");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void testAge() throws HotelAgeException{ // Exception可以替换为 Throwable
        System.out.println("请输入年龄:");
        Scanner input = new Scanner(System.in);
        int age = input.nextInt();
        if( age < 18 || age > 80) {
            throw new HotelAgeException();
        } else {
            System.out.println("欢迎入住本酒店");
        }
    }
}

2.5 异常链

  • 捕获一个异常后再抛出另一个异常；
  • 将异常发生的原因一个传递给另一个，把底层的异常信息传给上层，这样逐层抛出。

在下面的例子中，testOne 抛出一个异常，testTwo接受并抛出另一个异常，testThree接受并抛出另一个异常

package com.imooc.test;

public class TryDemoFive {
    
    public static void main(String[] args) {
        try{
            testThree();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void testOne() throws HotelAgeException {
        throw new HotelAgeException();
    }

    public static void testTwo() throws Exception {
        try{
            testOne();
        } catch(HotelAgeException e) {
            throw new Exception("我是新产生的异常1" ,e);// 方法1
        }

    }

    public static void testThree() throws Exception {
        try{
            testTwo();
        } catch(Exception e) {
            Exception e1=new Exception("我是新产生的异常2"); //方法2
            e1.initCause(e);
            throw e1;
            //throw new Exception("我是新产生的异常2" ,e);
        }
    }
}

上述代码避免了一般的异常链导致的只获取最后 testThree("我是新产生的异常2") 的弊端，对于每一个异常的信息都保存并显示出来，有两种方法

2.6 throws的使用规则

  • 如果是不可查异常（unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出；

  • 如果一个方法中可能出现可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误；

  • 当抛出了异常，则该方法的调用者必须处理或者重新抛出该异常；

  • 当子类重写父类抛出异常的方法时，声明的异常必须是父类方法所声明异常的同类或子类。

    针对这个有代码证明：

    // FatherTest.java
package com.imooc.test;

public class FatherTest {
	public void test() throws HotelAgeException{
		throw new HotelAgeException();
	}
}

//HotelAgeException.java
package com.imooc.test;

public class HotelAgeException extends Exception {
	public HotelAgeException(){
		super("18岁以下，80岁以上的住客必须由亲友陪同");
	}
}

class SubException extends HotelAgeException{}

//SubTest.java
//在这里 子类抛出的SubException继承自父类抛出的HotelAgeException,否则就会报错
package com.imooc.test;

public class SubTest extends FatherTest {
	@Override
	public void test() throws SubException {
		// TODO Auto-generated method stub
		//super.test();
	}
}

3.总结

  • 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理

  • 在多重catch块后面，可以加一个catch（Exception e）来处理可能会被遗漏的异常

  • 对于不确定的代码，也可以加上try-catch，处理潜在的异常

  • 尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出

  • 具体如何处理异常，要根据不同的业务需求和异常类型去决定

  • 尽量添加finally语句块去释放占用的资源

推荐阅读