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; //会出现算数异常，除数不为零 }}