[Java] 超详细讲解Java异常

• 异常类型回答了 “什么” 被抛出
  
• 异常堆栈跟踪回答了 “在哪” 抛出
  
• 异常信息回答了 “为什么” 会抛出
  

• try：用于监听。
  

• catch：用于捕获异常。
  

• finally：finally 语句块总是会被执行。
  

• throw：用于抛出异常。
  
• throws：用在方法签名中，用于声明该方法可能抛出的异常。
  

• 非检查异常（Error、RuntimeException 或它们的子类）不可使用 throws 关键字来声明要抛出的异常。
  
• 一个方法出现编译时异常，就需要 try-catch/ throws 处理，否则会导致编译错误。
  

public static void readFile(String filePath) throws IOException {
  BufferedReader reader = new BufferedReader(new FileReader(filePath));
  String res;
  while ( (res = reader.readLine()) != null ) {
    System.out.println(res);
  }
  reader.close();
}

public class MyException extends Exception {
  public MyException() {
    super();
  }
  public MyException(String message) {
    super(message);
  }
}

public static void readFile(String filePath) throws MyException {
  BufferedReader reader = null;
  String res;
  try {
    reader = new BufferedReader(new FileReader(filePath));
    while ( (res = reader.readLine()) != null ) {
      System.out.println(res);
    }
  } catch (IOException e) {
    MyException myException = new MyException("读取文件失败！");
    myException.initCause(e);
    throw myException;
  }
  try {
    reader.close();
  } catch (IOException e) {
    e.printStackTrace();
  }
}

public static void readFile(String filePath) {
  try {
    // do
  } catch (FileNotFoundException e) {
    // handle FileNotFoundException
  } catch (IOException e) {
    // handle IOException
  }
}

public static void readFile(String filePath) {
  try {
    // do
  } catch (FileNotFoundException | UnknownHostException e) {
    // handle FileNotFoundException or UnknownHostException
  } catch (IOException e) {
    // handle IOException
  }
}

public class MyException extends Exception {
  public MyException() {
    super();
  }
  public MyException(String message) {
    super(message);
  }
}

