# 第 09 章_异常处理

讲师：尚硅谷 - 宋红康（江湖人称：康师傅）

官网：http://www.atguigu.com

# 本章专题与脉络

# 1. 异常概述

# 1.1 什么是生活的异常

男主角小明每天开车上班，正常车程 1 小时。但是，不出意外的话，可能会出现意外。

出现意外，即为异常情况。我们会做相应的处理。如果不处理，到不了公司。处理完了，就可以正常开车去公司。

# 1.2 什么是程序的异常

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

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

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

# 1.3 异常的抛出机制

Java 中是如何表示不同的异常情况，又是如何让程序员得知，并处理异常的呢？

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

举例：

运行下面的程序，程序会产生一个数组角标越界异常 ArrayIndexOfBoundsException 。我们通过图解来解析下异常产生和抛出的过程。

	public class ArrayTools {
	// 对给定的数组通过给定的角标获取元素。
	public static int getElement(int[] arr, int index) {
	int element = arr[index];
	return element;
	}
	}

测试类

	public class ExceptionDemo {
	public static void main(String[] args) {
	int[] arr = { 34, 12, 67 };
	intnum = ArrayTools.getElement(arr, 4)
	System.out.println("num=" + num);
	System.out.println("over");
	}
	}

上述程序执行过程图解：

# 1.4 如何对待异常

对于程序出现的异常，一般有两种解决方法：一是遇到错误就终止程序的运行。另一种方法是程序员在编写程序时，就充分考虑到各种可能发生的异常和错误，极力预防和避免。实在无法避免的，要编写相应的代码进行异常的检测、以及 异常的处理 ，保证代码的 健壮性 。

# 2. Java 异常体系

# 2.1 Throwable

**java.lang.Throwable 类** 是 Java 程序执行过程中发生的异常事件对应的类的根父类。

Throwable 中的常用方法：

public void printStackTrace() ：打印异常的详细信息。
包含了异常的类型、异常的原因、异常出现的位置、在开发和调试阶段都得使用 printStackTrace。
public String getMessage() ：获取发生异常的原因。

# 2.2 Error 和 Exception

Throwable 可分为两类：Error 和 Exception。分别对应着 java.lang.Error 类与 java.lang.Exception 类。

**java.lang.Error 类：**Java 虚拟机无法解决的严重问题。如：JVM 系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理

例如：StackOverflowError（栈内存溢出）和 OutOfMemoryError（堆内存溢出，简称 OOM）。

java.lang.Exception 类： 其它因编程错误或偶然的外在因素导致的一般性问题，需要使用针对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉。例如：

空指针访问
试图读取不存在的文件
网络连接中断
数组角标越界

说明：
无论是 Error 还是 Exception，还有很多子类，异常的类型非常丰富。当代码运行出现异常时，特别是我们不熟悉的异常时，不要紧张，把异常的简单类名，拷贝到 API 中去查去认识它即可。
我们本章讲的异常处理，其实针对的就是 Exception。

# 2.3 编译时异常和运行时异常

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

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

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

1562771528807

# 3. 常见的错误和异常

# 3.1 Error

最常见的就是VirtualMachineError，经典的子类：

StackOverflowError：调用栈溢出，通常是由于递归调用的次数过多导致的。
OutOfMemoryError（OOM）：无法分配内存，通常是由于程序中创建了过多的对象或持续运行时间过长（即内存泄露）导致的。

	package com.atguigu.exception;

	import org.junit.Test;

	public class TestStackOverflowError {
	@Test
	public void test01(){
	//StackOverflowError
	recursion();
	}

	public void recursion(){ // 递归方法
	recursion();
	}
	}

	package com.atguigu.exception;

	import org.junit.Test;

	public class TestOutOfMemoryError {
	@Test
	public void test02(){
	//OutOfMemoryError
	// 方式一：
	int[] arr = new int[Integer.MAX_VALUE];
	}
	@Test
	public void test03(){
	//OutOfMemoryError
	// 方式二：
	StringBuilder s = new StringBuilder();
	while(true){
	s.append("atguigu");
	}
	}
	}

