违例差错控制

违例差错控制这个给程序的编写带来了很大的好处：

public class test {
    public static void f() throws Exception {
        System.out.println(
        "originating the exception in f()");
        throw new Exception("thrown from f()");
    }
    public static void g() throws Throwable {
        try {
            f();
        } catch(Exception e) {
            System.out.println(
            "Inside g(), e.printStackTrace()");
            e.printStackTrace();
            throw e;
        }
    }
    public static void main(String[] args) throws Throwable {
        try {
            g();
        } catch(Exception e) {
            System.out.println(
            "Caught in main, e.printStackTrace()");
            e.printStackTrace();
        }
    }
}

output：

java.lang.Exception: thrown from f()
originating the exception in f()
Inside g(), e.printStackTrace()
	at test.f(test.java:5)
	at test.g(test.java:9)
	at test.main(test.java:21)
java.lang.Exception: thrown from f()
	at test.f(test.java:5)
	at test.g(test.java:9)
	at test.main(test.java:21)
Caught in main, e.printStackTrace()

违例路径堆栈无论如何都会记住它的真正起点，无论自己被重复“投掷”了多少次。printStackTrace()在什么时候会被执行呢？为什么在不同的时候输出的顺序并不相同？什么时候记录调用记录的？从这个程序中都可以看出来了。再来一个例子说明问题：

public class test {
    public static void f() throws Exception {
        System.out.println(
        "originating the exception in f()");
        throw new Exception("thrown from f()");
    }
    public static void main(String[] args) {
        try {
            f();
        } catch(Exception e) {
            System.out.println(
            "Caught in main, e.printStackTrace()");
            e.printStackTrace();
            throw new NullPointerException("from main");
        }
    }
}

output：

originating the exception in f()
Caught in main, e.printStackTrace()
java.lang.Exception: thrown from f()
	at test.f(test.java:5)
	at test.main(test.java:9)
Exception in thread "main" java.lang.NullPointerException: from main
	at test.main(test.java:14)

异常和异常之间只是名字的不同（所以名字很重要）。Throwable有两种常规类型：Exception和Error。Error是指编译期和系统错误，我们不必特意捕获他们。Exception是可以从任何标准Java库的类方法中“throw”出的基本类型。RuntimeException在默认情况下自动会处理，如果必须检查RuntimeException那我们的代码就会变得相当复杂（难道我们时不时顶着空指针还得自己处理？）。一个例子：

public class test {
    static void f() {
        throw new RuntimeException("From f()");
    }
    static void g() {
        f();
    }
    public static void main(String[] args) {
        g();
    }
}

output：

Exception in thread "main" java.lang.RuntimeException: From f()
	at test.f(test.java:3)
	at test.g(test.java:6)
	at test.main(test.java:9)

如果RuntimeException获得到达main（）的所有途径，同时不被捕获，那么程序在退出的时候会自动调用printStackTrace()。

创建自己的“Exception”还是很简单的吧，举个例子：

class MyException extends Exception {
    public MyException() {}
    public MyException(String msg) {
        super(msg);
    }
}
public class test {
    public static void f() throws MyException {
        System.out.println(
        "Throwing MyException from f()");
        throw new MyException();
    }
    public static void g() throws MyException {
        System.out.println(
        "Throwing MyException from g()");
        throw new MyException("Originated in g()");
    }
    public static void main(String[] args) {
        try {
            f();
        } catch(MyException e) {
            e.printStackTrace();
        }
        try {
            g();
        } catch(MyException e) {
            e.printStackTrace();
        }
    }
}

output：

MyException
	at test.f(test.java:11)
	at test.main(test.java:20)
MyException: Originated in g()
	at test.g(test.java:16)
	at test.main(test.java:25)Throwing MyException from f()
Throwing MyException from g()

如何限制违例？在捕获到一个异常的时候怎么知道我们抓到的东西是正确的东西：

class BaseballException extends Exception {}
class Foul extends BaseballException {}
class Strike extends BaseballException {}
abstract class Inning {
    Inning() throws BaseballException {}
    void event () throws BaseballException {
    }
    abstract void atBat() throws Strike, Foul;
    void walk() {}
}
class StormException extends Exception {}
class RainedOut extends StormException {}
class PopFoul extends Foul {}
interface Storm {
    void event() throws RainedOut;
    void rainHard() throws RainedOut;
}
public class test extends Inning implements Storm {
    test() throws RainedOut, BaseballException {}
    test(String s) throws Foul, BaseballException {}
    public void rainHard() throws RainedOut {}
    public void event() {}
    void atBat() throws PopFoul {}
    public static void main(String[] args) {
        try {
            test si = new test();
            si.atBat();
        } catch(PopFoul e) {            
        } catch(RainedOut e) {            
        } catch(BaseballException e) {
        }
        try {
            Inning i = new test();
            i.atBat();
        } catch(Strike e) {            
        } catch(Foul e) {            
        } catch(RainedOut e) {            
        } catch(BaseballException e) {
        }
    }
}

