【Java心得总结二】浅谈Java中的异常

　　作为一个面向对象编程的程序员对于 下面的一句一定非常熟悉：

try
{
　　// 代码块
}
catch(Exception e)
{
    // 异常处理
}
finally
{
   // 清理工作
}

就是面向对象中最最常见的异常处理程序，而且甚至我们会莫名其妙的被编译器要求加上这个模块，甚至我们自己也不知道捕捉到异常该怎么处理。。。

• 为什么要有异常

　　其实这个问题不用多说，程序员都知道，简单总结为一句话：就是为了增强程序健壮性呗，比如下面的代码：

Class DenominatorZeroException extends Exception{}

public double division(int numerator,int denominator) throws DenominatorZeroException
{
    double result;
    try
    {
        if(denominator == 0)
            throw new DenominatorZeroException();
        else
            result = numerator/denominator;
    }
    catch(DenominatorZeroException e)
    {
        e.printStackTrace();
        return -1;
    }

    return result;
}

这段代码很简单，就是为了预防除法中发生分母为0的情况，为了增强代码的健壮性，我声明了一个自定义的异常名为：DenominatorZeroException，这个异常继承自所有异常的根类Exception，当代码发现分母为0的时候就将new一个异常然后跑出，当catch捕捉到这个异常后，则返回一个预先定义好的标志-1；否则正常返回除法结果。

　　其实在Java语言中，按照我自己看书和平时编程的理解，异常的作用可以概括为以下两点：

1. 增强程序健壮性。当遇到异常（为什么叫异常而不是错误，就是说在当前编程环境下，出现这种情况很奇怪，不正常，无法解决）我们可以捕获它，然后有两种选择：一是就像上面的代码一样，我们知道异常的原因，然后进行相应的处理，这样并不会影响程序的正常执行；二是我们并不知道捕获这个异常该怎么处理，我们就可以利用Java的异常链可以将这个异常抛给上一级代码或者直接抛给控制台（就像上面的代码e.printStackTrace()打印出栈轨迹或者利用异常说明加在主函数入口处）。
2. 报告。Java程序员可能会发现当我们程序遇到bug停止的时候，所有报告的错误信息都是以异常的形式产生的，这样统一的形式使得程序员在编写程序时不必考虑如果程序运行出错怎么办，Java会做好的，出错会向你报告而且绝对不会遗漏（除了异常“吞咽”，稍后说明），程序员就可以专心设计和实现自己的代码了。

• throw关键字

　　我们要将一个异常跑出就需要throw关键字，其实在某种程度上，我们可以将throw和return进行一个类比，因为当我们使用throw抛出异常时就会跳出当前的方法或者作用域，这与return是非常相似的。但是一定不能混淆，因为return关键字返回的“地点”一般就是主调函数处然而throw抛出异常，而捕获异常的这个“地点”可能距离现有函数的地址很远。

Class DenominatorZeroException extends Exception{}
Class AnotherException extends Exception
{
    public AnotherException(String s){super(s);}
}

public double division(int numerator,int denominator) throws DenominatorZeroException, AnotherException
{
    double result;
    try
    {
        if(denominator == 0)
            throw new DenominatorZeroException();
        else
            result = numerator/denominator;
    }
    catch(DenominatorZeroException e)
    {
        throw e;
        /*或者*/
        throw new RuntimeException(e);
        /*或者*/
        AnotherException ae = new AnotherException("from division");
        ae.initCause(new DenominatorZeroException());
        throw ae;
    }

    return result;
}

还是上面除法的例子，我想做点说明：

1. 当我们在catch中捕获到一个异常不知道怎么处理时，可以利用throw直接再将这个异常抛出；
2. 同样我们也可以直接将这个异常抛给RuntimeException，让它直接抛出运行时异常（就是现实在控制台的错误信息）；
3. 然而上面两种方式有一个问题就是当我们再次抛出异常时，我们最一开始发生异常的位置就会丢失，所以我们利用initCause将原先的异常加入，并且在异常信息中也添加了"from division"
4. 解释异常“吞噬”，就是捕获了异常什么都不做，也不抛出，那么这样很危险，因为找不到错误信息了。

