异常处理

在程序运行的过程中，也会发生各种非正常状况，例如，程序运行时磁盘空间不足、网络连接中断、被装载的类不存在等。针对这些情况， Java语言引入了异常，以异常类的形式对这些非正常情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理。

下面通过一个案例认识一下什么是异常

public class Test {
	public static void main(String[] args) {
		int result=divide(4,0);
		System.out.println(result);
	}
	
	public static int divide(int x,int y) {
		return x/y;
	}
}

运行结果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.ccccc.Test.divide(Test.java:10)
	at com.ccccc.Test.main(Test.java:5)

可以看出，程序发生了算术异常(ArithmeticException),调用divide()方法时传入了参数0，运算时出现了被0除的情况。异常发生后，程序会立即结束，无法继续向下执行。

Throwable类的继承体系

Java把所有的非正常情况分成两种：异常（Exception）和错误（Error），它们都继承Throwable父类。

1. Error错误

Error错误，一般是指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败等，这种错误无法恢复或不可能捕获，将导致应用程序中断。通常应用程序无法处理这些错误，因此应用程序不应该试图使用catch块来捕获Error对象。在定义该方法时，也无须在其throws子句中声明该方法可能抛出Error及其任何子类。

2.Exception异常
Exception分为两大类：

 1.编译时异常

在Exception类中,除了RuntimeException类及其子类外, Exception的其他子类都是编译时异常。编译异常的特点是Java编译器会对异常进行检查，如果出现异常就必须对异常进行处理，否则程序无法通过编详有两种方式处理编译时期的异常，具体如下。

(1)使用try... catch语句对异常进行捕获处理。

(2)使用throws关键字声明抛出异常，调用者对异常进行处理。

2.运行时异常

RuntimeException类及其子类都是运行时异常。运行时异常的特点是Java编译器不会对异常进行检查。也就是说，当程序中出现这类异常时，即使没有使用try. catch语句捕获或使用throws关键字声明抛出，被序也能编译通过。运行时异常一般是由程序中的逻辑错误引起的，在程序运行时无法恢复。例如，通过数组的角标访问数组的元素时，如果角标超过了数组范围，就会发生运行时异常，代码如下：

int[]  arr=new  int[5];

System. out. println(arr[6]);

在上面的代码中，由于数组arr的length为5，最大角标应为4，当使用an[6]访问数组中的元素时就会发生数组角标越界的异常。

 常用方法

方法声明	功能描述
String getMessage()	返回异常的消息字符串
String toString()	返回异常的简单信息描述
void printStackTrace()	获取异常类名和异常信息，以及异常出现在程序中的位置，把信息输出在控制台

 

 

 try…catch和finally

由于发生了异常导致程序立即终止，因此程序无法继续向下执行。为了解决异常， Java提供了对异常进行处理的方式——异常捕获。异常捕获使用try... catch语句实现， try... catch具体语法格式如下：

try{
//程序代码块
}catch(ExceptionType(Exception类及其子类)e)   {
//对ExceptionType的处理
}

在try代码块中编写可能发生异常的Java语句，在catch代码块中编写针对异常进行处理的代码。当try代码块中的程序发生了异常，系统会将异常的信息封装成一个异常对象，并将这个对象传递给catch代码块进行处理。catch代码块需要一个参数指明它所能接收的异常类型，这个参数的类型必须是Exception类或其子类。

public class Test {
	public static void main(String[] args) {
		try {
			int result=divide(4,0);
            System.out.println("我没有执行");
		    System.out.println(result);
		}catch(Exception e) {
			System. out. println("捕获的异常信息为:"+e.getMessage());
		}
		System.out.println("程序继续向下执行…");
	}
	
	public static int divide(int x,int y) {
		return x/y;
	}
}

运行结果：

捕获的异常信息为:/ by zero
程序继续向下执行…

在try代码块中发生除0异常时，程序会通过catch语句捕获异常，在catch语句中通过调用Exception对象的getMessage()方法,返回异常信息“/by zero”。catch代码块对异常处理完毕,程序仍会向下执行,而不会终止程序。

在try代码块中，发生异常语句后面的代码是不会被执行的，如  System.out.println("我没有执行");打印语句就没有执行。

有时候会希望有些语句无论程序是否发生异常都要执行，这时就可以在try.. catch语句后加一个finally代码块。 

public class Test {
	public static void main(String[] args) {
		try {
			int result=divide(4,0);
			System.out.println("我没有执行");
			System.out.println(result);
		}catch(Exception e) {
			System. out. println("捕获的异常信息为:"+e.getMessage());
            return; 
		}finally {
			System.out.println("进入finally代码块");
		}
		System.out.println("程序继续向下执行…");
	}
	
	public static int divide(int x,int y) {
		return x/y;
	}
}

运行结果：

捕获的异常信息为:/ by zero
进入finally代码块