Java提供了用finally来清除（也是一个从异常中恢复运行的例子）：

public class test {
    static int count = 0;
    public static void main(String[] args) {
        while(true) {
            try {
                if(count++ == 0)
                    throw new Exception();
                System.out.println("No exception");
            } catch(Exception e) {
                System.out.println("Exception thrown");
            } finally {
                System.out.println("in finally clause");
                if(count == 2) break;
            }
        }
    }
}

output：

Exception thrown
in finally clause
No exception
in finally clause

finally中的代码不管是在什么情况下都是会执行的。finally能做什么呢？比如打开文件或者套接字的时候，在finally中释放这些资源。如果没有finally要怎么实现：

class Switch {
    boolean state = false;
    boolean read() { return state; }
    void on() { state = true; }
    void off() { state = false; }
}
public class test {
    static Switch sw = new Switch();
    public static void main(String[] args) {
        try {
            sw.on();
            sw.off();
        } catch(NullPointerException e) {
            System.out.println("NullPointerException");
            sw.off();
        } catch(IllegalArgumentException e) {
            System.out.println("IOException");
            sw.off();
        }
    }
}

可以看出finally的好处了吧。即使异常不在当前的“catch”中捕获，“finally”都会在违例控制机制转到更高级别搜索一个控制器之前得到执行。eg：

class Ex extends Exception {}
public class test {
    public static void main(String[] args) {
        System.out.println("Entering first try block");
        try {
            System.out.println("Entering second try block");
            try {
                throw new Ex();
            } finally {
                System.out.println("finally in 2nd try block");
            }
        } catch(Ex e) {
            System.out.println("Caught Ex in first try block");
        } finally {
            System.out.println("finally in 1st try block");
        }
    }
}

output：

Entering first try block
Entering second try block
finally in 2nd try block
Caught Ex in first try block
finally in 1st try block

Java的异常控制机制还是有缺陷滴，一个异常可能被简单地“丢弃”，eg：

class VeryImportantException extends Exception {
    public String toString() {
        return "A very important exception!";
    }
}
class HoHumException extends Exception {
    public String toString() {
        return "A trivial exception";
    }
}
public class test {
    void f() throws VeryImportantException {
        throw new VeryImportantException();
    }
    void dispose() throws HoHumException {
        throw new HoHumException();
    }
    public static void main(String[] args)
    throws Exception {
        test lm = new test();
        try {
            lm.f();
        } finally {
            lm.dispose();
        }
    }
}

output：

Exception in thread "main" A trivial exception
	at test.dispose(test.java:16)
	at test.main(test.java:24)

这样的话“try”块中的异常就被忽略掉了，而输出的异常是“finally”模块中的。用一个例子来看看清除有构建器的文件、套接字等资源的释放（感觉这个还是不错的）：

import java.io.*;
class InputFile {
    private BufferedReader in;
    InputFile(String fname) throws Exception {
        try {
            in = new BufferedReader(new FileReader(fname));
        } catch(FileNotFoundException e) {
            System.out.println("Could not open " + fname);
            throw e;
        } catch(Exception e) {
            try {
                in.close();
            } catch(IOException e2) {
                System.out.println("in.close() unsuccessful");
            }
            throw e;
        } finally {}
    }
    String getLine() {
        String s;
        try {
            s = in.readLine();
        } catch(IOException e) {
            System.out.println("readLine() unsuccessful");
            s = "failed";
        }
        return s;
    }
    void cleanup() {
        try {
            in.close();
        } catch(IOException e2) {
            System.out.println("in.close() unsuccessful");
        }
    }
}
public class test {
    public static void main(String[] args) {
        try {
            InputFile in = new InputFile("test.java");
            String s;
            int i = 1;
            while((s = in.getLine()) != null)
                System.out.println(""+ i++ + ": " + s);
            in.cleanup();
        } catch(Exception e) {
            System.out.println("Caught in main, e.printStackTrace()");
            e.printStackTrace();
        }
    }
}

可以用异常来做些什么：

1. 解决问题并再次调用引起异常的方法；
2. 平息事态的发展，并在不重新尝试的情况下继续；
3. 计算另一些结果，而不是希望方法产生的结果；
4. 在当前环境中尽可能地处理，将相同的异常重新“throw”到一个更高级的环境；
5. 终止程序的执行；
6. 简化代码；
7. 使自己的库和程序更加安全。

-----------------------------

个人理解，欢迎拍砖。