JAVA 异常处理机制

异常：程序在运行时发生的不正常情况。

不正常情况分成了两大类：1.不可处理（error）；2.可处理（exception）。

Throwable类是Java语言中所有错误或异常的超类，它有两个直接子类Error和Exception。Throwable及其所有的子类都具有可抛性。

在java中提供了很多的异常类，每一种异常类都对应一种特殊的错误，下面实例java中存在的异常类提供异常处理机制：

public class demooo {	
	public static void main(String[] args) {
		int a,b;
		try{
			a=Integer.parseInt("2"); //将字符串转换为int
			b=0;
			a/=b; //发生异常，自动抛出异常对象，下面两句不执行 
			System.out.println(a);
			System.out.println(b);
		}
		catch(NumberFormatException e){  //数字格式化异常
			System.out.println("NumberFormatException:"+e.getMessage());
			//public String getMessage()  用来得到有关异常事件的信息
		}
		//发生的异常是ArithmeticException类型，所以执行该语句块，其他catch语句块不会被执行
		catch (ArithmeticException e) {  //算数运算异常，除数为0
			System.out.println("ArithmeticException:"+e.getMessage());
		}
		catch (IndexOutOfBoundsException e) {  //数组下表越界异常
			System.out.println("IndexOutOfBoundsException:"+e.getMessage());
		}
		catch(Exception e){  //上述异常类都是Exception类的子类。子类异常在前面，父类异常在后面，否则不能编译通过。
			System.out.println("Exception："+e.getMessage());
		}
		finally{  //最终一定会执行
			System.out.println("程序结束！");
		}
	}
}

运行结果：

自定义异常：

如果要让一个类成为异常类，必须要继承异常体系，因为只有这样才具有可抛性，才能被关键字throws或throw操作。

throw用在函数里面，抛出的是异常对象。

throws用于函数声明，抛出的是异常类，可抛出多个，用逗号隔开。

创建一个名为MyException的自定义异常类：

class MyException extends Exception{      //自定义异常时，要么继承Exception，要么继承RuntimeException
	MyException（）{}                 //构造函数
	MyException （String msg）{
	super（msg）;
}
}

自定义异常类实例：

class MyException extends Exception // 自定义异常类
{
	public MyException(String str){
		super(str);
	}
}

public class demooo {	
	public double getArea(double r) throws MyException //声明方法的异常
	{
		if(r<0){
			MyException me=new MyException("半径不合法"); //创建异常对象
			throw me; //抛出异常（自定义异常对象只能用throw强制抛出）
			//以上两行代码可用 throw new MyException("半径不合法"); 替换
		}
		return 3.14*r*r;
	}
	public static void main(String[] args) {
		demooo d=new demooo();
		try{
			System.out.println("半径是:"+d.getArea(10));
		}catch (MyException e) {
			System.out.println(e.getMessage());
		}
		
		try {
			System.out.println("半径是:"+d.getArea(-0.5));
		} catch (MyException e) {
			System.out.println(e.getMessage());
		}
	}
}

运行结果：

异常的捕捉形式（格式）：

try
{
	//需要被检测异常的代码
}
catch（异常类  变量） //该变量接收发生的异常对象
{
	//处理异常的代码
}
finally
{
	//一定会执行的代码,通常用于关闭（释放）资源
}

注意：try finally可组合（无catch的情况）：这种异常无法直接catch处理，但是资源需要关闭。

当一个try对应多个catch的时候，要将父类的catch放在最下面。

异常处理的原则：

1.函数内部如果抛出需要检测的异常，那么函数上必须要声明，否则必须在函数内用trycatch捕捉，否则编译失败。

2.如果调用到了声明异常的函数，要么trycatch要么throws，否则编译失败。

3.功能内容可以解决时用catch；解决不了，用throws告诉调用者，由调用者解决。

4.一个功能如果抛出了多个异常，那个调用时必须有对应多个catch进行针对性处理。内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

异常的注意事项:

1.子类在覆盖父类的方法时，子类只能抛出父类的异常或者该异常的子类。

2.如果父类抛出多个异常，那么子类只能抛出父类异常的子集。

3.如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。