Java 异常处理

Java异常处理

异常就是程序执行过程中出现的不正常现象。
任何一个程序都可能出现异常，Java使用对象表示对打开的文件不存在、内存不够、数组访问超界等非预期情况。
Java使异常处理标准化，使程序设计思路更清楚，理解更容易。

Java异常的类型

Error ：产生了非常严重的问题，即使可能使程序恢复正常也非常困难，如内存不足等。对于这一类问题，一般不要求应用程序进行异常处理。
RuntimeException：表明产生了设计或执行的问题，如果程序设计正确应该能够避免发生这类问题，如在访问数组时，数组下标越界等。对于这类问题也不要求处理，使该类问题能够暴露出来，从而改正程序。
其它Exception : 由于执行环境的影响，不可避免地将产生的问题。如用 户敲入错误的文件名而导致文件没有找到等。对于这类问题，Java强烈要求应用程序进行完整的异常处理，给用户友好的提示，或者修正后使程序继续执行

Java异常类的层次

Java定义的异常类有分类层次。所有异常类都是Throwable类的子类。
Throwable属于java.lang包，在程序中不必使用import语句引入。
Throwable类有三个最基本子类Error, Exception和RuntimeException类。

Throwable类常用方法

getMessage()：
获得更详细的异常信息，但并非每个异常都有详细信息。 如果没有详细信息，该方法调用后返回空值。
toString()：
获得异常的简短描述。
printStackTrace()：
打印异常发生处堆栈跟踪的信息，包括异常的类名、方法 名及所在程序的行数

异常处理

发生异常时，就会抛出一个异常，通过捕获这个异常，就可以进行相
应异常处理。其形式如下：
try {
正常程序段;
}
catch(异常类1 异常变量) {
与异常类1有关的处理程序段;
}
catch(异常类2 异常变量) {
与异常类2有关的处理程序段;
}…
finally {
退出异常处理程序段;
}（与是否抛出异常无关）

嵌套的异常处理

在try-catch-finally结构中，可以使用嵌套形式，即在捕获异常处理过程中，可以继续抛出异常。
在这种嵌套结构中，产生异常后，首先与最内层的try-catch-finally结构中的catch语句进行匹配比较。
如果没有相匹配的catch语句，该异常情况可以被抛出，让外层的try-catch-finlly的结构重复进行匹配检查。这样从最内层到最外层，逐一检查匹配，直到找到一个匹配为止。

package Test;

public class TryException {
	public TryException(){
		for(int i=0;i<2;i++) {
			int k;
			try {
				System.out.println("\nOuter try block;Test Case#"+i);
				try {
					System.out.println("\tInner try block");
					switch(i) {
					case 0:
						int zero=0;
						k=8/zero;
						break;
					case 1:
						int[] c=new int[3];
						k=c[5];
						break;
					}
				}catch(ArithmeticException e) {
					System.out.println("\tInner>"+e);
				}
				catch(IndexOutOfBoundsException e) {
					System.out.println("Inner>"+e);
					throw e;
				}
				finally {
					System.out.println("Inner finally block");
				}
			}catch(ArrayIndexOutOfBoundsException e) {
				System.out.println("Outer>"+e);
			}
			finally{
				System.out.println("Outer finakky block");
			}
		}
	}
	public static void main(String[] args) {
		new TryException();
	}
}

t

throw语句

在实际的应用程序中，除了可能产生Java的标准异常外，还可能产生应用程序的特定异常，这时应用程序应该给用户提供明确的指示，帮助用户正确理解和使用该应用程序。
throw语句抛出异常格式为：
throw 表达式;
其中，“表达式” 为一个异常对象。 例： throw new IOException(“Not found the file”);

throws语句

抛出异常的方法并不处理该异常，而是由调用该方法的另一方法来处理，那么这时可以使用throws语句给方法声明一个例外情况，其声明格式为：
<返回类型> <方法名>(paraList) throws 异常类1,…
例： void exam(int mark) throws NegativeMarkException, OutofMarkException
{
if(mark < 0) throw new NegativeMarkException();
if(mark> 100) throw new OutofMarkException();
}

package Test;

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()方法抛出的异常");//输出异常信息
		}
	}
}

throw与throws的对比

throw语句用在方法体内，表示抛出异常，由方法体内的语句处理。
throws语句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。

throws主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。
throw是具体向外抛异常的动作，所以它是抛出一个异常实例。

throws说明你有那个可能，倾向。
throw的话，那就是你把那个倾向变成真实的了。

同时：
1、throws出现在方法函数头；而throw出现在函数体。
2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常。
3、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

自定义异常类

用户可以根据需要定义异常类。则要完成三件事:
① 生成Throwable类或其子类的一个子类。
② 在可能发生异常的地方，判断是否发生异常，如果发生异常， 则用throw抛出异常。
③ 用try-catch-finally结构来捕获异常，进行处理。
例，自定义异常类IllegalMarkException:
class IllegelMarkException extends Throwable{
IllegelMarkException() {}
}

package Test;

public class NotTriangleException extends Exception{
	public NotTriangleException(String msg) {
		super(msg);
	}
}

package Test;

public class Triangle {
	private double x;
	private double y;
	private double z;

	
	public Triangle(double x,double y,double z)throws NotTriangleException{
		if((x+y)<=z||(y+z)<=x||(z+x)<=y) {
			throw new NotTriangleException("不能构成三角形。");
		}
		else {
			this.x=x;
			this.y=y;
			this.z=z;
		}
	}
	
	public void outPut() {
		System.out.println("三角形三条边为：x="+this.x+",y="+this.y+",z="+this.z);
	}
	
	public void getArea() {
		double p=(this.x+this.y+this.z)/2;
		System.out.println("三角形的面积为："+String.format("%.3f",Math.sqrt(p*(p-x)*(p-y)*(p-z))));
	}
	
	public static void main(String[] args) {
		try {
			Triangle sj2=new Triangle(2.0,3.0,3.0);
			sj2.outPut();
			sj2.getArea();
		}catch(NotTriangleException e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}
	}
}

注：对于throw和throws的补充理解，之所以在有try–catch语句后还要有throw和throws语句，是为了能够在大的工程问题中将异常集中处理，从而减少了try–catch的代码量，使代码更易读。