public static void readFile(String filePath) throws MyException {
  BufferedReader reader = null;
  String res;
  try {
    reader = new BufferedReader(new FileReader(filePath));
    while ( (res = reader.readLine()) != null ) {
      System.out.println(res);
    }
  } catch (IOException e) {
    System.out.println("catch 代码块");
    MyException myException = new MyException("读取文件失败！");
    myException.initCause(e);
    throw myException;
  } finally {
    System.out.println("finally 代码块");
    if (null != reader) {
      try {
        reader.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

catch (IOException e) {
  System.out.println("catch 代码块");
  return ;
}

catch 代码块
finally 代码块

public static void tryWithResourceTest() {
  try {
    Scanner scanner = new Scanner(new FileInputStream("d:/"),"UTF-8");
  } catch (IOException e) {
    // handle IOException
  }
}

• throw 关键字用在方法内部，只能用于抛出一种异常，用来抛出方法或代码块中的异常，
  

• throws 关键字用在方法声明上，可以抛出多个异常，用来标识该方法可能抛出的异常列表。
  

• final 可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量
  

• finally一般作用在 try-catch 代码块中，在处理异常的时候，通常我们将一定要执行的代码方法 finally 代码
  

• finalize 是一个方法，属于 Object 类的一个方法，而 Object 类是所有类的父类，Java 中允许使用 finalize()
  

public static int getInt() {
  int a = 10;
  try {
    System.out.println(a / 0);
    a = 20;
  } catch (ArithmeticException e) {
    a = 30;
    // 程序执行到这里时，不是 return a，而是 return 30，这个返回路径已经形成
    // 但是后面还有 finally，所以继续执行 finally 内容，a = 40
    // 再次回到这里，继续 return 30，形成返回路径后，这里的 a 就不是变量了，
    // 而是常量 30，所以结果为 30
    return a;
  } finally {
    a = 40;
  }
  return a;
}

public static int getInt() {
  int a = 10;
  try {
    System.out.println(a / 0);
    a = 20;
  } catch (ArithmeticException e) {
    a = 30;
    return a;
  } finally {
    a = 40;
    // 如果 finally 中 return，这样就重新又形成了一条返回路径，
    // 由于只能通过 1 个 return 返回，所以这里直接返回 40
    return a;
  }
}

try {
  throw new ExampleB("B");
} catch (ExampleA e) {
  System.out.println("ExampleA");
} catch (Exception e) {
  System.out.println("Exception");
}

class AnnoyanceException extends Exception {
}
class SneezeException extends AnnoyanceException {
}
public class Test04 {
  public static void main(String[] args) throws Exception {
    try {
      try {
        throw new SneezeException();
      } catch (AnnoyanceException a) {
        System.out.println("Caught Annoyance");
        throw a;
      }
    } catch (SneezeException s) {
      System.out.println("Caught Sneeze");
      return;
    } finally {
      System.out.println("Hello World");
    }
  }
}

Caught Annoyance
Caught Sneeze
Hello World

• ClassCastException（类转换异常）
  
• IndexOutOfBoundsException（数组越界）
  
• NullPointerException（空指针）
  
• ArrayStoreException（数据存储异常，操作数组时类型不一致）
  
• 还有IO操作的 BufferOverflowException 异常
  

• java.lang.IllegalAccessError：违法访问错误。当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。
  
• java.lang.InstantiationError：实例化错误。当一个应用试图通过 Java 的 new 操作符构造一个抽象类或者接口时抛出该异常。
  
• java.lang.OutOfMemoryError：内存不足错误。当可用内存不足以让 Java 虚拟机分配给一个对象时抛出该错误。
  
• java.lang.StackOverflowError：堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出或者陷入死循环时抛出该错误。
  
• java.lang.ClassCastException：类造型异常。假设有类 A 和 B（A 不是 B 的父类或子类），O 是 A 的实例，那么当强制将 O 构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。
  
• java.lang.ClassNotFoundException：找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历 CLASSPAH 之后找不到对应名称的 class 文件时，抛出该异常。
  
• java.lang.ArithmeticException：算术条件异常。譬如：整数除零等。
  
• java.lang.ArrayIndexOutOfBoundsException：数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
  
• java.lang.IndexOutOfBoundsException：索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。
  
• java.lang.InstantiationException：实例化异常。当试图通过 newInstance() 方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。
  
• java.lang.NoSuchFieldException：属性不存在异常。当访问某个类的不存在的属性时抛出该异常。
  
• java.lang.NoSuchMethodException：方法不存在异常。当访问某个类的不存在的方法时抛出该异常。
  
• java.lang.NullPointerException：空指针异常。当应用试图在要求使用对象的地方使用了 null 时，抛出该异常。譬如：调用 null 对象的实例方法、访问 null 对象的属性、计算 null 对象的长度、使用 throw 语句抛出 null 等等。
  
• java.lang.NumberFormatException：数字格式异常。当试图将一个 String 转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。
  
• java.lang.StringIndexOutOfBoundsException：字符串索引越界异常。当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。
  

• Throwable 类是 Java 语言中所有错误或异常的超类。它的两个子类是 Error 和 Exception；
  
• Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题，如内存溢出、虚拟机错误、栈溢出等。
  

• Exception 类及其子类是 Throwable 的一种形式，合理的应用程序想要捕获的条件，有些异常在编写程序时无法预料的，
  

• RuntimeException 类是 Exception 类的子类（可能在Java虚拟机正常运行期间抛出的异常的超类）；
  
• IOExeption类是Exception类的子类。
  

public static void readFile(String filePath) {
  BufferedReader reader = null;
  String res;
  try {
    reader = new BufferedReader(new FileReader(filePath));
    while ( (res = reader.readLine()) != null ) {
      System.out.println(res);
    }
    reader.close(); // 错误！
  } catch (IOException e) {
    e.printStackTrace();
  }
}

public static void readFile(String filePath) {
  BufferedReader reader = null;
  String res;
  try {
    reader = new BufferedReader(new FileReader(filePath));
    while ( (res = reader.readLine()) != null ) {
      System.out.println(res);
    }
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    if (null != reader) { // 正确
      try {   
        reader.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

public static void readFile(String filePath) {
  String res;
  try {
    BufferedReader reader = new BufferedReader(new FileReader(filePath));
    while ( (res = reader.readLine()) != null ) {
      System.out.println(res);
    }
  } catch (IOException e) {
    e.printStackTrace();
  }
}

public void doNotDoThis() throws Exception {
  
}
public void doThis() throws NumberFormatException {
  
}

try {
  new Long("xxx");
} catch (NumberFormatException e) {
  e.printStackTrace();
}

java.lang.NumberFormatException: For input string: "xxx"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Long.parseLong(Long.java:589)
at java.lang.Long.<init>(Long.java:965)

public static void catchMostSpecificExceptionFirst() {
  try {
    // do
  } catch (NumberFormatException e) {
    // handle NumberFormatException
  } catch (IllegalArgumentException e) {
    // handle IllegalArgumentException
  }
}

public void doNotIgnoreExceptions() { 
  try{ 
    // do 
  } catch (NumberFormatException e){ 
    // this will neverhappen
  }
}

public void logAnException() { 
  try{ 
    // do 
  } catch (NumberFormatException e){ 
    log.error("This should never happen: "+ e)
  }
}

try {
  new Long("xxx");
} catch (NumberFormatException e) {
  log.error(e);
  throw e;
}

public void wrapException(String input) throws MyException {
  try { 
    // do 
  } catch(NumberFormatException e) { 
    throw new MyException("A message that describesthe error.", e);
  }
}

public void wrapException(String input) throws MyException {
  try { 
    // do 
  } catch(NumberFormatException e) { 
    throw new MyException("A message that describesthe error.", e);
    // 等价于 
    // MyException myException = new MyException("A message that describesthe error.");
    // myException.initCause(e);
    // throw myException;
  }
}

• 仅在异常情况下使用异常；
  
• 在可恢复的异常情况下使用异常；