Java学习笔记-《Java程序员面试宝典》-第四章基础知识-4.6异常处理(4.6.1-4.6.3)

最新推荐文章于 2024-10-10 23:42:47 发布

LiReader

最新推荐文章于 2024-10-10 23:42:47 发布

阅读量281

点赞数

文章标签： java 函数异常处理程序员面试

本文链接：https://blog.csdn.net/qq_28814687/article/details/73534003

版权

异常处理机制详解参见博客： http://www.cnblogs.com/hy928302776/archive/2013/04/22/3035504.html

4.6.1finally块中的代码什么时候被执行

问题描述：try{}里有一个return语句，那么紧跟在这个try后的finally{}中的代码是否会被执行？如果会的话，什么时候被执行，在return之前还是return之后？
在Java语句的异常处理中，finally块的作用就是为了保证无论出现什么情况，finally块里的代码一定会被执行。由于程序执行return就意味着结束对当前函数的调用并跳出这个函数体，因此任何语句要执行都只能在return之前执行(除非碰到exit函数)，因此finally块里的代码也是在return之前执行的。此外，如果try-finally或者catch-finally中都有return，那么finally块中的return语句将会覆盖别处的return语句，最终返回到调用者那里的是finally中的return的值。如下代码所示：

public class TestFinally {

    public static int testFinally(){

        try{

            return 1;
        }catch(Exception e){
            return 0;
        }finally{
            System.out.println("execute finally");
        }

    }

    public static void main(String[] args){

        int result = testFinally();
        System.out.println(result);


    }
}

运行结果：
execute finally
1

从上面的例子可以看出，在执行return语句之前确实执行了finally块中的代码。紧接着，在finally块里面放置return语句，例子如下所示：

public class TestFinally {

    @SuppressWarnings("finally")
    public static int testFinally(){

        try{

            return 1;
        }catch(Exception e){
            return 0;
        }finally{
            System.out.println("execute finally");
            return 3;
        }

    }

    public static void main(String[] args){

        int result = testFinally();
        System.out.println(result);


    }
}

运行结果：
execute finally
3

从以上结果可以看出，当finally块中有return语句时，将会覆盖函数中其他return语句。此外，由于在一个方法内部定义的变量都存储在栈中，当这个函数结束后，其对应的栈就会被回收，此时在其方法体内部的变量就不存在了，因此return在返回时不是直接返回变量的值，而是复制一份，然后再返回。因此，对于基本的数据，在finally块中改变return的值对返回值没有任何影响，而对引用类型的数据会有影响。示例如下：

public class TestFinally {

    public static int testFinally1(){

        int result = 1;
        try{
            result = 2;
            return result;
        }catch(Exception e){
            return 0;
        }finally{
            result = 3;
            System.out.println("execute finally1");
        }

    }

    public static StringBuffer testFinally2(){

        StringBuffer s = new StringBuffer("Hello");
        try{
            return s;
        }catch(Exception e){
            return null;
        }finally{
            s.append(" World");
            System.out.println("execute testFinally2");
        }
    }
    public static void main(String[] args){

        int resultVal = testFinally1();
        System.out.println(resultVal);

        StringBuffer resultStr = testFinally2();
        System.out.println(resultStr);

    }
}

运行结果：
execute finally1
2
execute testFinally2
Hello World

程序在执行到return时会首先将返回值存储在一个特定的位置，其次再去执行finally块，最后再返回。在方法testFinally1中调用return前，先把result的值1存储在一个指定的位置，然后再去执行finally块中的代码，此时修改result的值，因为基本类型都是不可变类，所以并不会影响到程序的返回结果。在testFinally2中，在调用return前首先把s存储到一个指定的位置，由于s是引用类型，因此在finally块中修改s将会修改程序的返回结果。
引申：出现在Java程序中的finally块是不是一定会被执行？
答：不一定。有两种情况下finally代码块不会被执行。1>当程序进入try语句块之前就出现异常时，会直接结束，不会执行finally块中的代码，示例如下：

public class TestFinally {

    public static void testNotExecute(){
        int i=5/0;
        try{
            System.out.println("try block");
        }catch(Exception e){
            System.out.println("catch block");
        }finally{
            System.out.println("finally block");
        }
    }

    public static void main(String[] args){

        testNotExecute();
    }
}

运行结果：
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at TestFinally.testNotExecute(TestFinally.java:6)
    at TestFinally.main(TestFinally.java:18)

程序在执行int i=5/0时抛出异常，导致没有执行try块，因此finally块也就不会执行。
2>当程序在try块中强制退出时，也不会去执行finall块中的代码。示例如下：

public class TestFinally {

