黑马程序员全套Java教程_Java基础教程_异常（含扩展）（二十三）

1.1 异常概述与异常体系结构

• 在开发过程中，即是我们把代码写得尽善尽美，在系统运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，如：客户输入数据的格式、读取文件是否存在、网络是否始终保持通畅等。
• 异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。（开发过程中的语法错误和逻辑错误等代码问题不是异常）
• Java程序执行时发生的异常事件的分类：
  （1）Error：Java虚拟机无法解决的严重问题（程序执行分为编译和运行两个过程，运行的时候特别需要使用JVM）。如：JVM系统内部错误、资源耗尽（比如StackOverflowError（栈溢出，如下例：递归调用导致的栈溢出）和OOM（堆溢出））等严重情况。一般不（无法）编写针对性的代码进行处理。
  （2）Exception(狭义上的异常，我们所说的异常处理通常就是指这个，不包括Error)：其他因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。如：
  （1）空指针访问
  （2）试图读取不存在的文件
  （3）网络连接中断
  （4）数组角标越界

//资源耗尽的两种情况
//1、递归调用导致的栈溢出java.lang.StackOverflowError
public class ErrorTest {
    public static void main(String[] args) {
        main(args);
    }
}

//2、new的空间过大，堆溢出java.lang.OutOfMemoryError
public class ErrorTest {
    public static void main(String[] args) {
        Integer[] arr = new Integer[1024*1024*1024];
    }
}

• 异常的两种解决方法：一是遇到错误就终止程序的执行（默认）。二是由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。
• 异常体系结构：
  
  Error和Exception是两个类，我们可以查看api，它们的父类是Throwable（为顶级父类）。
  （1）java.lang.Error：An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch. Most such errors are abnormal conditions. The ThreadDeath error, though a “normal” condition, is also a subclass of Error because most applications should not try to catch it.
  Error是Throwable的一个子类，它表示合理的应用程序不应该捕捉的严重问题。大多数这样的错误都是异常情况。
  除了ThreadDeath，其他错误基本都是以*****Error的格式命名（如java.lang.StackOverflowError和java.lang.OutOfMemoryError），ThreadDeath错误虽然是“正常”情况，但也是错误的一个子类，因为大多数应用程序不应该尝试捕捉它。
  综上，对于Error，我们一般不编写针对性的代码进行处理。
  （2）java.lang.Exception：上图Exception类下，红色为编译时异常，蓝色为运行时异常，关于两者区别可转到本文1.6。

1.2 JVM遇到异常时的默认处理方案

运行下列程序：

public class ExceptionDemo2 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }

    public static void method() {
        int[] arr = {1, 2, 3};
        System.out.println(3);
    }
}

控制台会输出结果：

开始
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
	at itheima.ExceptionDemo2.method(ExceptionDemo2.java:18)
	at itheima.ExceptionDemo2.main(ExceptionDemo2.java:12)

可以看到在输出“开始之后”，控制台在第二行输出了异常的类名ArrayIndexOutOfBoundsException及原因，第三行输出了异常出现的位置（第18行）。而程序并没有输出“结束”，这说明JVM将异常的对应信息输出之后，就将程序结束了。

• 综上，如果程序出现了问题，我们没有做任何处理，最终会作默认的处理：
  （1）把异常的名称、异常原因以及异常出现的位置等信息输出在了控制台；
  （2）程序停止执行。

1.3 异常处理

• 如果程序出现了问题，我们需要自己来处理，有两种方案：
  （1）try……catch……
  （2）throws

1.4 异常处理之try……catch……

• 格式：

try{
	可能出现异常的代码
} catch(异常类名 变量名) {
	异常的处理代码;
}

• 执行流程：程序从try里面的代码开始执行。出现异常，会自动生成（new）一个异常类对象，该异常对象将被提交给Java运行时系统。当Java运行时系统接收到异常对象时，会到catch中去找匹配的异常类，找到后进行异常的处理。执行完毕之后，程序还可以继续往下执行。

public class ExceptionDemo2 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }

    public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);//new ArrayIndexOutOfBoundsException()
        } catch (ArrayIndexOutOfBoundsException e){
            //System.out.println("你访问的数组对象不存在");
            e.printStackTrace();
        }

    }
}

1.5 Throwable的成员方法

