Java基础(十五)：异常处理

Java基础系列文章

一、异常概述

1、什么是程序异常

• 在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美
• 在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的
• 比如：客户输入数据的格式问题，读取文件是否存在，网络是否始终保持通畅等等

异常 ：指的是程序在执行过程中，出现的非正常情况，如果不处理最终会导致JVM的非正常停止

• 异常指的并不是语法错误和逻辑错误。语法错了，编译不通过，不会产生字节码文件，根本不能运行
• 代码逻辑错误，只是没有得到想要的结果，例如：求a与b的和，你写成了a-b

2、异常的抛出机制

• Java中把不同的异常用不同的类表示，一旦发生某种异常，就创建该异常类型的对象，并且抛出（throw）
• 然后程序员可以捕获(catch)到这个异常对象，并处理，则程序继续往下执行
• 如果没有捕获(catch)这个异常对象，那么这个异常对象将会导致程序终止

二、Java异常体系

1、Throwable

• java.lang.Throwable 类是Java程序执行过程中发生的异常事件对应的类的根父类
• Throwable中的常用方法：
  • public void printStackTrace()：打印异常的详细信息 包含了异常的类型、异常的原因、异常出现的位置、在开发和调试阶段都得使用printStackTrace
  • public String getMessage()：获取发生异常的原因

2、Error 和 Exception

• Throwable可分为两类：Error和Exception。分别对应着java.lang.Error与java.lang.Exception两个类
• Error：Java虚拟机无法解决的严重问题
  • 如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理
  • 例如：StackOverflowError（栈内存溢出）和OutOfMemoryError（堆内存溢出，简称OOM）
• Exception: 其它因编程错误或偶然的外在因素导致的一般性问题
  • 需要使用针对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉
  • 如：空指针访问、试图读取不存在的文件、数组角标越界

3、编译时异常和运行时异常

• Java程序的执行分为编译时过程和运行时过程
• 有的错误只有在运行时才会发生。比如：除数为0，数组下标越界等

因此，根据异常可能出现的阶段，可以将异常分为：

• 编译时期异常（即checked异常、受检异常）
  • 在代码编译阶段，编译器就能明确警示当前代码可能发生（不是一定发生）xx异常
  • 并明确督促程序员提前编写处理它的代码
  • 如果程序员没有编写对应的异常处理代码，则编译器就会直接判定编译失败，从而不能生成字节码文件
  • 通常，这类异常的发生不是由程序员的代码引起的
  • 或者不是靠加简单判断就可以避免的，例如：FileNotFoundException（文件找不到异常）
• 运行时期异常（即runtime异常、unchecked异常、非受检异常）
  • 在代码编译阶段，编译器完全不做任何检查
  • 无论该异常是否会发生，编译器都不给出任何提示
  • 只有等代码运行起来并确实发生了xx异常，它才能被发现
  • 通常，这类异常是由程序员的代码编写不当引起的，只要稍加判断，或者细心检查就可以避免
  • java.lang.RuntimeException类及它的子类都是运行时异常

三、异常的处理

1、捕获异常（try-catch-finally）

• Java提供了异常处理的抓抛模型
• Java程序的执行过程中如出现异常，会生成一个异常类对象
• 该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常
  • 如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理 如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法 这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常
  • 如果一个异常回到main()方法，并且main()也不处理，则程序运行终止

try-catch-finally基本格式

try{
	......	//可能产生异常的代码
}
catch( 异常类型1 e ){
	......	//当产生异常类型1型异常时的处置措施
}
catch( 异常类型2 e ){
	...... 	//当产生异常类型2型异常时的处置措施
}  
finally{
	...... //无论是否发生异常，都无条件执行的语句
} 

1、整体执行过程：

当某段代码可能发生异常，不管这个异常是编译时异常（受检异常）还是运行时异常（非受检异常），我们都可以使用try块将它括起来，并在try块下面编写catch分支尝试捕获对应的异常对象

• 如果在程序运行时，try块中的代码没有发生异常，那么catch所有的分支都不执行
• 如果在程序运行时，try块中的代码发生了异常，根据异常对象的类型，将从上到下选择第一个匹配的catch分支执行。此时try中发生异常的语句下面的代码将不执行，而整个try…catch之后的代码可以继续运行
• 如果在程序运行时，try块中的代码发生了异常，但是所有catch分支都无法匹配（捕获）这个异常，那么JVM将会终止当前方法的执行，并把异常对象“抛”给调用者。如果调用者不处理，程序就挂了

2、try

• 捕获异常的第一步是用try{…}语句块选定捕获异常的范围
• 将可能出现异常的业务逻辑代码放在try语句块中

3、catch (Exceptiontype e)

• catch分支，分为两个部分，catch()中编写异常类型和异常参数名，{}中编写如果发生了这个异常，要做什么处理的代码
• 如果明确知道产生的是何种异常，可以用该异常类作为catch的参数；也可以用其父类作为catch的参数
• 每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象
• 如果有多个catch分支，并且多个异常类型有父子类关系，必须保证小的子异常类型在上，大的父异常类型在下。否则，报错
• catch中常用异常处理的方式
  • public String getMessage()：获取异常的描述信息，返回字符串
  • public void printStackTrace()：打印异常的跟踪栈信息并输出到控制台。包含了异常的类型、异常的原因、还包括异常出现的位置，在开发和调试阶段，都得使用printStackTrace()

finally使用

• 因为异常会引发程序跳转，从而会导致有些语句执行不到。而程序中有一些特定的代码无论异常是否发生，都需要执行
  • 例如，数据库连接、输入流输出流、Socket连接、Lock锁的关闭等
  • 这样的代码通常就会放到finally块中
  • 所以，我们通常将一定要被执行的代码声明在finally中
  • 唯一的例外，使用 System.exit(0) 来终止当前正在运行的 Java 虚拟机