# 3.2 运行时异常

在执行 java.exe 命令时出现的异常：

NullPointerException：当尝试调用空引用的方法时
ClassCastException：当试图将一个对象强制转换为另一种类型，但该对象实际上不是该类型时
ArrayIndexOutOfBoundsException：当尝试访问数组或集合中不存在的索引时
InputMismatchException：当 Scanner 类或其它输入流读取操作遇到的输入不匹配时，就会抛出该异常
ArithmeticException：当一个算术运算操作出现异常时，例如除 0 / 取模 0

	package com.atguigu.exception;

	import org.junit.Test;

	import java.util.Scanner;

	public class TestRuntimeException {
	@Test
	public void test01(){
	//NullPointerException
	int[][] arr = new int[3][];
	System.out.println(arr[0].length);
	}

	@Test
	public void test02(){
	//ClassCastException
	Object obj = 15;
	String str = (String) obj;
	}

	@Test
	public void test03(){
	//ArrayIndexOutOfBoundsException
	int[] arr = new int[5];
	for (int i = 1; i <= 5; i++) {
	System.out.println(arr[i]);
	}
	}

	@Test
	public void test04(){
	//InputMismatchException
	Scanner input = new Scanner(System.in);
	System.out.print("请输入一个整数：");// 输入非整数
	int num = input.nextInt();
	input.close();
	}

	@Test
	public void test05(){
	int a = 1;
	int b = 0;
	//ArithmeticException
	System.out.println(a/b);
	}
	}

# 3.3 编译时异常

在执行 javac.exe 命令时出现的异常：

InterruptedException：通常发生在一个线程在等待另一个线程执行完毕时，而等待的线程被中断（interrupted）时抛出。当一个线程在调用了 sleep ()、wait () 或 join () 等方法后，如果在等待期间被中断，则会抛出 InterruptedException 异常。
ClassNotFoundException：尝试加载某个类时，如果找不到该类的定义，则会抛出该异常
FileNotFoundException：当尝试打开文件时，如果文件不存在或者无法访问，则会抛出该异常。
IOException：通常用于处理输入输出操作中可能出现的异常情况。当进行文件读写、网络连接、Socket 通信等 I/O 操作时，如果发生异常，都会抛出 IOException 或其子类的异常。

	package com.atguigu.exception;

	import org.junit.Test;

	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.sql.Connection;
	import java.sql.DriverManager;
	import java.sql.SQLException;

	public class TestCheckedException {
	@Test
	public void test06() {
	Thread.sleep(1000);// 休眠 1 秒 InterruptedException
	}

	@Test
	public void test07(){
	Class c = Class.forName("java.lang.String");//ClassNotFoundException
	}

	@Test
	public void test08() {
	Connection conn = DriverManager.getConnection("...."); //SQLException
	}
	@Test
	public void test09() {
	FileInputStream fis = new FileInputStream("尚硅谷Java秘籍.txt"); //FileNotFoundException
	}
	@Test
	public void test10() {
	File file = new File("尚硅谷Java秘籍.txt");
	FileInputStream fis = new FileInputStream(file);//FileNotFoundException
	int b = fis.read();//IOException
	while(b != -1){
	System.out.print((char)b);
	b = fis.read();//IOException
	}

	fis.close();//IOException
	}
	}

# 4. 异常的处理

# 4.1 异常处理概述

在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行 x/y 运算时，要 检测分母为0 ， 数据为空 ， 输入的不是数据而是字符 等。过多的 if-else 分支会导致程序的 代码加长 、 臃肿 ， 可读性差 ，程序员需要花很大的精力 “ 堵漏洞 ”。因此采用异常处理机制。

Java 异常处理

Java 采用的异常处理机制，是 将异常处理的程序代码集中在一起 ，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。

Java 异常处理的方式：

方式一：try-catch-finally

方式二：throws + 异常类型

# 4.2 方式 1：捕获异常（try-catch-finally）

Java 提供了异常处理的抓抛模型。

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

