Java 异常的捕获与处理详解（二）

上一篇Java 异常的捕获与处理详解（一）讲了异常的产生、处理以及处理流程，接下来讲其他内容。

一、throws关键字
throws关键字主要是在方法定义上使用的，
表示的是此方法之中不进行异常的处理，而交给被调用处处理。
例如：

class MyMath {
    public int div(int x, int y) throws Exception {
        return x / y;
    }
}

现在的div()方法之中抛了一个异常出来，
表示所有的异常交给被调用处进行处理。

class MyMath {
    public int div(int x, int y) throws Exception {
        return x / y;
    }
}

public class Test {
    public static void main(String args[]) {
        try {
            System.out.println(new MyMath().div(10, 0));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

java.lang.ArithmeticException: / by zero
    at MyMath.div(Test.java:3)
    at Test.main(Test.java:10)

注意： 在调用throws声明方法的时候，
一定要使用异常处理操作进行异常的处理，这属于强制性的处理。

而主方法本身也属于方法，那么在主方法上也可以继续使用throws进行异常的抛出：

class MyMath {
    public int div(int x, int y) throws Exception {
        return x / y;
    }
}

public class Test {
    public static void main(String args[]) throws Exception {
        System.out.println(new MyMath().div(10, 0));
    }
}

运行结果:

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at MyMath.div(Test.java:3)
    at Test.main(Test.java:9)

这时主方法将异常继续向上抛，交给JVM进行异常的处理，也就是采用默认的方式，输出异常信息，而后结束程序执行。

注意：在实际开发中，
主方法不要加throws，
因为程序如果有异常，我们也希望可以正常的结束。

二、throw关键字

之前所有异常类对象都是由JVM自动进行实例化操作的，
用户也可以自己手工的抛出一个异常类实例化对象，就通过throw完成了。

class MyMath {
    public int div(int x, int y) throws Exception {
        return x / y;
    }
}

public class Test {
    public static void main(String args[]) {
        try {
            throw new Exception("自定义的异常");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

java.lang.Exception: 自定义的异常
    at Test.main(Test.java:4)

小结：throw和throws的区别？

（1）throw：在方法体内使用，表示人为的抛出一个异常类对象（这个对象可可以是自己实例化的，也可以是已存在的）；
（2）throws:在方法的声明上使用，表示在此方法中不进行异常的处理，而交给被调用处处理。

三、异常处理标准格式

我们有种感觉，finally和throw没有用处。现要求定义一个div()方法，这个方法有如下的一些要求：
（1）在进行除法操作之前，输出一行提示信息；
（2）在除法操作执行完毕后，输出一行提示信息；
（3）如果中间产生了异常，则应该交给被调用处来进行处理。

class MyMath {
    // 出现异常要交给被调用处出，使用throws
    public int div(int x, int y) throws Exception {
        System.out.println("===== 计算开始 ====="); 
        int result = 0;
        try {
            result = x / y; // 除法计算
        } catch (Exception e) {
            throw e; // 向上抛
        } finally {
            System.out.println("===== 计算结束 ====="); 
        }
        return result;
    }
}

public class Test {
    public static void main(String args[]) {
        try {
            System.out.println(new MyMath().div(10, 0));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果:

===== 计算开始 =====
===== 计算结束 =====
java.lang.ArithmeticException: / by zero
    at MyMath.div(Test.java:7)
    at Test.main(Test.java:20)

以上代码也可以做一些简化：

class MyMath {
    // 出现异常要交给被调用处出，使用throws
    public int div(int x, int y) throws Exception {
        System.out.println("===== 计算开始 ====="); 
        int result = 0;
        try {
            result = x / y; // 除法计算
        } finally {
            System.out.println("===== 计算结束 =====");
        }
        return result;
    }
}

public class Test {
    public static void main(String args[]) {
        try {
            System.out.println(new MyMath().div(10, 0));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

直接使用try…finally，不带有catch，那么就连处理的机会都没有了，所以不建议使用try…finally。
标准格式是try…catch、finally、throws、throw一起使用。

六、自定义异常

在Java之中本身已经提供了大量的异常类型，但是在开发之中，这些异常类型还不能满足于开发的需要。所以在一些系统架构之中往往会提供一些新的异常类型，来表示一些特殊的错误，而这种操作就称为自定义异常类，而要想实现这种自定义异常类，那么可以让一个类继承Exception或RuntimeException。

class MyException extends Exception { // 自定义异常类
    public MyException(String msg) {
        super(msg);
    }
}

public class Test {
    public static void main(String args[]) throws Exception {
        throw new MyException("自己的异常类");
    }
}

运行结果：

Exception in thread "main" MyException: 自己的异常类
    at Test.main(Test.java:9)