异常（一）

1、什么是异常？

异常，就是指程序在运行时出现不正常的情况。

        异常也是某种意义上的错误，就是问题，虽然编译通过了，但会导致运行失败。

（1）异常的由来：

          问题也是现实中的一个具体的事物，也可以通过Java类的形式进行描述，并封装成对象。

          其实就是Java对不正常情况进行描述后的对象体现。

          问题封装成对象。

（2）对于问题的划分，分为两种：

          一种是严重的问题，一种是非严重的问题。

          对于严重的，Java通过Error类进行描述。

          对于Error，一般不编写针对性的代码对其进行处理。

          对于不严重的，Java通过Exception类进行描述。

          对于Exception，可以使用针对性的处理方式进行处理。

          无论Error还是Exception，都具有一些共性的内容。

          比如：不正常的信息，引发原因等。

          函数有异常发生时，函数就停止，所以两个异常不能同时处理。

2、异常的处理

Java提供了特有的语句对异常进行处理。

try

{

    需要被检测的代码；

}

catch（异常类 变量）

{

    处理异常的代码；

}

finally

{

一定会执行的语句；

}

代码示例：

class ExceptionDemo {
	public static void main(String[] args){
		Demo d = new Demo();
		
		try{
			int f = d.div(5,0);     //函数有异常发生，函数就停止，所以两个异常不能同时处理。
			System.out.println(f);
		}
		catch(Exception e){
		        System.out.println(e.toString());  //捕获异常，并处理
			System.out.println("除零啦");
		}
		
		System.out.println("over");
	}
}
class Demo {
	int div(int a,int b) throws Exception {
		return a/b;                 //会出现异常，除数不为零
	}
}

出现异常不进行处理时，默认打印异常信息：

对异常用try-catch进行处理后：

（1）对捕获到的异常进行常见方法操作：

//e为异常对象

e.toString();        //打印异常的简短描述

String getMessage();    //获取异常的信息

e.printStackTrace();      //JVM默认的异常处理机制，就是在调用printStackTrace()方法打印异常的堆栈跟踪信息。

（2）在函数上声明异常，即 throws Exception

便于提高安全性，要捕获进行处理，不处理编译失败。

函数后使用 throws 关键字声明此函数可能会出现问题。

3、对多异常的处理

（1）声明异常时，建议声明为更具体的异常，这样处理的可以更具体。

例如，上面除数为0的异常为算数异常，可以声明为ArithmeticException，更为具体。

（2）对方声明几个异常，就对应几个catch块，不要定义多余的catch块。

如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面.（ArithmeticException就继承了Exception）

否则，只执行父类异常的catch块。

（3）异常中的多态性，父类异常也是多态性的体现，抛出的异常对象可以是父类引用。

（4）建议在进行catch处理时，catch中一定要定义具体处理方式，不要简单定义一句输出语句 e.printStackTrace()，而是输出为一个异常日志文件。

多异常处理的Demo：

class ExceptionDemo {
	public static void main(String[] args){
		Demo d = new Demo();
		
		try{
			int f = d.div(5,0);     //函数有异常发生，函数就停止，所以两个异常不能同时处理。
			System.out.println(f);
		}
		catch(ArithmeticException e){
		    System.out.println(e.toString());//捕获算数异常，并处理
			System.out.println("除零啦");
		}
		
 		catch(ArrayIndexOutOfBoundsException c){  //捕获脚标越界异常，并处理
			System.out.println(c.toString());    
			System.out.println("数组脚标越界啦");
		}
		
		catch(Exception e) {    //父类异常放在最下面,否则只执行父类异常
			System.out.println("haha:"+e.toString());
		} 
		
		System.out.println("over");
	}
}
class Demo {
	int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException {
 		int[] arr = new int[a];
		System.out.println(arr[4]);  //会出现脚标越界异常 
		return a/b;                 //会出现算数异常，除数不为零
	}
}

结果为除数为0异常：

把

int f = d.div(5,0);

改为

int f = d.div(4,1);

就会出现数组脚标越界异常：

3、自定义异常

因为项目中会出现特有的问题，而这些问题并未被Java所描述并封装对象。

所以对于这些特有的问题，可以按照Java的对问题封装的思想，将特有的问题，进行自定义的异常封装。

那么就需要对这个问题进行自定义的描述。

