Java中的异常处理

1.认识异常

一个程序在编译时没有出现错误，但是在运行过程中有可能由于各种各样的错误导致程序退出，这些错误就被称为异常。Java中提供了异常处理的机制。

在Java中这些异常其实就是一个类，异常的根类是java.lang.Throwable ,下面介绍一下异常的继承结构：

异常可以分为三种主要类型：系统错误（Error）、异常(Exception)、运行时异常(RuntimeException)

Error:指的是JVM错误，这时的程序没有执行，所以无法处理。
Exception:指的是程序运行过程中产生的异常，用户可以使用异常处理格式处理。
RuntimeException:程序在编译时不会强制性地要求用户处理的异常，如果出现异常将交由JVM默认处理。

2.异常处理流程

异常处理格式：

try{
	//有可能出现异常的语句
}catch(异常类型 对象){
	//异常处理
}fianlly{
	//无论是否出现异常，都执行的内容
}

程序示例：异常处理

import java.util.Scanner;

public class Test6_3 {
	public static void main(String args[]) {
		System.out.println("1.除法计算开始！");
		Scanner input = new Scanner(System.in);
		int x = input.nextInt();
		int y = input.nextInt();
		try {
			System.out.println("2.除法计算："+x/y);
			System.out.println("##########");
		}catch(ArithmeticException e) {
			//System.out.println("第二步出现了异常！");
			e.printStackTrace();
			
		}finally {
			System.out.println("##########不管是否发生异常，都要输出");
		}
		
		System.out.println("3.计算完成。");
		input.close();
	}
}
程序运行结果：
			1.除法计算开始！
			10
			0
			java.lang.ArithmeticException: / by zero
				at unit_6.Test6_3.main(Test6_3.java:14)
			##########不管是否发生异常，都要输出
			3.计算完成。
	

3.声明异常(throws)、抛出异常(throw)

（1）throws关键字

throws关键字在方法的定义上使用，表示此方法不进行异常处理，将异常交给被调用处处理。
程序示例：

class MyMath{
	public static int div(int i,int j) throws Exception{
		return i/j;
	}
}
public class Test{
	public static void main(String[] args){
		//div方法声明了异常，必须进行异常处理
		try{
			System.out.println(MyMath.div(10,2));
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

（2）throw关键字

使用throw关键字手工抛出一个异常类对象。

public class Test{
	public static void main(String[] args){
		try{
			throw new Exception("自己定义的异常。");
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

4.assert关键字 断言操作（了解）

在JDK1.4的时候引入，主要功能是断言。断言是指程序在执行到某行之后，其结果一定是预期的结果。
在默认情况下Java不开启断言，如果需要，则进行手动启用。

• 命令行中：java -ea Test
• Eclipse中：右键单击类找到Run As —> Run configurations-就出现如下界面，配置即可
  

5.自定义异常

Java本身提供了很多种异常，但是在实际开发中这些不够用，需要开发者自定义异常。如果要实现自定义异常只需要继承Exception 或RuntimeException父类即可。

程序示例：自定义异常

@SuppressWarnings("serial")
class AddException extends Exception{

	public AddException(String msg){
		super(msg);
	}
}
public class Test_AddException {
	public static void main(String args[]) {
		int num = 20;
		try {
			if(num>10) {
				throw new AddException("数据传递的过大！");
			}
		}catch(Exception e) {
				e.printStackTrace();
		}
		
	}
}
程序运行结果：
			unit_6.AddException: 数据传递的过大！
				at unit_6.Test_AddException.main(Test_AddException.java:14)

6.链式异常

与另一个异常一起抛出一个新的异常，构成了链式异常。

程序示例：链式异常

/*
 * 链式异常
 */
package unit_12;

public class Program12_9 {
	public static void main(String args[]) {
		try {
			method1();
		}catch(Exception ex) {
			ex.printStackTrace();
		}
	}
	public static void method1() throws Exception{
		try {
			method2();
		}catch(Exception ex) {
			throw new Exception("New unfo from method1",ex);
		}
	}
	public static void method2() throws Exception{
		throw new Exception("New info from method2");
	}
}
程序运行结果：
			java.lang.Exception: New unfo from method1
				at unit_12.Program12_9.method1(Program12_9.java:18)
				at unit_12.Program12_9.main(Program12_9.java:9)
			Caused by: java.lang.Exception: New info from method2
				at unit_12.Program12_9.method2(Program12_9.java:22)
				at unit_12.Program12_9.method1(Program12_9.java:16)
				... 1 more