方法名	说明
public String getMessage()	返回Throwable的详细消息字符串
public String toString()	返回可抛出的简短描述
public void printStackTrace()	把异常信息错误输出在控制台

    public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        } catch (ArrayIndexOutOfBoundsException e){//ArrayIndexOutOfBoundsException
            System.out.println(e.getMessage());//3
            System.out.println(e.toString());//java.lang.ArrayIndexOutOfBoundsException: 3
        }

    }

    public static void method2(){
        try{
            System.out.println(1000/0);
        }catch (Exception e){//ArithmeticException
            System.out.println(e.getMessage());//输出/ by zero
            System.out.println(e.toString());//java.lang.ArithmeticException: / by zero
        }
    }

getMessage()：返回Throwable的详细消息字符串（视JDK版本有所不同），我们可以通过ctrl+B查看Throwable类下的getMessage()，这个方法返回了String类型的成员变量detailMessage，并在这个方法往上面翻，我们会发现很多Throwable的构造方法，这些构造方法对detailMessage进行了赋值。可知在我们new某种异常对象的时候，子类根据传入的参数（包括无参和带参）调用对应的Throwable父类参构造方法，在构造方法中对detailMessage进行赋值，我们通过getMessage()就可以得到这个值。

public class Throwable implements Serializable {
    private String detailMessage;
	略。。。
	public Throwable(String message) {
        构造方法实现过程。。。
        detailMessage = message;
    }
    其他构造法。。。
    public String getMessage() {
        return detailMessage;
    }
    略。。。
    
}

toString()：返回可抛出的简短描述，包括异常的原因（即getMessage()的内容）及异常的类名。
printStackTrace()：把异常信息错误输出在控制台，包括异常的类名、原因及位置信息。此方法输出信息比较全，所以我们一般调用这个方法查看异常的相关信息。

1.6 编译时异常和运行时异常的区别

• 异常的体系结构：捕获异常（异常也是一个对象，捕获即catch）最理想的是在编译期间（javac.exe执行时），但有的错误只有在运行时（java.exe执行时）才会发生（比如：除数为0、数组下表越界等）。据此，我们将异常分为编译时异常和运行时异常
  （1）运行时异常（也称非受检异常）：指编译器不要求强制处置的异常。一般指编程时的逻辑错误，是程序员应该积极避免其出现的异常。包含java.lang.RuntimeException类及它的子类。对于这类异常，可以不作处理，因为这类异常很普遍，若全部处理可能会对程序的可读性和运行效率产生影响。（无需显示处理，也可以和编译时异常一样处理）
  （2）编译时异常（也称受检异常）：是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。对于这类异常，如程序不处理，可能会带来意想不到的结果。（必须显示处理，否则程序就会发生错误，无法通过编译）
  （3）tip：可以通过在API文档内搜索对应的异常类查看其父类及祖宗类是否有RuntimeException，有的话说明是编译时异常，否则即为运行时异常。
  

public class ExceptionDemo3 {
    public static void main(String[] args) {
        System.out.println("开始");
        method2();
        System.out.println("结束");
    }

    //编译时异常
    public static void method2() {
        String s = "2021-11-11";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //报红：Unhandled exception: java.text.ParseException（Unhandled未经手触过的，未经处理的）
        //通过查看API文档，知其父类为Exception类，说明为编译时异常
        //Date date = sdf.parse(s);
        //System.out.println(date);

        //解决方案
        try{
            Date date = sdf.parse(s);
            System.out.println(date);//Thu Nov 11 00:00:00 CST 2021
        }catch (ParseException e){
            e.printStackTrace();
        }
    }

    //运行时异常
    public static void method() {
        int[] arr = {1, 2, 3};
        //ArrayIndexOutOfBoundsException，其爷爷类为java.lang.RuntimeException，说明为运行时异常
        System.out.println(arr[3]);

        //解决方案
        //try{
        在这里我们可以知道，编译时异常并不是一定会出现的异常，只是有可能出现，只要我们字符串s与sdf的格式是匹配的，就不会出现问题
        而编译器是知道会出现问题，所以报红告诉我们，让我们解决
        //    System.out.println(arr[3]);
        //}catch (ArrayIndexOutOfBoundsException e){
        //    e.printStackTrace();
        //}
    }
}

1.7 异常处理之throws

• 虽然我们通过try…catch…可以对异常进行出路，但是并不是所有的情况我们都有权限进行异常的处理。也就是说，有些时候可能出现的异常是我们解决不了的，这个时候怎么办呢？Java对此提供了throws的处理方案
• 格式（可以在异常报红处Alt+Enter快速生成）：

