Java基础编程之异常处理
Java异常类是对于程序中可能出现的错误或者异常的一种处理方式。在设计程序的过程中，对于可能出现的异常错误，比如说用户输入错误，设备错误，磁盘满了或者代码错误等等，通常采用异常处理的方式来进行处理可能的错误。 JAVA的异常处理机制：如果某个方法不能按照正常的途径完成任务，就可以通过另一种路径退出该方法，并处理可能出现的错误。在这种情况下会抛出一个封装了错误信息的对象。 这个方法会立刻退出同时不返回任何值。另外，调用这个方法的其他代码也无法继续执行，异常处理机制会将代码执行交给异常处理器。
（一）Java异常
异常：导致程序中断运行的一种指令流。 在理想的情况下，程序完全按照我们设计的流程来执行，但是很多时候会出现这样或者那样的错误，如文件找不到，磁盘满了或者代码错误等，这些错误会影响程序的正常执行，对于这种情况，就有了异常处理情况，即使程序异常了，它也是按照某种逻辑在执行，只是没有按照我们给它安排的逻辑执行。异常在Java中定义为Throwable类，其结构层次图如下：
由上图可以看出，Thowable有两个重要的子类，一个是Error类，另一个是Expection类，每一个子类下面还有很多小的分类。
Error类指的是Java运行时系统的内部错误或者资源耗尽错误， 这是程序无法处理的错误，表示运行应用程序中较严重问题，对于这类问题，JVM告知用户，并尽力终止程序。
Expection类指的是 程序本身可以处理的异常。主要分为两类，RuntimeException类异常或者其他异常，由程序错误导致的异常称之为RuntimeExpection，比如说：错误的类型转化，数组访问过界，访问空指针等。而程序本身没有错误，像I/O错误这类问题所导致的异常称之为其他异常，比如说试图打开一个不存在的文件或类。
Java 异常类的另一种分类方式是：可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。
可查的异常（checked exceptions）：正确的程序在运行时，出现情理可容的异常，除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。对于此类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
可不查的异常（unchecked exceptions）： 包括RuntimeException及其子类和Error。 编译器不要求强制处理的异常。
（二） 异常处理
在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。
抛出异常：在执行一个方法时，如果发生异常，则这个方法生成代表该异常的一个对象，并停止当前执行路径，并将此异常提交给系统。首先像创建普通的java对象一样，使用new在堆上创建一个异常对象；然后，当前的执行路径被终止，并且从当前环境中弹出对异常对象的引用。此时，异常处理机制接管程序，并开始寻找一个恰当的地方继续执行程序，这个恰当的地方就是异常处理程序或者异常处理器，它的任务是将程序从错误状态中恢复，以使程序要么换一种方式运行，要么继续运行下去。
捕捉异常：当系统捕捉到该异常后，寻求相应的代码来看处理该异常，在方法的调用栈中查找合适·的异常处理器，从生成异常的方法开始回溯，直到找到相应的异常处理代码，并在控制台上打印异常信息，包括异常的信息的堆栈的内容。
Java异常处理涉及到五个关键字，分别是：try、catch、finally、throw、throws。
- 处理方法1 捕捉异常：try－catch-finally语句
try -catch-finally语句是常用的异常处理语句,其结构如下：
try {
code1；
// 可能会发生异常的程序代码
} catch (Type1 id1) {
code2
// 捕获并处理try抛出的异常类型Type1
} catch (Type2 id2) {
code3
// 捕获并处理try抛出的异常类型Type2
} finally {
code4
// 无论是否发生异常，都将执行的语句块
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
其逻辑框图如下：
- try： 制定一段代码，即一次性捕获并处理的范围，用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，（1）程序将跳出try语句块中的其余代码，（2）转而执行catch中的处理器代码，异常就被抛出 。
注：当异常代码执行完成以后，try语句块中尚未执行的语句不会再执行。
一个try语句必须有至少一个catch或finally语句。 - catch用于处理不同类型的异常。捕获顺序为：越是底层的类，越放在下面。常见的方法有：
toString（）：显示异常的类名和产生的原因。
geyMessage( ) : 显示异常的原因。
printstackTrack() :显示异常发生时堆栈的内容。 - finally：不管异常处理与否，必须要执行的代码块。比如说关闭外界的资源。
- 当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
1）在finally语句块中发生了异常。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）关闭CPU。
异常执行图示：
代码示例：
public class TestException
{
public static void main(String args[])
{ int i = 0;
String greetings[] = { " Hello world !", " Hello World !! ", " HELLO WORLD !!!" };
while (i < 4) {
try { // 特别注意循环控制变量i的设计，避免造成无限循环
System.out.println(greetings[i++]);
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组下标越界异常");
} finally
{
System.out.println("--------------------------");
}
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 处理方法2 抛出异常 Throws、Throw 用法
如果遇到无法处理的情况，Java便会抛出一个异常，即告诉编译器需要返回什么值，以及可能出现哪些错误。
public void test() throws FileNotFoundException {
method();
}
public void method() throws FileNotFoundException {
//一个会抛出异常的方法
method2();
}
//这里 方法后是throws
public void method2() throws FileNotFoundException {
//这里是throw
throw new FileNotFoundException();
}
- Throw总是出现在函数体中， 表示手动抛出一个异常，抛出异常的时候，直接在 Throw 后面添加异常的实例即可。 用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。
public class Test {
public static void main(String[] args) {
try {
throw new TestException20180809("自定义异常：天王盖地虎");
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- Throws 声明过的方法表示此方法不处理异常，找到一个合适的异常类，创建这个类的对象，并将对象抛出。
import java.lang.Exception;
public class TestException {
static void pop() throws NegativeArraySizeException {
// 定义方法并抛出NegativeArraySizeException异常
int[] arr = new int[-3]; // 创建数组
}
public static void main(String[] args) { // 主方法
try { // try语句处理异常信息
pop(); // 调用pop()方法
} catch (NegativeArraySizeException e) {
System.out.println("pop()方法抛出的异常");// 输出异常信息
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 自定义异常类：在程序中，如果标准异常类并不能够充分的描述问题，则需要自己来定义一个异常类来解决问题，只需继承 Exception 即可。可以通过以下步骤定义异常类（1）创建自定义异常类。（2）在方法中通过throw关键字抛出异常对象。（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。（4）在出现异常方法的调用者中捕获并处理异常。
import java.lang.Exception;
public class TestException {
static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
if (y < 0) { // 判断参数是否小于0
throw new MyException("除数不能是负数"); // 异常信息
}
return x/y; // 返回值
}
public static void main(String args[]) { // 主方法
int a =3;
int b =0;
try { // try语句包含可能发生异常的语句
int result = quotient(a, b); // 调用方法quotient()
} catch (MyException e) { // 处理自定义异常
System.out.println(e.getMessage()); // 输出异常信息
} catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
} catch (Exception e) { // 处理其他异常
System.out.println("程序发生了其他的异常"); // 输出提示信息
}
}
}
class MyException extends Exception { // **创建自定义异常类**
String message; // 定义String类型变量
public MyException(String ErrorMessagr) { // 父类方法
message = ErrorMessagr;
}
public String getMessage() { // 覆盖getMessage()方法
return message;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
（三）Java常见异常
五种常见的运行时异常：
ClassCastException(类转换异常)
IndexOutOfBoundsException(数组越界)
NullPointerException(空指针)
ArrayStoreException(数据存储异常，操作数组时类型不一致)
IO操作的BufferOverflowException异常
非运行时异常必须得捕获，否则编译不过去，java编译器要求程序员必须对这种异常进行catch,Java认为Checked异常都是可以被处理（修复）的异常，所以Java程序必须显式处理Checked异常。常见的非运行异常有io异常和sql异常。
IOException、FileNotFoundExcetion 和SQLException
（四）当异常遇到return
在一个方法中，无论 Try 块中有没有异常、Return，只要 Finally 块中有 Return，那么函数的返回值都由 Finally 块提供。
Java异常总结：（1）一个图：异常类型图。（2）五个关键字，try， catch finally throws throw
（3）继承关系：先大后小，（4）异常和重写：子类重写异常范围不能超出父类。
实例说明：
public class TestException {
public TestException() {
}
boolean testEx() throws Exception {
boolean ret = true;
try {
ret = testEx1();
} catch (Exception e) {
System.out.println("testEx, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx, finally; return value=" + ret);
return ret;
}
}
boolean testEx1() throws Exception {
boolean ret = true;
try {
ret = testEx2();
if (!ret) {
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
} catch (Exception e) {
System.out.println("testEx1, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx1, finally; return value=" + ret);
return ret;
}
}
boolean testEx2() throws Exception {
boolean ret = true;
try {
int b = 12;
int c;
for (int i = 2; i >= -2; i--) {
c = b / i;
System.out.println("i=" + i);
}
return true;
} catch (Exception e) {
System.out.println("testEx2, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx2, finally; return value=" + ret);
return ret;
}
}
public static void main(String[] args) {
TestException testException1 = new TestException();
try {
testException1.testEx();
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
运行结果：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false
常见的异常·：
JAVA异常知识结构
