异常处理（Exception Handling）

java里的异常处理（Exception）
Exception 是在程序执行过程中发生的一些不希望发生的事情，这些事情如果不被好好处理，就会导致奇怪的结果或者是程序终结。Exception Handler是那些当异常发生时处理这些异常的代码。所以这里只讲三个事儿：

1. 什么是异常（Exception）
1.1 Exceptions in java
1.2 checked 和 unchecked的异常
1.3 error和unchecked exception的不同
2. 如何处理异常 （how to handle exception）
2.1 try-catch-finally
2. 2. throws exception
3.如何创建一个custom的exception类
3.1 如何创建一个custom的exception类
3.2 如何扔throw一个custom的exception
1. 什么是异常（Exception）
Exception 是在程序执行过程中发生的一些不希望发生的事情，这些事情如果不被好好处理，就会导致奇怪的结果或者是程序终结。Exception Hander是那些当异常发生时处理这些异常的代码。java和javascript都用try／catch来处理异常。

1.1 Exceptions in java
exception在java里也是个object。
来个图先

图片来源： http://voyager.deanza.edu/~hso/cis35a/lecture/java13/intro/hier.html
它爸爸是Throwable（面试会考，敲黑板）。它还有个兄弟叫Error。

error and exception的不同：
An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.

The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch.

1.2 checked 和 unchecked的异常
Checked exception 是编译的时候就要求被handle的。编译的时候会检测Checked exception如果发生了有没有被handler（有没有加handler）所以也被称为compile-time exception。如果一个class是 Exception的孩子但不是 RuntimeException的孩子，那么它就是checked，写代码的时候被要求加handler 。如果用IDE, 会在写代码时要求handle这类异常。
例如： CloneNotSupportedException, IOException, SQLException,
InterruptedException, FileNotFoundException
Unchecked exception 也被称为runtime exception因为它发生在程序执行时。我们可以添加handler去处理这类异常，也可以不加handler不处理这类异常。如果一个class是 RuntimeException的子孙，那它就是一个unchecked exception。
例如： IllegalMonitorStateException,
ConcurrentModificationException, NullPointerException,
IndexOutOfBoundException, NumberFormatException
1.3 error和unchecked exception的不同
虽然都发生在runtime，但是error不被建议去handle。 大部分情况下即使是加了catch也无法修复。而RuntimeException可以去handle。

2. 如何处理异常 （how to handle exception）
有一些方法在声明的时候就声明扔出一个exception。如果这个exception是checked exception，则调用这个方法的时候就必须handle它。
checked exception就像一个炸弹，如果说方法A的某处扔出一个炸弹，或者从别处接到一个炸弹（调用了另一个扔出exception的方法）， 有两种解决方案：

自己把它拆了（ try-catch-finally）。 这样的话调用方法A的方法不用担心这个炸弹（异常）了
继续丢出去， 谁调用方法A谁来处理（在A的method declaration的时候加上throws.）
如果采用第一种方案，当方法B调用方法A的时候，方法A已经把炸弹拆了，方法B不用担心任何事情。
如果采用第二种方法，方法B调用方法A的时候知道同时要接到一个炸弹，于是它有两种解决方案，拆了，或者继续throws。

2.1 如何拆炸弹 用try-catch-finally
try-catch:
一个常见的数组越界exception。是个unchecked的exception，因为编译时没有要求handle，所以是个常见的新手 runtime异常。（不要求被handle，但是如果想handle也是可以的。）

import java.io.*;
public class ExceptionTest1 {
   public static void main(String args[]) {
      try {
         int a[] = new int[2];
         System.out.println(a[3]); //数组越界访问
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println(e);//虽然没有做有意义的事情，但是阻止了程序死在半截。
      }
      System.out.println("run successfully");
   }
}

一个try可以跟着好几个catch, 为了分开处理不同的错误：

try {
   //doing something
} catch (Exception1 e) {
    // handle the first type exception
    System.out.println("Exception1 happened")
} catch (Exception2 f){
    // handle the first type exception
    System.out.println("Exception2 happened")
}

一个exception发生之后，如果是Exception1类型的，就会被第一个handle，如果不是Exception1类型的就会接着往下找catch，如果是Exception2类型的，就会被第二个catch块handle。
如果Exception1和Exception2是父子关系，则儿子要先被检测，因为如果爸爸先被检测，就永远也到不了儿子那个catch块了。

finally block：
finally block 是无论如何也会发生的一个block。 catch里的代码如果不发生异常就不会被执行，但是finally里面的代码无论如何都会执行。（除非是在try或者catch里面用System.exit(1)结束jvm。）通常用来关闭文件。

try {
         //doing something
      } catch (Exception e) {
          //handle the exception
      }finally {
         //一定会被执行的代码。
      }
   }
}

另外， try-finally也是合法的。

2.2 如何继续甩锅 throws exception
用throws关键词

//m1抛出了一个异常
void m1 throws FileNotFoundException(){
    //大概是想读一些文件，又不想考虑如果文件找不到咋整。(甩锅)
}
//m2调用了m1，相当于从m1手里接到了这个异常，自己不处理，继续往外甩。
void m2 throws FileNotFoundException(){
    m1();//想用m1方法，m1声明如果想用我就要考虑文件找不到的情况。
    //但是m2依然不想考虑文件找不到咋整。
}