# 4.2.1 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 的参数。
比如：可以用 ArithmeticException 类作为参数的地方，就可以用 RuntimeException 类作为参数，或者用所有异常的父类 Exception 类作为参数。但不能是与 ArithmeticException 类无关的异常，如 NullPointerException（catch 中的语句将不会执行）。
每个 try 语句块可以伴随一个或多个 catch 语句，用于处理可能产生的不同类型的异常对象。
如果有多个 catch 分支，并且多个异常类型有父子类关系，必须保证小的子异常类型在上，大的父异常类型在下。否则，报错。
catch 中常用异常处理的方式
- public String getMessage() ：获取异常的描述信息，返回字符串
- public void printStackTrace() ：打印异常的跟踪栈信息并输出到控制台。包含了异常的类型、异常的原因、还包括异常出现的位置，在开发和调试阶段，都得使用 printStackTrace ()。

# 4.2.2 使用举例

举例 1：

	public class IndexOutExp {
	public static void main(String[] args) {
	String friends[] = { "lisa", "bily", "kessy" };
	try {
	for (int i = 0; i < 5; i++) {
	System.out.println(friends[i]);
	}
	} catch (ArrayIndexOutOfBoundsException e) {
	System.out.println("index err");
	}
	System.out.println("\nthis is the end");
	}
	}

举例 2：

	public class DivideZero1 {
	int x;
	public static void main(String[] args) {
	int y;
	DivideZero1 c = new DivideZero1();
	try {
	y = 3 / c.x;
	} catch (ArithmeticException e) {
	System.out.println("divide by zero error!");
	}
	System.out.println("program ends ok!");
	}
	}

举例 3：

	@Test
	public void test1(){
	try{
	String str1 = "atguigu.com";
	str1 = null;
	System.out.println(str1.charAt(0));
	}catch(NullPointerException e){
	// 异常的处理方式 1
	System.out.println("不好意思，亲~出现了小问题，正在加紧解决...");
	}catch(ClassCastException e){
	// 异常的处理方式 2
	System.out.println("出现了类型转换的异常");
	}catch(RuntimeException e){
	// 异常的处理方式 3
	System.out.println("出现了运行时异常");
	}
	// 此处的代码，在异常被处理了以后，是可以正常执行的
	System.out.println("hello");
	}

# 4.2.3 finally 使用及举例

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

举例 1：确保资源关闭

	package com.atguigu.keyword;

	import java.util.InputMismatchException;
	import java.util.Scanner;

	public class TestFinally {
	public static void main(String[] args) {
	Scanner input = new Scanner(System.in);
	try {
	System.out.print("请输入第一个整数：");
	int a = input.nextInt();
	System.out.print("请输入第二个整数：");
	int b = input.nextInt();
	int result = a/b;
	System.out.println(a + "/" + b +"=" + result);
	} catch (InputMismatchException e) {
	System.out.println("数字格式不正确，请输入两个整数");
	}catch (ArithmeticException e){
	System.out.println("第二个整数不能为0");
	} finally {
	System.out.println("程序结束，释放资源");
	input.close();
	}
	}

	@Test
	public void test1(){
	FileInputStream fis = null;
	try{
	File file = new File("hello1.txt");
	fis = new FileInputStream(file);//FileNotFoundException
	int b = fis.read();//IOException
	while(b != -1){
	System.out.print((char)b);
	b = fis.read();//IOException
	}

	}catch(IOException e){
	e.printStackTrace();
	}finally{
	try {
	if(fis != null)
	fis.close();//IOException
	} catch (IOException e) {
	e.printStackTrace();
	}
	}
	}
	}

举例 2：从 try 回来

	public class FinallyTest1 {
	public static void main(String[] args) {
	int result = test("12");
	System.out.println(result);
	}

	public static int test(String str){
	try{
	Integer.parseInt(str);
	return 1;
	}catch(NumberFormatException e){
	return -1;
	}finally{
	System.out.println("test结束");
	}
	}
	}