throws 异常类名;

注意：这个格式是跟在方法后面的

public class ExceptionDemo4 {
    public static void main(String[] args) {
        System.out.println("开始");

        //method();

        //抛出的异常没有进行处理，现在调用的时候还是要处理
        try{
            method2();
        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println("结束");
    }

    //编译时异常
    //先不对异常进行处理，只是抛出（延迟）异常
    public static void method2() throws ParseException {
        String s = "2021-11-11";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(s);
        System.out.println(date);//Thu Nov 11 00:00:00 CST 2021
    }

    //运行时异常
    public static void method() throws ArrayIndexOutOfBoundsException {
        int[] arr = {1, 2, 3};
        System.out.println(arr[3]);//只输出了“开始”没有输出“结束”
    }
}

不管是运行时异常还是编译时异常，我们都可以在方法后面通过throws抛出，但是这个抛出并没有做实际的处理，真正的处理还是得通过try…catch…实现。也就是说，只要你想让程序继续往下执行，就要使用try…catch…进行处理，只不过假如我们处理不了异常，我们可以抛出去（即延迟处理），在调用的时候再进行处理（让调用者处理）。
编译时异常必须要进行处理，两种处理方案：try…catch…或者throws，如果采用throws这种方案，将来谁调用谁处理。
运行时异常可以不处理，出问题后，需要我们回来修改代码。

1.8 自定义异常

• 虽然Java提供了很多异常类供我们使用，但是在实际开发中，这里类并不能满足我们所有的需求。比如说我们想设置学生的考试成绩只能在0~100之间。所以就需要我们自己定义异常类来实现需求。
• 那么我们如何让自己定义的异常类称为异常体系的一员呢？
  在IDEA界面按快捷键Ctrl+N，搜索NullPointException类，发现其继承自RuntimeException类；再搜索ParseException类，发现其继承自Exception类。
  
  
  也就是说如果我们自定义的类继承自RuntimeException和Exception，类就可以作为异常体系的一员。
  格式：

public class 异常类名 extends Exception(){
	无参构造
	带参构造
}

范例：

public class ScoreException extends Exception{
	public ScoreException(){}
	public ScoreException(String message){
		super(message);
	}
}

为什么带参构造方法要将message传给父类Exception类呢？我们Ctrl+B查看super的构造方法：

    public Exception(String message) {
        super(message);
    }

Ctrl+B继续跟进super

    public Throwable(String message) {
        fillInStackTrace();
        detailMessage = message;
    }

这里的message传给了detailMessage，在上文1.5Throwable的成员方法学习中我们了解到，detailMessage是Throwable的一个成员变量，我们把message传给父类之后，detailMessage有了值，将来就可以通过getMessage()或者printStackTrace()来查看detailMessage。

public class ScoreException extends Exception{
    public ScoreException(){}

    public ScoreException(String message){
        super(message);
    }
}

public class Teacher {

    public void check(int score) throws ScoreException {
        //不符合分数范围的条件，所以我们就要产生一个异常对象并抛出
        if(score < 0 || score>100){
            //抛出异常对象的关键字是throw（后面没有“s”，用于在方法体内部抛出对象）
            //自定义异常类的异常对象需要我们手动throw，而Java提供的异常类如果我们不抛出他也会自动new一个异常对象并throw
            //因为抛出的ScoreException异常继承自Exception，为编译时异常，所以check()要用throws将异常类（是类，不是对象）抛出，将来在调用check()的时候就会报红，我们就可以知道这个方法有一个编译时异常需要进行处理
            //当然，如果ScoreException继承自RuntimeException，可以throws也可以不throws
            //无参构造：不显示异常产生原因
            //throw new ScoreException();

            //带参构造方法：显示异常产生原因
            throw new ScoreException("你输入的分数不合法");
        }else{
            System.out.println("分数合法");
        }
    }
}

public class TeacherTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入分数：");
        int score = sc.nextInt();

        Teacher t = new Teacher();
        try {
            t.check(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

throws和throw的区别：
（1）throws用在方法声明后面，跟的是异常类名；而throw用在方法体内，跟的是异常对象名；
（2）throws表示抛出异常，由该方法的调用者来处理；而throw表示抛出异常，由方法体内的语句处理；
（3）throws表示出现异常的一种可能性，并不一定会发生这些异常；而执行throw一定抛出了某种异常。