Java知识总结-异常

说明：异常多多注语句的使用格式就好。

一，异常类体系介绍

1.异常类体系的父类是Throwable类。其中常见方法有：

方法1：getMessage（）：返回异常的详细消息，返回值类型String；

package Test;
class DemoException extends Exception{
	DemoException(String message){
		super(message);
	}
}
class Demo{
	void show(int x)throws DemoException{
		if(x==0)
			throw new DemoException("参数错误，不能为零");
		System.out.println("参数正确");
	}
}
public class Test {
	public static void main(String[] args) {
		Demo d=new Demo();
		try {
			d.show(0);
		} catch (DemoException e) {
			System.out.println(e.getMessage());
		}
	}
}

运行结果：

参数错误，不能为零

方法2：toString（）：返回异常的简短描述。返回值类型String；

public class Test {
	public static void main(String[] args) {
		Demo d=new Demo();
		try {
			d.show(0);
		} catch (DemoException e) {
			System.out.println(e.toString());
		}
	}
}

运行结果：

Test.DemoException: 参数错误，不能为零

访法3：printStackTrace（）：返回异常的全部信息，返回值类型void。

public class Test {
	public static void main(String[] args) {
		Demo d=new Demo();
		try {
			d.show(0);
		} catch (DemoException e) {
			e.printStackTrace();
		}
	}
}

运行结果：

Test.DemoException: 参数错误，不能为零
	at Test.Demo.show(Test.java:10)
	at Test.Test.main(Test.java:18)

以上三个方法都是输出异常的信息，区别在于信息的详细程度不一样。

2.Throwable类有两个子类：Error类，Exception类；

其中Error类用于描述严重问题，这类问题大多程序都不用试图捕获和处理。

Exception类用于描述程序应当捕获并可以进行处理的异常。

这里主要介绍Exception类：

3.自定义异常：

通常自定义异常的格式如下：

class ZiDingYiException extends Exception{  
	ZiDingYiException(String message){ 
		super(message);
	}
}

通过构造函数，我们可以向异常对象传入信息，并通过前面介绍的Throwable类中的三个方法来获取这些信息。
自定义异常后，就是异常的使用了。当一段程序中可能会出现异常时，就需要对程序进行异常捕捉和处理，如果程序对该异常只是抛出并未处理时，就需要在函数进行异常声明。

  例：编写一个方法，功能为打印所传参数的平方数，且要求参数只能是正数，当传入的参数不是正数时，则抛出异常。

class DemoForZiDingYi{ 
	//在方法上声明该方法可能会出现的异常类
	public void method(int x) throws ZiDingYiException{
		if(x<=0)
			//当参数不是正数时，抛出异常对象
			throw new ZiDingYiException("参数不是正数");
		System.out.println("所得结果是="+x*x);
	}
}

对一个函数进行异常声明后，表示该函数运行时可能会出现所声明的异常，当用户调用这个函数时，需要对这个异常进行处理（抛出或者捕捉）。

public class Test {
	public static void main(String[] args) {
		DemoForZiDingYi d=new DemoForZiDingYi();
		//捕捉异常
		try {
			d.method(-5);
		} catch (ZiDingYiException e) {
			//处理异常
			e.printStackTrace();
		}
		
	}
}

当函数调用者也无法处理函数声明中的异常时，可以继续讲异常抛出：

public class Test {
	public static void main(String[] args) throws ZiDingYiException {
		DemoForZiDingYi d=new DemoForZiDingYi();
			d.method(-5);
	}
}

注意：catch代码块中也可以继续抛出异常，当catch代码块中有异常抛出时，也需要在函数上对该异常进行声明，catch捕捉的异常和抛出的异常可以是相同的异常，也可以是不同的异常：

package Test;
//自定义A异常
class AException extends Exception{
	AException(String message){
		super(message);
	}
}
//自定义B异常
class BException extends Exception{
	BException(String message){
		super(message);
	}
}
class ClassA{
	//函数上声明A异常
	public void show(int x) throws AException{
		if(x==0)
			//抛出A异常
			throw new AException("异常A");
	}
}
public class Test {
	//在函数上声明B异常
	public static void main(String[] args) throws BException{
		ClassA a=new ClassA();
		try {
			//调用已声明A异常的函数
			a.show(0);
			//捕获A异常
		} catch (AException e) {
			//处理A异常
			e.printStackTrace();
			//抛出B异常 
			throw new BException("异常B");
		}
	}
}

4.Exception类体系中有乐意子类型体系：RuntimeException类体系。RuntimeException类和子类异常都是运行时异常，当出现该类异常时，调用者可以不用进行异常处理，并且可以不用在函数上进行异常声明。之所以不用再函数上声明运行时异常，是因为该类通过不需要让调用者处理，当该类异常发生时，希望程序停止，因为运行时异常表示程序出现了无法继续运算的情况，需要停止程序并对代码进行修正。

自定义异常时，如果这个异常发生会使程序无法继续继续运算，就将该异常继承RuntimeException类。让该异常成为一个运行时异常。

//自定义一个RuntimeException异常
class DemoException extends RuntimeException{
	DemoException(String message){
		super(message);
	}
}
class DemoClass{
	//当函数中抛出RuntimeException异常时，函数上不需要声明
	public void show(int x){
		if(x==0)
			throw new DemoException("参数不能为零");
	}
}
public class Test {
	public static void main(String[] args){
		DemoClass dc=new DemoClass();
		//调用一个会抛出RuntimeException异常的函数时，不需要处理异常的语句
		dc.show(0);
	}
}

5.try{}catch{}finally{}代码块的几种使用形式。

形式1： 

		try {
			
		} catch (Exception e) {
			 
		}

形式2：

		try {
			
		} catch (AException e) {
			 
		} catch (BException e) {
			 
		} catch (CException e) {
			 
		}

注：当一个try对应多个catch时，如果这几个异常之间存在继承关系，需要将父类异常放在后面的catch代码块中。

如果将父类异常放在前面的catch中，则后面catch就无法补货子类异常，会出现编译失败。

形式3.

		try {
			
		} catch (Exception e) {
			 
		} finally{
			
		}

注：finally代码块中的语句一般是必须执行的语句，除非系统停止，否则finally代码块必会执行一次。

形式4.

		try {
			
		} finally{
			
		}

注：这个形式中并没有异常处理。

6.继承中子父类异常。

若一个父类函数中抛出一个异常，当其子类重写该函数时，可以不抛出异常，如果要抛出异常，必须是父类函数异常或者其子异常。

若一个父类函数中抛出多个异常，当其子类重写该函数时，可以不抛出异常，如果要抛出异常，只能是父类函数异常的子集。

若一个父类函数中没有抛出异常，当其子类重写该函数时，也不能抛出异常，如果出现异常，就必须在函数进行try{}catch{}处理。