举例 3：从 catch 回来

	public class FinallyTest2 {
	public static void main(String[] args) {
	int result = test("a");
	System.out.println(result);
	}

	public static int test(String str) {
	try {
	Integer.parseInt(str);
	return 1;
	} catch (NumberFormatException e) {
	return -1;
	} finally {
	System.out.println("test结束");
	}
	}
	}

举例 4：从 finally 回来

	public class FinallyTest3 {
	public static void main(String[] args) {
	int result = test("a");
	System.out.println(result);
	}

	public static int test(String str) {
	try {
	Integer.parseInt(str);
	return 1;
	} catch (NumberFormatException e) {
	return -1;
	} finally {
	System.out.println("test结束");
	return 0;
	}
	}
	}

笔试题：

	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++;
	}
	}
	}

笔试题：final、finally、finalize 有什么区别？

final 关键字：可以用于修饰变量、方法和类，作用是使它们具有不可变性、不可修改性和不可扩展性。
- 如果一个变量被声明为 final 类型，则该变量的值不能被修改。
- 如果一个方法被声明为 final 类型，则该方法不能被子类重写。
- 如果一个类被声明为 final 类型，则该类不能被继承。
finally 关键字：用于定义在 try-catch 语句块中的一个代码块，无论异常是否发生，该代码块都会被执行。finally 块通常用于释放资源、关闭连接、清理内存等操作。在 Java 中，finally 块与 try 和 catch 块一起使用，组成 try-catch-finally 语句块，用于处理异常情况。

finalize：是 Object 类中的一个方法，用于在 Java 垃圾回收器回收一个对象之前调用，用于释放该对象所占用的资源。finalize 方法是 Java 中的一种兜底机制，当程序员没有手动释放资源时，Java 虚拟机会在垃圾回收时调用该方法。

public class FinalizeExample {
    public static void main(String[] args) {
        MyObject obj = new MyObject();
        obj = null; // 将对象置为 null，使其成为垃圾对象
        System.gc(); // 请求垃圾回收
    }
    static class MyObject {
        @Override
        protected void finalize() throws Throwable {
            System.out.println("对象被销毁了！");
        }
    }
}
在上述示例中，我们创建了一个 MyObject 对象，然后将其置为 null，使其成为垃圾对象。然后使用 System.gc () 请求垃圾回收，此时 Java 虚拟机会在垃圾回收过程中调用 MyObject 类中的 finalize 方法，输出 "对象被销毁了！"。
需要注意的是，不应该在程序中过多地使用 finalize 方法，因为 finalize 方法的调用时机和频率是不确定的，可能会对程序性能造成影响。同时，我们应该尽量手动释放资源，避免出现资源泄露等问题。

# 4.2.4 练习

编写一个类 ExceptionTest，在 main 方法中使用 try、catch、finally，要求：

在 try 块中，编写被零除的代码。
在 catch 块中，捕获被零除所产生的异常，并且打印异常信息
在 finally 块中，打印一条语句。

# 4.2.5 异常处理的体会

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

# 4.3 方式 2：声明抛出异常类型（throws）

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

# 4.3.1 throws 基本格式

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }

在 throws 后面可以写多个异常类型，用逗号隔开。

举例：

	public void readFile(String file) throws FileNotFoundException,IOException {
	...
	// 读文件的操作可能产生 FileNotFoundException 或 IOException 类型的异常
	FileInputStream fis = new FileInputStream(file);
	//...
	}

# 4.3.2 throws 使用举例

举例：针对于编译时异常

	package com.atguigu.keyword;

	public class TestThrowsCheckedException {
	public static void main(String[] args) {
	System.out.println("上课.....");
	try {
	afterClass();// 换到这里处理异常
	} catch (InterruptedException e) {
	e.printStackTrace();
	System.out.println("准备提前上课");
	}
	System.out.println("上课.....");
	}

	public static void afterClass() throws InterruptedException {
	for(int i=10; i>=1; i--){
	Thread.sleep(1000);// 本来应该在这里处理异常
	System.out.println("距离上课还有：" + i + "分钟");
	}
	}
	}

举例：针对于运行时异常：

