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() + ")";
    }
}