在catch代码块中增加了一个return语句，用于结束当前方法，这样finally后的代码就不会执行了，而finally代码块中的代码仍会执行，不受return语句的影响。也就是说，不论程序是发生异常，还是使用return语句结束， finally中的语句都会执行。因此，在程序设计时，通常会使用finally 代码块处理完成必须做的事情，例如释放系统资源。

finally中的代码块在一种情况下是不会执行的,那就是在try. catch中执行了System. exit(0)语句。System. exit(0)表示退出当前的Java虚拟机， Java虚拟机停止了，任何代码都不能再执行了。

 

throws关键字 

 由于调用的是自己编写的divide()方法，因此很清楚该方法可能发生的异常。但是在实际开发中，大部分情况下会调用别人编写的方法，并不知道别人编写的方法是否会发生异常。Java允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常，这样调用者在调用方法时，就明确地知道该方法是否有异常，并且必须在程序中对异常进行处理，否则编译无法通过。

throws关键字声明抛出异常的语法格式如下：

修饰符 返回值类型 方法名(参数1，参数2⋯⋯) throws 异常类1，异常类2⋯⋯{
    //方法体   ･･････
}

throws关键字需要写在方法声明的后面， throws后面需要声明方法中发生异常的类型。

public class Test {
	public static void main(String[] args) {
			int result=divide(4,2);
			System.out.println(result);
	}
	public static int divide (int x,int y) throws Exception{
		return x/y;
	}
}

运行结果：

Exception in thread "main" java.lang.Error: 无法解析的编译问题：
	未处理的异常类型 Exception

	at com.ccccc.Test.main(Test.java:5)

调用divide()方法时传入的第二个参数为2，程序在运行时不会发生被0除的异常，但是由于定义divide()方法时声明了抛出异常，调用者在调用divide()方法时就必须进行处理，否则就会发生编译错误。

public class Test {
	public static void main(String[] args) {
		try {
			int result=divide(4,2);
			System.out.println(result);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	public static int divide (int x,int y) throws Exception{
		return x/y;
	}
}

运行结果:2

由于使用了try... catch对divide()方法进行了异常处理，因此程序可以编译通过，运行后正确打印出了运行结果“2”。

在调用divide()方法时，如果不知道如何处理声明抛出的异常，也可以使用throws关键字继续将异常抛出，这样程序也能编译通过。需要注意的是，程序一旦发生异常，并且异常没有被处理，程序就会非正常终止。

public class Test {
	public static void main(String[] args)throws Exception {
			int result=divide(4,0);
			System.out.println(result);
	}
	public static int divide (int x,int y) throws Exception{
		return x/y;
	}
}

在main()方法中继续使用throws关键字将Exception抛出，程序虽然可以通过编译，在运行时期由于没有对“/by zero”的异常进行处理，最终导致程序终止运行。

自定义异常

一般地，用户自定义异常类都是RuntimeException的子类。
自定义异常类通常需要编写几个重载的构造器。
自定义异常需要提供全局常量：serialVersionUID
自定义的异常通过throw抛出。
自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。

用户自定义异常类MyException，用于描述数据取值范围错误信息。用户自己的异常类必须继承现有的异常类。

public class MyException extends RuntimeException{
	static final long serialVersionUID=1215646L;
	public MyException() {
		// TODO 自动生成的构造函数存根
	}
	public MyException(String message, Throwable cause) {
		super(message, cause);
		// TODO 自动生成的构造函数存根
	}
	public MyException(String message) {
		super(message);
		// TODO 自动生成的构造函数存根
	}
	public MyException(Throwable cause) {
		super(cause);
		// TODO 自动生成的构造函数存根
	}
	public MyException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}
}

运行异常的特点

一般来说，我们在方法体内出现异常，我们用throw 关键字 将 异常对象或 异常对象的引用抛出，如果当前方法无法处理异常，那么必须在方法的参数列表后方法体前 必须 用 throws 声明异常所属类，交给调用者去处理。但是RuntimeException是非常特殊的子类，你可以不用throw和throws，哪怕你throw了，也没必要throws，即使你throws了，调用者也没必要try-catch

1> 如果在函数内容中抛出该类异常或其子类异常，函数上可以不用声明，编译一样通过

2> 如果在函数上声明该异常，调用者可以不同处理(try-catch)，编译一样通过 

对divide()方法进行改写，在divide()方法中判断被除数是否为负数，如果为负数,就使用throw关键字在方法中向调用者抛出自定义的MyException异常对象。

public class Test {
	public static void main(String[] args){
			int result=divide(4,-2);
			System.out.println(result);
	}
	public static int divide (int x,int y) {
		if(y<0)
			throw new MyException("除数是负数");
		return x/y;
	}
}

运行结果：

Exception in thread "main" com.ccccc.MyException: 除数是负数
	at com.ccccc.Test.divide(Test.java:10)
	at com.ccccc.Test.main(Test.java:5)