• 异常说明throws

　　我们在调用Java的库函数的时候肯定会遇到这种情况（尤其是IO操作的地方）：就是调用了一个函数，然后编译器报错，给出的解决方案是要么加入try,catch块，要么就在主调函数的后面加上throws，并且后面跟上可能抛出的异常。这里后者就是所谓的异常说明。

　　为什么要有异常说明：这主要是编写类的程序员要将方法可能会抛出的异常告知客户端程序员。

　　格式：方法名() throws 所有潜在异常类型列表

　   异常说明将Java中的异常分为了两类，一类是被检查的异常，即Exception及所有继承自它的异常；另一类是不受检查的异常，即RuntimeException，即运行时异常。怎么理解呢？

　　说白了就是，被检查的异常只要你在函数中要用到throw抛出异常或者说你调用的函数利用了throw抛出了异常，那么你就必须在函数后面加上throws关键字并在后面列出所有可能抛出的异常；而不受检查的异常就是你抛出它的时候不用做特别说明，就像上面除法的例子一样。

　　这种自顶向下的约束，可以保证Java代码一定水平的异常正确性。但是这里是有争议的，有些人认为这样好，但有些人认为这样会影响程序员的编程效率，因为有时候你根本就不知道你捕捉的是什么异常，也不知道该怎么处理，但是编译器会强制要求你加上这些模块。

• finally关键字

　　finally关键字常用数据库的哥们肯定懂，一般我们在finally里要关闭数据库连接或者做一些清理工作。关于finally我想说两点有趣的事情：

　　一、保证完成任务

　　为什么这么说finally关键字呢，就是因为无论在try语句中执行了什么命令，finally中的语句块一定会执行（这就确保了有些必要的清理工作），如：

public class MultipleReturns
{
    public static void f(int i)
    {
        System.out.println("Initialization that requires cleanup");

        try
        {
            System.out.println("Point 1");
            if (i == 1)
                return;
            System.out.println("Point 2");
            if (i == 2)
                return;
            System.out.println("Point 3");
            if (i == 3)
                return;
            System.out.println("End");
            return;
        }
        finally
        {
            System.out.println("Performing cleanup");
        }
    }

    public static void main(String[] args)
    {
        for (int i = 1; i <= 4; i++)
            f(i);
    }
}

大家执行这段代码会惊奇的发现，即使try中代码调用了return命令但是finally也一定会执行。

　　二、嵌套try

public class Cleanup
        {
            public static void main(String[] args)
            {
                try
                {
                    InputFile in = new InputFile("Cleanup.java");
                    try
                    {
                        String s;
                        int i = 1;
                        while ((s = in.getLine()) != null)
                            ; // Perform line-by-line processing here...
                    }
                    catch (Exception e)
                    {
                        System.out.println("Caught Exception in main");
                        e.printStackTrace(System.out);
                    }
                    finally
                    {
                        in.dispose();//自定义
                    }
                }
                catch (Exception e)
                {
                    System.out.println("InputFile construction failed");
                }
            }
        } /*
         * Output: dispose() successful
         */// :~

对于这个例子，我们看出我们要创建InputFile对象，当我们成功创建它时需要用dispose方法对其进行清理，然而如果失败时我们并不需要对其进行清理。倘若只有一个不使用嵌套try块，那么不管怎样finally都会执行。所以为了避免这种情况，上面的嵌套try语句就起到了作用。

• 总结

　　异常机制是我们在写代码时常用到的，在利用异常机制时，没必要搞得过于复杂，如果捕获到一个异常进行简单处理，或者没办法直接将其抛出给上一级代码都可以。另外补充一点关于声明自己的异常就是，其实打开Java源码会发现，不同的异常之间差别并不大，主要就是在名字上的差异，所以当我们声明自己的异常去抛出时，没必要过于复杂，关键是起一个好名字，让别的程序员一看就明白出了什么问题。

以上仅仅是自己看书和平时编程的体会，如果有不妥之处还请指出。