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异常知识结构