JAVA——从基础学起（十）异常处理

10 异常处理

10.1 异常概述

在程序中，错误可能产生于程序员没有预料到的各种情况等。在Java中这种在程序运行时可能出现的错误称为异常。异常是一个在程序执行期间发生的事件，他中断了正在执行的程序的正常指令流。
如：

package com.mw;

public class Baulk {
	public static void main(String[] args) {
		int result = 3/0;
		System.out.println(result);
	}
}

由于result定义为3除以0的结果，因此会出现异常：

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.mw.Baulk.main(Baulk.java:5)

根据给出的错误提示ArithmeticException得知是发生了算术异常，系统不再执行下去，提前结束。还有很多中异常的情况如空指针，数组溢出等情况。
由于Java是面向对象的语言，因此异常在Java中也是作为类的实例出现的。当某一个方法中发生错误时，这个方法会创建一个对象并且传递给正在运行的程序。这个对象就是异常对象，通过异常处理机制可以将非正常情况下的处理代码与程序的主逻辑分离，即在编写代码主流程的同时在其他地方处理异常。

10.2 处理程序异常错误

为了保证程序有效地执行，需要对发生的异常进行相应的处理。在Java中，如果某个方法抛出异常，既可以在当前方法中进行捕捉，然后处理该异常；也可以将异常向上抛出，由方法调用者来处理。本节中将介绍Java中捕获异常的方法。

10.2.1 错误

异常产生后，如果不做任何处理，程序就会被终止。如将一个字符串转换成整型，可以使用Integer类中的parseInt方法来实现。但是如果字符串不是数值型字符串，praseInt()方法就会抛出异常，程序就会在出现异常的位置终止，不再执行下面的语句。

public class Baulk {
    static String age = "25岁";
	public static void main(String[] args) {
		System.out.println("年龄为：" + Integer.parseInt(age));
	}
}

如上述语句使用时将会抛出异常：

Exception in thread "main" java.lang.NumberFormatException: For input string: "25岁"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:68)
	at java.base/java.lang.Integer.parseInt(Integer.java:652)
	at java.base/java.lang.Integer.parseInt(Integer.java:770)
	at com.mw.Baulk.main(Baulk.java:6)

10.2.2 捕捉异常

Java语言的异常捕获结构有由try，catch和finally三部分组成。其中try语句块中存放的是可能出现异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。
语法如下：

 try {
	   //程序代码块
   }
   catch(Exceptiontype1 e) {
	   //对Exceptiontype1的处理
   }
   catch(Exceptiontype2 e) {
	   //对Exceptiontype2的处理
   }
   ...
   finally {
	   //程序块
   }

通过异常处理器的语法得知，异常处理器大致分为try-catch语句块和finally语句块

1. try-catch语句块
   我们使用以下代码来做介绍：

public class Take { //创建类
	public static void main(String[] args) {
		try {                                          //try语句中包含可能出现异常的程序代码
			String string1 = "Lill";                   //定义字符串变量
			System.out.println(string1 + "年龄是：");     //输出的信息
			int age = Integer.parseInt("20L");         //数据类型转换
			System.out.println(age);                   
		} catch (Exception e) {
			e.printStackTrace();                       //catch语句块用来获取异常信息
		}                                              //输出异常性质
		System.out.println("progrom over");            //输出信息
	}
}

运行结果为：

Lill年龄是：
java.lang.NumberFormatException: For input string: "20L"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:68)
	at java.base/java.lang.Integer.parseInt(Integer.java:652)
	at java.base/java.lang.Integer.parseInt(Integer.java:770)
	at com.mw.Take.main(Take.java:8)
progrom over

这说明程序依然会输出最后的提示信息，并没有因为异常而终止。将可能出现异常的代码使用try-catch语句块处理，当try中的语句发生异常时，程序就会跳转到catch代码块中执行，执行完catch语句块中的代码后，将继续执行catch代码块后的其他代码，而不会执行try中发生异常语句后的代码。由此可知，Java中的异常处理时结构化的，不会因为一个异常影响整个程序的执行。
Excpeption是try代码块传递给catch代码块的变量类型，e是变量名。catch代码块中的e.getMessage语句用于输出错误性质。通常，异常处理常会用以下三个函数获取异常的有关信息：
1. getMessage()函数：输出错误性质；
2. toString()函数：给出异常的类型与性质；
3. peintStackTrace()函数：指出异常的类型、性质、栈层次以及出现在程序中的位置。

2. finally语句块
   完整的异常处理一定要包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句是否顺利执行完毕，都会执行finally语句。
   在以下四种情况下finally语句不会执行：
   （1）在finally语句块中发生了异常
   （2）在前面的代码中使用了System.exit()退出程序
   （3）程序所在的线程死亡
   （4）关闭CPU

10.3 Java常见异常

在Java中提供了一些异常用来描述经常发生的错误，其中，有的需要程序员进行驳货处理或声明抛出，有的是由Java虚拟机自动进行捕获处理的。Java中常见的异常类如下;

