一、基本含义

1.1 异常(Exception)原因：

（1）用户输入了非法数据。
（2）要打开的文件不存在。
（3）网络通信时连接中断，或者JVM内存溢出。

1.2 种类

异常种类：非检查性（运行）异常和检查性异常

1.2.1 非检查性（运行）异常

系统会自动提示该种异常。

（1）空指针异常示例（NullPointerException）

String str = null;
System.out.println(str.length()); // 异常。长度为空。

（2）数组下标越界异常（ArrayIndexOutOfBoundsException）

int[] arr = {1,2,3};
for(int i = 0;i <= 3; i++){ // 异常。数组下标只能达到2。
  System.out.println(arr[i]);
} 

（3）类型转换异常（ClassCastException）

class Animal{
}
class Dog extends Animal{
}
class Cat extends Animal{
}
public class Test{
  public static void main(String[] args){
    Animal a1 = new Dog();
    Animal a2 = new Cat();
    Dog d1 = (Dog)a1;
    Dog d2 = (Dog)a2; // 异常。不可把动物猫转化为狗。
  }  
}

（4）算术异常（ArithmeticException）

int num1 = 12;
int num2 = 0;
System.out.println(num1/num2); // 异常。被除数不能为零。

1.2.1 检查性异常

需要手动添加捕获该异常的语句。

（1）连接SQL错误（SQLException）
（2）文件不存在（ClassNotFoundException）

二、 异常方法

2.1 getMessage()

public String getMessage()
返回异常的详细信息

2.2 getCause()

public Throwable getCause()
返回一个Throwable 对象代表异常原因。

2.3 toString()

public String toString()
使用getMessage()的结果返回类的串级名字。

2.4 printStackTrace()

public void printStackTrace()
打印toString()结果和栈层次到System.err，即错误输出流。

2.5 getStackTrace()

public StackTraceElement [] getStackTrace()
返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。

2.6 fillInStackTrace()

public Throwable fillInStackTrace()
用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。

三、捕获并处理异常

3.1 try…catch 捕获并处理异常

语法：

try{
 // 可能发生异常的代码块。
}catch(异常类型1 异常名1){
  // catch块。输出该种类型异常的提示信息。
}catch(异常类型2 异常名2){
  // catch块。输出该种类型异常的提示信息。
}catch(异常类型3 异常名3){
  // catch块。输出该种类型异常的提示信息。
}

语法示例：

import java.io.*;
public class ExcepTest{
  public static void main(String args[]){
    try{
      // 这是可能出现异常的代码块
      int[] a = new int[2];
      // 数组越界了（类型：ArrayIndexOutOfBoundsException）。后面语句不执行了，直接跳到catch判断异常类型语句
      System.out.println("输出数组a[3] :" + a[3]); 
    }catch(ArrayIndexOutOfBoundsException e){      
      e.printStackTrace();
    }catch(FileNotFoundException f){
      f.printStackTrace();
    }
    System.out.println("此语句不在try/catch中，没有异常判断！");
   }
}

3.2 try…catch…finally 捕获并处理异常

语法：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码,一定会被执行。作用：可以运行清理类型等收尾善后性质的语句。
}

示例：

Scanner input = new Scanner(System.in);
try{
   System.out.println("请输入第一个数：");
   int num1 = input.nextInt();
   System.out.println("请输入第二数：");
   int num2 = input.nextInt();
   System.out.println("两数之和为：" + (num1 + num2));
}catch(inputMismatchException i){ // 先子类，后父类。
  i.printStackTrace();
}catch(ArithmeticException a){
  a.printStackTrace();
}catch(Exception e){ // Exception 是所有异常的父类，所以要放在最后。
  e.printStackTrace();
}finally{
  System.out.println("计算两数之和的程序结束了！");
}

四、抛出并未处理异常

使用场景：一个方法没有捕获到一个检查性异常时。
声明次数：一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。
语法：

public void 方法名(参数列表) throws 异常列表{
  // 调用会抛出异常的方法或者
}

public class Test{
   public void divide(int num1,int num2) throws Exception{
     if(num2 == 0){
       throw new Exception("除数num2不能为零！");
     }else{
       System.out.println("num1 ÷ num2 = " + num1 / num2);
     }
   }
   // 捕获并处理异常。
   public void compute1(){
     try{
       divide(5,0);
     }catch( Exception e){
       System.out.println(e.getMessage());
     }
   }
   // 把异常抛出。交给更上一层调用者。
   public void compute2() throws Exception{
     divide(5,0);
   } 
   public static void main(String[] agrs){
      Test t1 = new Test();
      // 正常执行。
      t1.compute1(); 
      // 提示错误。在main方法签名后加throws Exception 即可。
      t1.compute2();  
      
   } 
}