throws 后面也可以写运行时异常类型，只是运行时异常类型，写或不写对于编译器和程序执行来说都没有任何区别。如果写了，唯一的区别就是调用者调用该方法后，使用 try...catch 结构时，IDEA 可以获得更多的信息，需要添加哪种 catch 分支。

	package com.atguigu.keyword;

	import java.util.InputMismatchException;
	import java.util.Scanner;

	public class TestThrowsRuntimeException {
	public static void main(String[] args) {
	Scanner input = new Scanner(System.in);
	try {
	System.out.print("请输入第一个整数：");
	int a = input.nextInt();
	System.out.print("请输入第二个整数：");
	int b = input.nextInt();
	int result = divide(a,b);
	System.out.println(a + "/" + b +"=" + result);
	} catch (ArithmeticException \| InputMismatchException e) {
	e.printStackTrace();
	} finally {
	input.close();
	}
	}

	public static int divide(int a, int b)throws ArithmeticException{
	return a/b;
	}
	}

# 4.3.3 方法重写中 throws 的要求

方法重写时，对于方法签名是有严格要求的。复习：

（1）方法名必须相同
（2）形参列表必须相同
（3）返回值类型
	- 基本数据类型和void：必须相同
	- 引用数据类型：<=
（4）权限修饰符：>=，而且要求父类被重写方法在子类中是可见的
（5）不能是static，final修饰的方法

此外，对于 throws 异常列表要求：

如果父类被重写方法的方法签名后面没有 “throws 编译时异常类型”，那么重写方法时，方法签名后面也不能出现 “throws 编译时异常类型”。
如果父类被重写方法的方法签名后面有 “ throws 编译时异常类型 ”，那么重写方法时，throws 的编译时异常类型必须 <= 被重写方法 throws 的编译时异常类型，或者不 throws 编译时异常。
方法重写，对于 “ throws 运行时异常类型 ” 没有要求。

	package com.atguigu.keyword;

	import java.io.IOException;

	class Father{
	public void method()throws Exception{
	System.out.println("Father.method");
	}
	}
	class Son extends Father{
	@Override
	public void method() throws IOException,ClassCastException {
	System.out.println("Son.method");
	}
	}

# 4.4 两种异常处理方式的选择

前提：对于异常，使用相应的处理方式。此时的异常，主要指的是编译时异常。

如果程序代码中，涉及到资源的调用（流、数据库连接、网络连接等），则必须考虑使用 try-catch-finally 来处理，保证不出现内存泄漏。
如果父类被重写的方法没有 throws 异常类型，则子类重写的方法中如果出现异常，只能考虑使用 try-catch-finally 进行处理，不能 throws。
开发中，方法 a 中依次调用了方法 b,c,d 等方法，方法 b,c,d 之间是递进关系。此时，如果方法 b,c,d 中有异常，我们通常选择使用 throws，而方法 a 中通常选择使用 try-catch-finally。

# 5. 手动抛出异常对象：throw

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

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

# 5.1 使用格式

throw new 异常类名(参数);

throw 语句抛出的异常对象，和 JVM 自动创建和抛出的异常对象一样。

如果是编译时异常类型的对象，同样需要使用 throws 或者 try...catch 处理，否则编译不通过。
如果是运行时异常类型的对象，编译器不提示。
可以抛出的异常必须是 Throwable 或其子类的实例。下面的语句在编译时将会产生语法错误：
throw new String("want to throw");

# 5.2 使用注意点：

无论是编译时异常类型的对象，还是运行时异常类型的对象，如果没有被 try..catch 合理的处理，都会导致程序崩溃。

throw 语句会导致程序执行流程被改变，throw 语句是明确抛出一个异常对象，因此它 下面的代码将不会执行 。

