Java基礎之異常

/**
 * Created by leo on 17-7-13.
 * 自定義的異常，MyExcepiton extends Exception
 */
/*
通常來講，Java中的異常會被分爲三種：
Error: 這種異常被設計成不被捕獲，因爲這種異常產生於JVM自身。
Runtime Exception: 運行時異常往往與環境有關，編譯時無法檢查，並且可能發生的情況太廣泛，所以系統會去處理，程序不需要捕獲。
普通異常: 常見的異常大多屬於此類,包括官方定義的和自定義的要處理的異常。

這裏的Java異常指直接繼承java.lang.Throwable的異常類，他們的結構如下：
java.lang.Throwable
  -->java.lang.Error
  -->java.lang.Exception
    -->java.lang.RuntimeException

1.java.lang.Throwable
java.lang.Throwable是Java中所有可以錯誤和異常的父類。這裏設計成父類而不是接口，我想部分原因可能是在Java誕生的早期，
使用類繼承結構更爲流行。但更重要的原因應該是由於Exception不適於設計爲接口。接口重視的是實現方法，規則的描述，
而Exception重視的是裏面含有的信息以及類名等信息。

Throwable的子類一般含有兩個構造函數：空參數的構造函數和帶異常信息String參數的構造函數。
如果此類繼承自其它Exception類，又會多兩個構造函數：含Throwable參數的構造函數和含Throwable，描述信息String兩個參數的構造函數。

2.java.lang.Error
java.lang.Error發生在應用程序不應該試圖捕獲的情況。Java程序不需要去throw或catch此類及其子類，因爲這種異常不應該由應用程序處理，並且通常屬於abnormal的情況。

3.java.lang.Exception
java.lang.Exception是指Java程序應該捕獲的異常。其中，java.lang.RuntimeException是其中一個特別的子類。

4.java.lang.RuntimeException
Java程序應該捕獲，卻可以不去捕獲的一個異常。在大多數情況下，都不會去捕獲他，一個重要原因是這種異常可能發生的情況太普遍，
幾乎每行代碼都會有RuntimeException的風險，因此反而無需去捕獲了。
JDK文檔中的原話是：“A method is not required to declare in its throws clause any subclasses of RuntimeException that might
 be thrown during the execution of the method but not caught.”
 */
public class MyExcepiton extends Exception {
    String message;

    public MyExcepiton() {
    }

    public MyExcepiton(int n) {
        message = n + " not a positive.";
    }

//該方法中把自定義異常給拋出
    public void check(int n) throws MyExcepiton{
        if(n < 0) {
//            throw new MyExcepiton(n);
            throw new MyExcepiton("my exception is here.");
        }
        double number = Math.sqrt(n);
        System.out.println("the sqrt of n is " + number);
    }

    public static void main(String[] args){
        MyExcepiton excepiton = new MyExcepiton();
        try {
            excepiton.check(2);
            excepiton.check(-8);
        } catch (MyExcepiton myExcepiton) {
            myExcepiton.printStackTrace();
        }
    }

    @Override
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public MyExcepiton(String message) {
        super(message);
        System.out.println(message);
    }

    public MyExcepiton(String message, Throwable cause) {
        super(message, cause);
    }

    public MyExcepiton(Throwable cause) {
        super(cause);
    }

    protected MyExcepiton(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }

}

下面也是自定義異常及使用的一個小例子：

/**
 * Created by leo on 17-7-13.
 */
public class ExceptionTest {
    public static void main(String[] args) {
        try {
            Rec rec = new Rec(1, -2);  //因爲Rec的構造方法拋出異常，所以本方法中要麼try-catch,要麼throws

	    rec.getArea();
        } catch (NoValueException e) {
            e.printStackTrace();
        }
    }
}

interface Shape{
    void getArea();
}

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

class Rec implements Shape{
    private int len, wid;

    Rec(int len, int wid) throws NoValueException{
        if(len <=0 || wid <= 0) throw new NoValueException("出現非法值。");
        this.len = len;
        this.wid = wid;
    }
    @Override
    public void getArea() {
        System.out.println(len * wid);
    }
}