六、自定义异常类

适用场景：系统没有提供该类型时的异常。
子类性：
（1）所有异常都必须是 Throwable 的子类。
（2）自定义检查性异常类时，则需要继承 IOException 类。
（3）自定义运行异常类时，则需要继承 RuntimeException 类。
（4）简写。直接继承Exception类。
语法：

public class MyException extends Exception{
}

public class MyRuntimeException extends RuntimeException{
}

示例：
自定义检查性异常类：

import java.io.*;
public class MyException extends Exception{
  /**
   * 取出钱多于余额时，返回存储余额
   * 
   */
  private double amount; // amount = 输入数字 - 实际余额。
  public MyException(double amount){
    this.amount = amount;
  } 
  public double getAmount(){
    return amount;
  }
}

银行账户类：

public class CheckingAccount{
  private double balance; // 余额
  private int number; // 卡号
  public CheckingAccount(int number){
    this.number = number;
  }
  //方法：存钱
  public void deposit(double amount){
    balance += amount;
  }
  //方法：取钱
  public void withdraw(double amount) throws MyException{ // 自定义异常调用。
    if(amount <= balance){
      balance -= amount;
    }else{
      double needs = amount - balance;
      throw new MyException(needs); // 创建异常对象，并抛出异常结果。
   }
  }
  //方法：返回余额
  public double getBalance(){
    return balance;
  }
  //方法：返回卡号
  public int getNumber(){
    return number;
  }
}

主函数入口类：

public class BankDemo{
  public static void main(String [] args){
    // 创建账户实例对象。
    CheckingAccount c = new CheckingAccount(101);    
    System.out.println("存入500元");
    // 调用方法：存入500元钱。
    c.deposit(500.00);
    // 可能出现异常处：取钱。
    try{
      System.out.println("开始取钱了，取出100元！");
      // 调用方法：取钱
      c.withdraw(100.00);
      System.out.println("再次取出500元钱");
      // 调用方法：取钱。
      c.withdraw(500.00); // 出现异常：因为账户中没有500元了。
    }catch(MyException e){ 
      System.out.println("取钱超了" + e.getAmount());
      // 打印出出现异常的原因。即异常信息。
      e.printStackTrace();
    }
  }
}

七、异常链

步骤：
（1）把捕获的异常包装成一个新的异常。
（2）在新的异常中，添加对原始异常的引用。
（3）再把新异常抛出。
原理：一个异常的发生导致另一个异常的发生。像链条一样。

/**
 * tes1(): 抛出"异常1"异常。
 * test2(): 调用test1()，捕获"异常1"，并且包装成运行时异常。继续抛出。
 * main()：调用test2()，尝试捕获test2()方法抛出的异常。
 */ 
public class ChainTest{
  public static void main(String[] args){
     ChainTest ct = new ChainTest();
     try{
       ct.test2();  
     }catch(Exception e){
       e.printStackTrace();
     }
  }
  
  // 
  public void test1(){
    throw new DrunkException("喝酒别开车！");
  }
  // 
  public void test2(){
    try{
       // 调用test1()方法。
       test1(); 
    }catch(DrunkException d){ // 捕获异常。
       // 包装成新的RuntimeException异常。
      RuntimeException newRE = new RuntimeException("司机一滴酒，亲人两行泪！");
      // 向前追溯原始（最初）异常。
      newRE.initCause(d);
      // 简写。RuntimeException newRE = new RuntimeException(d);
      // 抛出包装后的异常。
      throw newRE;
    }
  }
}

自定义喝酒异常类：

public class DrunkException extends Exception{
  public DrunkException(){
  }
  public DrunkException(String str){
    super(str);
  }
}

八、总结

（1）处理RuntimeException异常时，优化代码 + try-catch捕捉处理。
（2）多重try-catch后加Exception处理可能遗漏的异常。
（3）尽量去处理异常，减少直接使用printStackTrace()打印输出。
（4）本级异常，本级处理。根据实际业务情况，灵活处理异常。
（5）尽量添加finally语句，去释放占用的资源。