    public static void testNotExecute(){
        try{
            System.out.println("try block");
            System.exit(0);
        }catch(Exception e){
            System.out.println("catch block");
        }finally{
            System.out.println("finally block");
        }
    }

    public static void main(String[] args){

        testNotExecute();
    }
}

运行结果：
try block

上例在try块中通过调用System.exit(0)强制退出了程序，因此导致finally块中的代码没有被执行。

4.6.2异常处理的原理是什么

异常是指程序运行时(非编译时)所发生的非正常情况或错误，当程序违反了语义规则时，JVM就会将出现的错误表示为一个异常并抛出。这个异常可以在catch程序块中进行捕获，然后进行处理。而异常处理的目的则是为了提高程序的安全性和鲁棒性。
Java语言把异常当做对象来处理，并定义了一个基类(java.lang.Throeable)作为所有异常的父亲。在Java API中，已经定义了许多异常类，这些异常类分为Error(错误)和Exception(异常)两大类。
违反语义规则包含两种情况：一种是Java类库内置的语义检查，例如当数组下标越界时，会引发IndexOutOfBoundsException，当访问null对象时，会引发NullPointerException;另一种情况是Java允许开发人员扩展这种语义检查，开发人员可以创建自己的异常类(所有异常都是Java.lang.Throwable的子类)，并自由选择在何时用throw关键字抛出异常。

4.6.3运行时异常和普通异常有什么区别

Java提供了两种错误的异常类，分别为Error和Exception，且他们拥有共同的父类-Throwable。
Error表示程序在运行期间出现了非常严重的错误，并且该错误是不可恢复的，由于这属于JVM层次的严重错误，因此这种错误是会导致程序终止执行的。此外，编译器不会检查Error是否被处理，因此在程序中不推荐去捕获Error类型的异常，主要原因是运行时异常多是由于逻辑错误导致的，属于应该解决的错误，也就是说，一个正确的程序中是不应该存在Error的。OutOfMemoryError、ThreadDeath等都属于错误，当这些异常发生时，JVM一般会选择将线程终止。
Exception表示可恢复的异常，是编译器可以捕捉到的，它包含两种类型：检查异常(checked exception)和运行时异常(runtime exception)。
1>检查异常
检查异常是在程序中经常碰到的异常。所有继承自Exception并且不是运行时异常的异常都是检查异常，比如常见的IO异常和SQL异常。这种异常都发生在编译阶段，Java编译器强制程序去捕获此类型的异常，即把可能会出现的这些异常的代码都放到try块中，把对异常的处理的代码放到catch块中，这种异常一般在如下几种情况使用：
1）异常的发生并不会导致程序出错，进行处理后可以继续执行后续的操作，例如，当连接数据库失败后，可以重新连接后进行后续操作。
2)程序依赖于不可靠的外部条件，例如系统IO。
2>运行时异常
对于运行时异常，编译器没有强制对其进行捕获并处理。如果不对这种异常进行处理，当出现这种异常时，会由JVM来处理，例如NullPointerException异常，他就是运行时异常。在Java语言中，最常见的运行时异常包括NullPointerException、ClassCastException、ArrayIndexOutOfBoundsException、ArrayStoreException、BufferOverflowException、ArithmeticException等。
出现运行时异常后，系统会把异常一直往上层抛出，直到遇到处理代码为止。若没有处理块，则抛到最上层；如果是多线程就用Thread.run()方法抛出，如果是单线程，就用main()方法抛出。抛出之后，如果是线程，那么这个线程也就退出了。如果是主程序抛出的异常，那么这个程序也就退出了。所以，如果不对运行时额异常进行处理，后果是非常严重的，一旦发生，要么线程中止，要么主程序中止。
在使用异常处理时，还要注意以下几个问题：
1>Java异常处理用到了多态的概念，如果在异常处理过程中，先捕获了基类，然后再捕获子类，那么捕获子类的代码块将永远不会被执行。因此，在进行异常捕获时，正确的写法是：先捕获子类，再捕获基类的异常信息。
2>尽早抛出异常，同时对捕获的异常进行处理，或者从错误中恢复，或者让程序继续执行。对捕获的异常不进行任何处理是一个非常不好的习惯，这将非常不利于调试，但也不是抛出异常越多越好，对于有些异常类型，例如运行时异常，十几场根本不必处理。
3>可以根据实际的需求自定义异常类，这些自定义的异常类只要继承自Exception类即可。
4>异常能处理就处理，不能处理就抛出异常。对于一般的异常，如果不能进行行之有效的处理，最好转换为运行时异常抛出，对于最终没有处理的异常，JVM会进行处理。