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