来看个综合的例子：
下面代码由于接到了exception没有正确handle而产生编译错误：

import java.io.File;
import java.io.FileReader;
//会有编译错误
public class ReadFileTest {
   public static void main(String args[]) {
      getFile();
   }
   public static void getFile(){
          File file = new File("file.txt");
       FileReader fr = new FileReader(file);//error: unreported exception FileNotFoundException; must be caught or declared to be thrown
   }
}

因为FileReader的constructor throws了一个异常

public FileReader(String fileName) throws FileNotFoundException
1
所以当getFile方法调用FileReader的时候必须handle这个异常。

下面是一个例子用上面两种方法处理异常：

import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
public class ReadFileTest {
   public static void main(String args[]) {
           getFile1();
           System.out.println("=============");
        try{
           // 因为getFile2又把exception甩出来了，所以main方法得处理它。
           getFile2();
        }catch(FileNotFoundException e){
           System.out.println("Exception handled in main");
        }
      
   }
   //getFile1选择了自己处理,不麻烦调用它的方法
   public static void getFile1() {
        try{
                  File file = new File("file.txt");
               FileReader fr = new FileReader(file);
           }catch(FileNotFoundException e){
               System.out.println("Exception handled in getfile1");
       }
   }
   //getFile2选择了不处理，继续throws
   public static void getFile2() throws FileNotFoundException{
          File file = new File("file.txt");
       FileReader fr = new FileReader(file);
   }
}

运行结果：

Exception handled in getfile1
=============
Exception handled in main

一般来讲，所有的exception到了main方法这里都应该已经被解决了。如果，main方法也不负责任的往外扔。。。

import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
public class ReadFileTest {
   public static void main(String args[]) throws FileNotFoundException{
           getFile1();
           System.out.println("=============");
        getFile2();
      
   }
   public static void getFile1() {
        try{
                  File file = new File("file.txt");
               FileReader fr = new FileReader(file);
           }catch(FileNotFoundException e){
               System.out.println("Exception handled in getfile1");
       }
   }
   public static void getFile2() throws FileNotFoundException{
          File file = new File("file.txt");
       FileReader fr = new FileReader(file);
   }
}

这样做是可以的。。。在没有文件的情况下（触发exception）运行结果：

Exception handled in getfile1
=============
Exception in thread "main" java.io.FileNotFoundException: file.txt (No such file or directory)
    at java.io.FileInputStream.open0(Native Method)
    at java.io.FileInputStream.open(FileInputStream.java:195)
    at java.io.FileInputStream.<init>(FileInputStream.java:138)
    at java.io.FileReader.<init>(FileReader.java:72)
    at ReadFileTest.getFile2(ReadFileTest.java:21)
    at ReadFileTest.main(ReadFileTest.java:8)

3.如何应用custom的exception
3.1 如何创建一个custom的exception类
extends exception和它的孩子们呀

1. class New1Exception extends Exception { } // 创建一个checked exception
2. class NewException extends IOExcpetion { } // 创建一个跟IO相关的exception
3. class NewException extends RuntimeException { } // 创建一 UnChecked exception

来个例子(就是这么简单)：

import java.io.*;
class MyException extends Exception
{
    public MyException(String s)
    {
        super("a MyException happens: " + s);
        //还可以做一些其他的事
    }
}

3.2 如何甩出（throw）一个custom的exception
throw 和throws
throw是在方法或者代码块里面，用来扔炸弹 抛出异常。
throws是在方法声明的时候，说明这个方法抛出了异常。

用刚才的MyException写个例子：

import java.io.*;
public class Main
{
    public static void main(String args[])
    {
        try {
            throwTest();
        } catch (MyException e) {
            System.out.println("Caught something");
            System.out.println(e.getMessage());
        }
        //throwTest2是一个正常的方法，扔的exception被自己handle了。
        throwTest2();
        //另用一个block测试test3，
        //如果写在同一个block，throwTest()抛出异常后，throwTest3()不会被执行
        try {
            throwTest3();
        } catch (MyException e) {
            System.out.println("Caught something");
            System.out.println(e.getMessage());
        }
    }
    // 自己不handle，扔出来之后继续在方法声明里告诉调用自己的方法需要handle
    public static void throwTest() throws MyException {
        throw new MyException("something");
    }
    //自己handle了，变成一个正常的方法
    public static void throwTest2() {
        try {
            throw new MyException("somethingElse");
        } catch (MyException e) {
            System.out.println("Caught somethingElse");
            System.out.println(e.getMessage());
        }
    }
    //自己handle了，在catch里继续往外扔。
    public static void throwTest3() throws MyException{
        try {
            throw new MyException("somethingElse2");
        } catch (MyException e) {
           //一个非常不负责任的catch，但是是合法的。
           throw e;
        }
    }
}

输出：

Caught something
a MyException happens: something
Caught somethingElse
a MyException happens: somethingElse
Caught something
a MyException happens: somethingElse2