重新开始学习javase

重新开始学习javase_Exception

“违例”（Exception）这个词表达的是一种“例外”情况，亦即正常情况之外的一种“异常”。在问题发生的时候，我们可能不知具体该如何解决，但肯定知道已不能不顾一切地继续下去。此时，必须坚决地停下来，并由某人、某地指出发生了什么事情，以及该采取何种对策。但为了真正解决问题，当地可能并没有足够多的信息。因此，我们需要将其移交给更级的负责人，令其作出正确的决定（类似一个命令链）。

其实就是发生一些异常的时候，给出java相应的指示：现在程序发生异常了，我该怎么做，你要是不告诉我的话，我就停止运行了！

基本异常的产生：

手动抛出：当满足一定的条件时，程序员认为这个时候即可认为发生了“异常”，这个时候就可以手动抛出异常对象
```
@Test
    public void test2() throws Exception{
        if(true){
            throw new Exception();
        }
    }
```

程序自己抛出：当程序认为不满足合法要求的时候，Java本身也会自动抛出相应的异常：

@Test
    public void test3() {
        int i = 1 / 0;
        /*
         * java.lang.ArithmeticException: / by zero at
         * Mytest.Test01.test3(Test01.java:68) at
         * sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at....
         * 
         */
    }

异常的捕获try{}catch(){}
往往发生异常的时候我们都需要受益人采取一定的措施，那么如何我们怎么知道什么时候发生异常了，发生了什么样的异常了呢？

@Test
    public void test4() {
        try {
            /* 正常的代码放在try｛｝中 */
            int i = 1 / 0;// 肯定会发生ArithmeticException的异常
        } catch (ArithmeticException e/*当发生ArithmeticException异常应该做什么*/) {
            System.out.println("ArithmeticException");//ArithmeticException
        } catch (NullPointerException e/*当发生NullPointerException异常应该做什么*/) {
            System.out.println("NullPointerException");
        }catch(Exception e/*当不知道会发生什么异常的时候，可以用Exception来捕获，注意cacth的顺序是：范围大的放下面*/){
            System.out.println("Exception");
        }
    }

值得注意的是：当其中一个对应的catch捕获到异常以后，别的catch是不会再运行的了

throw（抛出）与throws（声明）
当你的方法中，throw出了一个异常，你又不想做出对应的解决方案：即，try...catch..那么别人使用你的方法只有两种选择：一，我来处理。二，我也不处理，我也只是告诉别人我这方法中有哪些异常；所以你的方法中必须要告诉别人我这个方法中throw出了哪些异常，java违例规范中就强制我们当方法中的发生的异常（运行时异常除外），你不处理的时候，你必须指出方法中的哪些异常，这个时候就是throws的指明的时候了：

@Test
    public void test5() throws IllegalClassFormatException {
        if(1<2){
            throw new RuntimeException();//运行时异常，不用处理
        }
        if(2>3){
            throw new IllegalClassFormatException();//不进行处理时，必须通过throws声明出
        }
        if(3>4){
            try {
                throw new Exception();//进行try{}catch(){}处理
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

自定义异常：extends Exception
```
class MyException extends Exception{}
```

继承时，覆盖的方法中不能抛出比父类多的异常：

public class Parent {
    public void a() throw AException {
    }
}
public class Child extends Parent {
    public void a() throw AException, BException {
    }
}
 
public class Test {
    public void main(String[] args) {
        Parent p = new Child();
        try {
             p.a();//这里在调用者就不知道抛出BException了！这样就会导致一些问题
        } catch(AException e) {
             doSomething();
        }
    }
}

finally{}
当有些逻辑不管程序有没有发生异常，都必须要被执行的话可以放在finally中。

@Test
    public void test01() {
        try{
            int i=1/0;
            System.out.println("this is a very important");
        }catch(Exception e){
            System.out.println("****************");//当代码执行到1/0时，会发生异常，程序会到catch｛｝中，执行******故important不会执行
        }
    }

@Test
    public void test01() {
        try{
            int i=1/0;
            
        }catch(Exception e){
            System.out.println("****************");
            return;
        }finally{
            System.out.println("this is a very important");
            //即使当程序执行到1/0后，程序抓到异常，执行catch块并且return，finally还是会执行
        }
    }

注意：finally是在return前执行的，执行完以后return;

那么什么情况下finally是不会被执行的呢？

@Test
    public void test01() {
        try{
            int i=1/0;
            
        }catch(Exception e){
            System.out.println("****************");
            System.exit(-1);//终止java虚拟机的运行
        }finally{
            System.out.println("this is a very important");
            //即使当程序执行到1/0后，程序抓到异常，执行catch块并且return，finally还是会执行
        }
    }

java异常体系中的缺陷
```
@Test
    public void test02 () throws Exception{
        try {
            int i=1/0;
        } finally {
            throw new Exception("我是exception");
        }
    }
```
分析可知，按理说，上面的程序应该先抛出ArithmeticException,再抛出Exception，可结果：

ArithmeticException没有了！！这在thinking in java中已经提出，但到1.8版本并没解决