如果当前方法没有 try...catch 处理这个异常对象，throw 语句就会 代替return语句 提前终止当前方法的执行，并返回一个异常对象给调用者。

	package com.atguigu.keyword;

	public class TestThrow {
	public static void main(String[] args) {
	try {
	System.out.println(max(4,2,31,1));
	} catch (Exception e) {
	e.printStackTrace();
	}
	try {
	System.out.println(max(4));
	} catch (Exception e) {
	e.printStackTrace();
	}
	try {
	System.out.println(max());
	} catch (Exception e) {
	e.printStackTrace();
	}
	}

	public static int max(int... nums){
	if(nums == null \|\| nums.length==0){
	throw new IllegalArgumentException("没有传入任何整数，无法获取最大值");
	}
	int max = nums[0];
	for (int i = 1; i < nums.length; i++) {
	if(nums[i] > max){
	max = nums[i];
	}
	}
	return max;
	}
	}

# 6. 自定义异常

# 6.1 为什么需要自定义异常类

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

# 6.2 如何自定义异常类

（1）要继承一个异常类型

自定义一个编译时异常类型：自定义类继承 java.lang.Exception 。

自定义一个运行时异常类型：自定义类继承 java.lang.RuntimeException 。

（2）建议大家提供至少两个构造器

无参构造
构造器 (String message)

（3）自定义异常需要提供 serialVersionUID

# 6.3 注意点

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

# 6.4 举例