异常类	说明
ClassCastException	类型转换异常
ClassNotFoundException	未找到相应类异常
ArithmeticException	算术异常
ArrayIndexOutOfBoundsException	数组下标越界异常
ArrayStoreException	数组中包含不兼容的值抛出的异常
SQLException	操作数据库异常
NullPointerException	空指针异常
NoSuchFieldException	字段未找到异常
NoSUnchMethodException	方法未找到异常
NumberFormatException	字符串转换为数字异常
NegitiveArraySizeException	数组元素个数为负异常
StringIndexOutOfBoundsException	字符串索引超出范围异常
IOException	输入输出异常
IllegalAccessException	不允许访问某类异常
InstantationException	当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出异常
EPFException	文件已结束异常
FileNotFoundException	文件未找异常

10.4 自定义异常

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户只需继承Exception类即可自定义异常类。
在程序中使用自定义异常类，大致可分为以下几个步骤：
（1）创建自定义异常类
（2）在方法中通过throw关键字抛出异常对象
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕捉并处理，否则在方法的声明处通过throws关键字知名要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常

1. 创建自定义异常：

public class MyException extends Exception{   //创建自定义异常
	public MyException(String ErrorMessage){  //构造方法
		super(ErrorMessage);                  //使用父类构造方法
	}
}

字符串ErrorMessage是要输出的错误信息。若想要抛出用户自定义的异常对象，要使用throw关键字：

public class MyException extends Exception{   //创建自定义异常
	public MyException(String ErrorMessage){  //构造方法
		super(ErrorMessage);                  //使用父类构造方法
	}
}

public class Tran {                                        // 创建类
	static int avg(int num1 ,int num2) throws MyException{ // 定义方法，抛出异常
		if (num1 < 0 || num2 <0) {
			throw new MyException("不可以使用负数");
		}
		if (num1 > 100 || num2 > 100) {
			throw new MyException("数值太大了");
		}
		return num1 + num2;
	}
	public static void main(String[] args) {
		try {
			int result = avg(102, 150);
			System.out.println(result);
		} catch (Exception e) {
			System.out.println(e);
		}
	}
}

输出结果为：

com.mw.MyException: 数值太大了

10.5 在方法中抛出异常

若某个方法可能会发生异常，但是不想再当前这个方法中处理，可以使用throws、throw关键字在方法中抛出异常。

10.5.1 使用throws关键字抛出异常

throws关键字通常被应用在声明方法时，来指定方法可能抛出的异常。多个异常可使用逗号分隔：

public class Shoot {              //创建类
	static void pop() throws NegativeArraySizeException{
		//定义方法并抛出NegativeArraySizeException异常
		int[] arr = new int[-3];
	}
	public static void main(String[] args) {
		try {
			pop();
		} catch (NegativeArraySizeException e) {
			System.out.println("pop()方法抛出的异常");
		}
	}
}

运行结果如下：

pop()方法抛出的异常

在使用throws关键字将异常抛给上一级后，如果不想处理该异常，可以继续向上抛出，但最终是要又能够处理该异常的代码。
注意：如果是Error、RuntimeException或他们的子类，可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

10.5.2 使用throw关键字抛出异常

throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中处理异常，需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常；如果要捕捉throw抛出的异常，则必须使用try-catch语句块。
throw通常用于抛出用户自定义异常，下面通过实例介绍：

public class MyException2 extends Exception{   //自定义异常类
	String message;                            //异常信息
	public MyException2(String errorMessage) { //构造方法
		this.message = errorMessage;
	}
	public String getMessage() {                //返回异常信息
		return this.message;
	}
}

public class Captor {
	static int quotient(int x,int y) throws MyException2{
		if (y < 0) {
			throw new MyException2("除数不能是负数");
		}
		return (int) x/y;
	}
	public static void main(String[] args) {
		try {
			int result  = quotient(5,-1);
		} catch (MyException2 e) {
			System.out.println(e.getMessage());
		}catch (ArithmeticException e) {
			System.out.println("除数不能为0");
		}catch (Exceptione) {
			System.out.println("程序发生了其他异常。");
		}
	}
}

上述的代码中使用了多个catch语句来捕捉异常，其中由于Exception类是所有异常类的父类，因此需要放置在catch语句块的最后，否则在其后面的代码块将永远得不到执行。

10.6 运行时异常

RuntimeException异常是程序运行过程中产生的异常。Java类库的每个包中都定义了异常类，所有的这些类都是Throwable类的子类。Throwable类派生出两个子类，分别是Exception和Error类。Error类及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。而Exception类称为非致命性类，可以通过捕捉处理使程序继续执行。根据错误发生的原因Exception类又分为RuntimeException异常和除RuntimeException之外的异常。
RuntimeException异常种类有：

种类	说明
NullPointerException	空指针异常
ArrayIndexOutOfBoundsException	数组下标越界异常
ArithmeticException	算术异常
ArrayStoreException	数组中包含不兼容的值抛出的异常
IllegalArguementException	非法参数异常
SecurityException	安全性异常
NegativeArrayException	数组长度为负异常

10.7 异常的使用规则

Java异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常是，可以遵循以下几条原则：

1. 在当前方法声明中使用try-catch语句捕获异常
2. 一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类
3. 如果父类抛出多个异常，则覆盖方法必须排除那些异常的一个子集，不能抛出新异常