（1）当在函数内部出现了 throw 抛出异常对象，那么就必须给出对应的异常处理：

                要么在内部 try-catch 处理；

                要么在函数上声明异常，让调用者处理，

                 一般情况下，函数内出现异常，函数上需要声明。

（2）发现打印的结果中只有异常的名称，却没有异常的信息，因为自定义的异常并未定义信息。

（3）如何定义异常信息呢？

                因为父类中已经把异常信息的操作都完成了，

                所以子类只要在构造时，通过 super() 语句，将异常信息传递给父类，

                那么就可以直接通过 getMessage() 方法获取自定义的异常。

（4）自定义异常：

                自定义异常类必须继承 Exception。

           继承Exception 的原因：

                 异常体系有个特点：因为异常类和异常对象都被抛出；

                 他们都具备可抛性，这个可抛型是 Throwable 这个体系中独有的特点；

                 Throwable 是 Exception 和 Error 的父类，

                 只有这个体系中的类和对象才可以被 throws 和 throw 操作。

（5）throws 和 throw 的区别

             a)  throws 使用在函数上（大括号和小括号之间）。throw 使用在函数内。

             b)  throws 后面跟的是异常类，可以跟多个（多异常），用逗号隔开。

                   throw 后面跟的是异常对象（new关键字）。

             c)  一般情况下，函数内抛出异常，则该函数上必须抛出异常类。

                   RuntimeException 是特例。

自定义异常的Demo：

// 需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的，即自定义的异常。
class ZiDingYiException {
	public static void main(String[] args){
		Demo d = new Demo();
		
		try {
			int f = d.div(5,-1);     //函数有异常发生，函数就停止，所以两个异常不能同时处理。
			System.out.println(f);
		}
		
		catch(ArithmeticException e){
			System.out.println(e.getMessage());
			System.out.println("除零啦");
		}
		
		catch(FuShuException e){
			System.out.println(e.getMessage());
			System.out.println("除数出现负数了");
		}
		
		System.out.println("over");
	}
}
class Demo {
	int div(int a,int b) throws ArithmeticException,FuShuException {  //会出现除数为0异常和负数异常
		if(b<0){
			throw new FuShuException("出现了除数是负数的情况：/by fushu"); //手动通过throw关键字抛出异常对象，括号内为定义的异常信息
		}
		return a/b;                 
	}
}
class FuShuException extends Exception{  //自定义的异常类中，需通过构造函数传递异常信息 
	private String msg;
	FuShuException(String msg){     //利用构造函数传递异常信息
		this.msg = msg;
	}
	public String getMessage(){    //重写getMessage;给异常定义信息
		return msg;
	} 
}
/* 	因为父类中已经把异常信息的操作都完成了。
　　所以子类只要在构造时，将异常信息传递给父类通过super()语句。
　　那么就可以直接通过getMessage()方法获取自定义的异常。 */
/* 	
	即 FuShuException() 函数中的三个语句，可以替换为：
	
	FuShuException(String msg){
		super(msg);    
	}
	即 FuShuException类如下：
*/	

class FuShuException extends Exception{ 
	FuShuException(String msg){        //利用构造函数传递异常信息
		super(msg);                    //通过 super()语句，将异常信息传递给父类
	}
}

运行结果：

4、RuntimeException

（1）Exception中有一个特殊的子类异常，即 RuntimeException；

          如果在函数内抛出该异常，函数上可以不用声明，编译一样通过；

          如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过；

          之所以不用在函数上声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。

          因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。

（2）自定义异常时：

          如果该异常发生，无法再继续进行运算时，就让自定义的异常继承 RuntimeException 。

（3）对于异常分为两种：

           a)  编译时被检测的异常，Exception；

           b)  编译时不被检测的异常（运行时异常，RuntimeException及其子类）

                运行时异常，函数内抛出异常对象，函数上不用声明异常，也不用在调用时处理异常。

RuntimeException的Demo：

class RuntimeException {
	public static void main(String[] args){
		Demo d = new Demo();

		int f = d.div(5,0);
		System.out.println(f);

		System.out.println("over");
	}
}
class Demo {
	int div(int a,int b){    //throws ArithmeticException，因为ArithmeticException是RuntimeException的子类
		if(b==0){
			throw new ArithmeticException(); //手动通过throw关键字抛出异常对象。
		}
		return a/b;        //会出现算数异常，除数不为零
	}
}