举例 1：

	class MyException extends Exception {
	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：

	package com.atguigu.define;
	// 自定义异常：
	public class NotTriangleException extends Exception{
	static final long serialVersionUID = 13465653435L;

	public NotTriangleException() {
	}

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

	package com.atguigu.define;

	public class Triangle {
	private double a;
	private double b;
	private double c;

	public Triangle(double a, double b, double c) throws NotTriangleException {
	if(a<=0 \|\| b<=0 \|\| c<=0){
	throw new NotTriangleException("三角形的边长必须是正数");
	}
	if(a+b<=c \|\| b+c<=a \|\| a+c<=b){
	throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
	}
	this.a = a;
	this.b = b;
	this.c = c;
	}

	public double getA() {
	return a;
	}

	public void setA(double a) throws NotTriangleException{
	if(a<=0){
	throw new NotTriangleException("三角形的边长必须是正数");
	}
	if(a+b<=c \|\| b+c<=a \|\| a+c<=b){
	throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
	}
	this.a = a;
	}

	public double getB() {
	return b;
	}

	public void setB(double b) throws NotTriangleException {
	if(b<=0){
	throw new NotTriangleException("三角形的边长必须是正数");
	}
	if(a+b<=c \|\| b+c<=a \|\| a+c<=b){
	throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
	}
	this.b = b;
	}

	public double getC() {
	return c;
	}

	public void setC(double c) throws NotTriangleException {
	if(c<=0){
	throw new NotTriangleException("三角形的边长必须是正数");
	}
	if(a+b<=c \|\| b+c<=a \|\| a+c<=b){
	throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
	}
	this.c = c;
	}

	@Override
	public String toString() {
	return "Triangle{" +
	"a=" + a +
	", b=" + b +
	", c=" + c +
	'}';
	}
	}

	package com.atguigu.define;

	public class TestTriangle {
	public static void main(String[] args) {
	Triangle t = null;
	try {
	t = new Triangle(2,2,3);
	System.out.println("三角形创建成功：");
	System.out.println(t);
	} catch (NotTriangleException e) {
	System.err.println("三角形创建失败");
	e.printStackTrace();
	}

	try {
	if(t != null) {
	t.setA(1);
	}
	System.out.println("三角形边长修改成功");
	} catch (NotTriangleException e) {
	System.out.println("三角形边长修改失败");
	e.printStackTrace();
	}
	}
	}

# 7. 练习

面试题：throw 和 throws 的区别？

throw：用于主动抛出一个异常对象；
throws：用于声明一个方法可能抛出的异常类型，用于告诉方法的调用者可能出现哪些异常；
需要注意的是，当一个方法使用 throws 声明了可能会抛出某些异常时，该方法的调用者必须使用 try-catch 语句或者将该异常向上抛出，否则会编译错误。

练习 1：

	public class ReturnExceptionDemo {
	static void methodA() {
	try {
	System.out.println("进入方法A");
	throw new RuntimeException("制造异常"); // 仍然会进入 finally 代码块
	}finally {
	System.out.println("用A方法的finally");
	}
	}

	static void methodB() {
	try {
	System.out.println("进入方法B");
	return; // 仍然会进入 finally 代码块
	} finally {
	System.out.println("调用B方法的finally");
	}
	}
	public static void main(String[] args) {
	try {
	methodA();
	} catch (Exception e) {
	System.out.println(e.getMessage());
	}
	methodB();
	}
	}

练习 2：

从键盘接收学生成绩，成绩必须在 0~100 之间。

自定义成绩无效异常。

编写方法接收成绩并返回该成绩，如果输入无效，则抛出自定义异常。

练习 3：

编写应用程序 DivisionDemo.java，接收命令行的两个参数，要求不能输入负数，计算两数相除。
对数据类型不一致 (NumberFormatException)、缺少命令行参数 (ArrayIndexOutOfBoundsException、
除 0 (ArithmeticException) 及输入负数 (EcDef 自定义的异常) 进行异常处理。

提示：
(1) 在主类 (DivisionDemo) 中定义异常方法 (ecm) 完成两数相除功能。

(2) 在 main () 方法中使用异常处理语句进行异常处理。

(3) 在程序中，自定义对应输入负数的异常类 (EcDef)。

(4) 运行时接受参数 java EcmDef 20 10 //args [0]=“20” args [1]=“10”

(5) Interger 类的 static 方法 parseInt (String s) 将 s 转换成对应的 int 值。
如：int a=Interger.parseInt (“314”); //a=314;

	public class DivisionDemo {
	public static void main(String[] args) {
	try {
	int m = Integer.parseInt(args[0]); // 可能出现 NumberFormatException，因为数字格式异常是运行时异常，不需要强制处理
	int n = Integer.parseInt(args[1]); // 可能出现 ArrayIndexOutOfBoundsException，因为数组越界异常是运行时异常，不需要强制处理
	int res = divide(m, n);
	System.out.println("res = " + res);
	} catch (BelowZeroException e) { // 只有该异常是受检查异常，需要强制处理。其他都是运行时异常，不需要强制处理
	System.out.println(e.getMessage());
	} catch (NumberFormatException e) {
	System.out.println("数据类型不匹配，请输入整数");
	} catch (ArrayIndexOutOfBoundsException e) {
	System.out.println("数组越界，请输入两个整数");
	} catch (ArithmeticException e) {
	System.out.println("除数不能为0");
	} catch (Exception e) { // 为什么要写这个？因为如果不写这个，那么上面的 catch 语句就不能捕获到 Exception 异常，因为 Exception 是所有异常的父类
	System.out.println("未知异常");
	} finally {
	System.out.println("程序结束");
	}
	}

	public static int divide(int m, int n) throws BelowZeroException { // 声明抛出异常，将异常抛给调用者
	if (m < 0 \|\| n < 0) {
	// 手动抛出异常类的对象
	throw new BelowZeroException("除数或被除数不能为负数");
	}
	return m / n; // 除数不能为 0，因为除数为 0 会自动抛出 ArithmeticException 异常
	}
	}

# 8. 小结与小悟

# 8.1 小结：异常处理 5 个关键字

类比：上游排污，下游治污

# 8.2 感悟

小哲理：

世界上最遥远的 距离 ，是我在 if 里你在 else 里，似乎一直相伴又永远分离；

世界上最痴心的 等待 ，是我当 case 你是 switch ，或许永远都选不上自己；

世界上最真情的 相依 ，是你在 try 我在 catch 。无论你发神马脾气，我都默默承受，静静处理。到那时，再来期待我们的 finally 。

歌词：

try

	public class FinalizeExample {
	public static void main(String[] args) {
	MyObject obj = new MyObject();
	obj = null; // 将对象置为 null，使其成为垃圾对象
	System.gc(); // 请求垃圾回收
	}

	static class MyObject {
	@Override
	protected void finalize() throws Throwable {
	System.out.println("对象被销毁了！");
	}
	}
	}