摘要：結果如下十一月上午嚴重靜態的方法創建了一個參數的對象，這個對象會將輸出發送到也就是發送到對象初始化的字符串到緩沖區中，執行到構造器新建對象的時候，就已經拿到了這個對象輸出到流緩沖區的字符，但是由于我們只是獲得了字符，所以我們調用獲取到了其中

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.logging.Logger;

/**
 * Created by 2017 on 2017/11/10.
 */
class LoggingException extends Exception{
    private static Logger logger = Logger.getLogger("LoggingException");

    public LoggingException() {
        StringWriter trace = new StringWriter();
        printStackTrace(new PrintWriter(trace));
        logger.severe(trace.toString());
    }
}
public class LoggingExceptions {
    public static void main(String[] args) {
        try {
            throw new LoggingException();
        } catch (LoggingException e) {
            System.err.println("Caught"+e);
        }
    }
}

結果如下

十一月 10, 2017 9:34:31 上午 LoggingException 
嚴重: LoggingException
    at LoggingExceptions.main(LoggingExceptions.java:20)

CaughtLoggingException

靜態的Logger方法創建了一個string參數的logger對象，這個logger對象會將輸出發送到system.err(也就是發送到logger對象初始化的字符串到緩沖區中)，執行到構造器新建對象trace的時候，trace就已經拿到了這個logger對象輸出到流緩沖區的字符，但是由于我們只是獲得了字符，所以我們調用 printStackTrace(new PrintWriter(trace))獲取到了其中的異常信息，并通過trace獲取錯誤信息到緩沖區中，然后我們要輸出緩沖區重的字符串，調用 logger.severe(trace.toString()); 方法對字符串進行打印，并把結果寫入到logger中，最后在main方法里執行try語句的時候會加載LoggingException的構造器，從而通過logger.severe(trace.toString());來打印出logger里的信息到控制臺

12.6.3異常鏈

/**
 * Created by 2017 on 2017/11/12.
 */
public class Test {

    public static void main(String[] args) {
        DynamicFields df = new DynamicFields(3);
        System.out.println(df);
        try {
            df.setField("d", "a value of d");
            df.setField("killer47", 47);
            df.setField("fatkiller48", 48);
            System.out.println(df);
            df.setField("d", "a new value of d");
            df.setField("thinkiller", 11);
            System.out.println("df:" + df);
            System.out.println("df.getField("d")" + df.getField("d"));
            Object field = df.setField("d", null);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (DynamicFieldException e) {
            e.printStackTrace();
        }
    }
}

class DynamicFieldException extends Exception {}
class DynamicFields {
    private Object[][] fields;
    public DynamicFields(int initialSize) {
        this.fields = new Object[initialSize][2];
//        這里的長度是由用戶指定的，里面存儲的是initialsize個一唯數組，每一個一唯數組的長度是2
        for (int i = 0; i < initialSize; i++) {
//            這里開始遍歷1唯數組，然后給1唯數組里的每個元素進行賦值
            fields[i] = new Object[]{null, null};
        }
    }

    public String toString() {
        StringBuilder result = new StringBuilder();
        for (Object[] object : fields) {
//            object遍歷的數組是1唯數組的個數，1唯數組有幾個就遍歷幾次,
//            由于object取出的是每一個一唯數組，所以object[0]取出的是每一個一唯數組里每一個元素的值，由于上面指定1唯數組的長度是2，所以取0，和1兩個下標進行遍歷，添加到緩沖區然后返回數組里的所有內容
//            object[0]取出的是每一個1唯數組，
            result.append(object[0] + ": " + object[1] + "
");
        }
        return result.toString();
    }

    private int hasField(String id) {
        for (int i = 0; i < fields.length; i++) {
            if (id.equals(fields[i][0]))
                return i;
        }
        return -1;
    }

    private int getFieldNumber(String id) throws NoSuchFieldException {
        int fieldNum = hasField(id);
        if (fieldNum == -1) {
            throw new NoSuchFieldException();
        }
        return fieldNum;
    }

    private int makeField(String id) {
        for (int i = 0; i < fields.length; i++) {
            if (fields[i][0] == null) {
                fields[i][0] = id;
                return i;
            }
        }
        // 如果空間滿了，那就在造一個空間
        Object[][] temp = new Object[fields.length + 1][2];
        for (int i = 0; i < fields.length; i++) {
            temp[i] = fields[i];
        }
        temp[fields.length] = new Object[]{null, null};
        fields = temp;
        return makeField(id);
    }

    public Object getField(String id) throws NoSuchFieldException {
        return fields[getFieldNumber(id)][1];
    }

    public Object setField(String id, Object value)
            throws DynamicFieldException {
        if (value == null) {
            DynamicFieldException dfe = new DynamicFieldException();
            dfe.initCause(new NullPointerException());
            throw dfe;
        }
        int fieldNumber = hasField(id);
        if (fieldNumber == -1) {
            fieldNumber = makeField(id);
        }
        Object result = null;
        try {
            result = getField(id);
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
//            e.printStackTrace();
        }
        fields[fieldNumber][1] = value;
        return result;
    }
}

底層類似于一個MAP的容器，我們通過調用DynamicFieldException的initcause方法來把其他的異常鏈接起來，也可以通過exception的構造器來傳入一個異常，這樣我們可以追蹤到異常最初發生的位置，不過需要注意的是，在調用setfiled的時候，如果跑出文件找不到異常（屬于查找才有的異常類型，而不是設置字段應該拋出的異常類型），所以我們需要用接受cause參數的構造器把文件找不到異常轉換成運行時異常