摘要：結(jié)果如下十一月上午嚴(yán)重靜態(tài)的方法創(chuàng)建了一個參數(shù)的對象，這個對象會將輸出發(fā)送到也就是發(fā)送到對象初始化的字符串到緩沖區(qū)中，執(zhí)行到構(gòu)造器新建對象的時候，就已經(jīng)拿到了這個對象輸出到流緩沖區(qū)的字符，但是由于我們只是獲得了字符，所以我們調(diào)用獲取到了其中

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);
        }
    }
}

結(jié)果如下

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

CaughtLoggingException

靜態(tài)的Logger方法創(chuàng)建了一個string參數(shù)的logger對象，這個logger對象會將輸出發(fā)送到system.err(也就是發(fā)送到logger對象初始化的字符串到緩沖區(qū)中)，執(zhí)行到構(gòu)造器新建對象trace的時候，trace就已經(jīng)拿到了這個logger對象輸出到流緩沖區(qū)的字符，但是由于我們只是獲得了字符，所以我們調(diào)用 printStackTrace(new PrintWriter(trace))獲取到了其中的異常信息，并通過trace獲取錯誤信息到緩沖區(qū)中，然后我們要輸出緩沖區(qū)重的字符串，調(diào)用 logger.severe(trace.toString()); 方法對字符串進(jìn)行打印，并把結(jié)果寫入到logger中，最后在main方法里執(zhí)行try語句的時候會加載LoggingException的構(gòu)造器，從而通過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個一唯數(shù)組，每一個一唯數(shù)組的長度是2
        for (int i = 0; i < initialSize; i++) {
//            這里開始遍歷1唯數(shù)組，然后給1唯數(shù)組里的每個元素進(jìn)行賦值
            fields[i] = new Object[]{null, null};
        }
    }

    public String toString() {
        StringBuilder result = new StringBuilder();
        for (Object[] object : fields) {
//            object遍歷的數(shù)組是1唯數(shù)組的個數(shù)，1唯數(shù)組有幾個就遍歷幾次,
//            由于object取出的是每一個一唯數(shù)組，所以object[0]取出的是每一個一唯數(shù)組里每一個元素的值，由于上面指定1唯數(shù)組的長度是2，所以取0，和1兩個下標(biāo)進(jìn)行遍歷，添加到緩沖區(qū)然后返回數(shù)組里的所有內(nèi)容
//            object[0]取出的是每一個1唯數(shù)組，
            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的容器，我們通過調(diào)用DynamicFieldException的initcause方法來把其他的異常鏈接起來，也可以通過exception的構(gòu)造器來傳入一個異常，這樣我們可以追蹤到異常最初發(fā)生的位置，不過需要注意的是，在調(diào)用setfiled的時候，如果跑出文件找不到異常（屬于查找才有的異常類型，而不是設(shè)置字段應(yīng)該拋出的異常類型），所以我們需要用接受cause參數(shù)的構(gòu)造器把文件找不到異常轉(zhuǎn)換成運行時異常