• 不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行
• finally语句和catch语句是可选的，但finally不能单独使用

try{
     
}finally{
    
} 

笔试题：

public class ExceptionTest {
    public static void main(String[] args) {
        int result = test();
        System.out.println(result); //100
    }

    public static int test(){
        int i = 100;
        try {
            return i;
        } finally {
            i++;
        }
    }
}

异常处理的体会

• 如果异常都是RuntimeException类或是它的子类
  • 这些类的异常的特点是：即使没有使用try和catch捕获
  • Java自己也能捕获，并且编译通过 ( 但运行时会发生异常使得程序运行终止 )
  • 所以，对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响
• 如果抛出的异常是IOException等类型的非运行时异常
  • 则必须捕获，否则编译错误
  • 也就是说，我们必须处理编译时异常，将异常进行捕捉，转化为运行时异常

2、声明抛出异常类型（throws）

• 如果在编写方法体的代码时，某句代码可能发生某个编译时异常，不处理编译不通过
• 但是在当前方法体中可能不适合处理或无法给出合理的处理方式
• 则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理

• 具体方式：在方法声明中用throws语句可以声明抛出异常的列表
• throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类

3、异常处理5个关键字

四、手动抛出异常对象：throw

Java 中异常对象的生成有两种方式

• 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，那么针对当前代码，就会在后台自动创建一个对应异常类的实例对象并抛出
• 由开发人员手动创建：new 异常类型([实参列表]);，如果创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样，但是一旦throw抛出，就会对程序运行产生影响了

使用格式

throw new 异常类名(参数);

• throw语句抛出的异常对象，和JVM自动创建和抛出的异常对象一样
• 如果是编译时异常类型的对象，同样需要使用throws或者try…catch处理，否则编译不通过
• 如果是运行时异常类型的对象，编译器不提示

使用注意点

• 无论是编译时异常类型的对象，还是运行时异常类型的对象，如果没有被try…catch合理的处理，都会导致程序崩溃
• throw语句会导致程序执行流程被改变，throw语句是明确抛出一个异常对象，因此它下面的代码将不会执行
• 如果当前方法没有try…catch处理这个异常对象，throw语句就会代替return语句提前终止当前方法的执行，并返回一个异常对象给调用者

五、自定义异常

1、为什么需要自定义异常类

• Java中不同的异常类，分别表示着某一种具体的异常情况
• 那么在开发中总是有些异常情况是核心类库中没有定义好的
• 此时我们需要根据自己业务的异常情况来定义异常类
• 例如年龄负数问题，考试成绩负数问题，某员工已在团队中等

2、如何自定义异常类

• 要继承一个异常类型
  • 自定义一个编译时异常类型：自定义类继承java.lang.Exception
  • 自定义一个运行时异常类型：自定义类继承java.lang.RuntimeException
• 建议大家提供至少两个构造器，一个是无参构造，一个是(String message)构造器
• 自定义异常需要提供serialVersionUID

注意点

• 自定义的异常里面定义赋值属性值，catch异常时候可以使用e.属性获取值
• 自定义异常最重要的是异常类的名字和message属性
  • 当异常出现时，可以根据名字判断异常类型
  • 比如：TeamException("成员已满，无法添加"); 、 TeamException("该员工已是某团队成员")
• 自定义异常对象只能手动抛出。抛出后由try…catch处理，也可以甩锅throws给调用者处理

举例1：

public class MyException extends Exception {
    private static final long serialVersionUID = 23423423435L;
    private int idnumber;

    public MyException(String message, int id) {
        super(message);
        this.idnumber = id;
    }

    public int getId() {
        return idnumber;
    }
}

public class MyExpTest {
    public void regist(int num) throws MyException {
        if (num < 0)
            throw new MyException("人数为负值，不合理", 3);
        else
            System.out.println("登记人数" + num);
    }
    public void manager() {
        try {
            regist(100);
        } catch (MyException e) {
            System.out.print("登记失败，出错种类" + e.getId());
        }
        System.out.print("本次登记操作结束");
    }
    public static void main(String args[]) {
        MyExpTest t = new MyExpTest();
        t.manager();
    }
}

举例2：

public class BizException extends RuntimeException {
    private static final long serialVersionUID = -7148169437991097594L;
    protected String errorMsg;
    protected Object data = null;

    public BizException() {
    }

    public BizException(String errorMsg) {
        super(errorMsg);
        this.errorMsg = errorMsg;
    }

    public BizException(String errorMsg, Object data) {
        super(errorMsg);
        this.errorMsg = errorMsg;
        this.data = data;
    }

    public BizException(String message, String errorMsg) {
        super(message);
        this.errorMsg = errorMsg;
    }

    public BizException(String message, Throwable cause, String errorMsg) {
        super(message, cause);
        this.errorMsg = errorMsg;
    }

    public BizException(Throwable cause, String errorMsg) {
        super(cause);
        this.errorMsg = errorMsg;
    }

    public BizException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, String errorMsg) {
        super(message, cause, enableSuppression, writableStackTrace);
        this.errorMsg = errorMsg;
    }

    public String getErrorMsg() {
        return this.errorMsg;
    }

    public Object getData() {
        return this.data;
    }

    public void setErrorMsg(String errorMsg) {
        this.errorMsg = errorMsg;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public String toString() {
        return "BizException(errorMsg=" + this.getErrorMsg() + ", data=" + this.getData() + ")";
    }
}