【Java】try中有return，finally还会执行吗？

Yumannn

已于 2024-04-06 23:47:19 修改

阅读量852

点赞数 23

分类专栏： Java学习之旅文章标签： java 开发语言后端

于 2024-04-06 11:23:29 首次发布

本文链接：https://blog.csdn.net/weixin_42968289/article/details/137413108

版权

Java学习之旅专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的异常处理机制，包括try...catch用于捕获异常，finally确保必要代码执行，以及return在try、catch和finally中的行为。特别强调了被屏蔽异常(SuppressedException)的概念以及如何处理返回值和异常传播。

摘要由CSDN通过智能技术生成

前言

Java内置了一套异常处理机制，在Java中异常是一种class，可以在任何地方抛出，但只需要在上层捕获，这样就和方法调用分离了。

1. 用try…catch捕获异常

捕获异常时通常使用try...catch语句，把可能发生异常的代码放到try {...}中，然后使用catch捕获对应的Exception及其子类。

public class Main {
    public static void main(String[] args) {
        String info = "error";
    	try {
    		getException(info);
    	} catch (Exception e) {
    		e.printStackTrace();
    	}
    }

    private static void getException(String info) throws CoreRuntimeException{
    	if ("error".equals(info)) {
    		throw new CoreRuntimeException();
    	}
    }
}

2. finally语句

无论是否有异常发生，如果我们都希望执行一些语句，例如清理工作，可以把正常执行的语句放到try中，总是会执行的语句放到finally中。

public class Main {
    public static void main(String[] args) {
	    try {
	    	System.out.println("Strart");
	        process();
	    } catch (IOException e) {
	        System.out.println("IO error");
	    } catch (Exception e) {
	        System.out.println("IO error");
	    } finally {
	    	System.out.println("END");
	    }
	}
	static void process() {
		//正常执行的语句
	}
}

上述代码无论是否发生异常，都会执行System.out.println("END");这条语句。

注意finally有几个特点：

finally语句不是必须的，可写可不写；
finally总是最后执行。

如果没有发生异常，就正常执行try { ... }语句块，然后执行finally。如果发生了异常，就中断执行try { ... }语句块，然后跳转执行匹配的catch语句块，最后执行finally。

可见，finally是用来保证一些代码必须执行的。

3. try、catch、finally中同时存在return语句

那如果 try、catch、finally中同时存在return语句，方法到底该返回什么值呢？看看下面几段代码：

情况一：try正常执行，try、finally中都有return

public class TestReturn {
	public static void main(String[] args) {
		int result = getResult01();
		System.out.println(result);
	}

	public static int getResult01() {
		int result;
		try {
			result = 10 / 1;
			return result;
		} catch (Exception e) {
			result = 20;
			return result;
		} finally {
			result = 30;
			return result;
		}
	}
}

程序执行结果：
程序一运行结果
可见，就算try中有return且未抛出异常，但finally中的语句依旧会被执行。

情况二：try抛出异常，catch、finally中都有return

public class TestReturn {
	public static void main(String[] args) {
		int result = getResult01();
		System.out.println(result);
	}

	public static int getResult01() {
		int result;
		try {
			result = 10 / 0;
			return result;
		} catch (Exception e) {
			result = 20;
			return result;
		} finally {
			result = 30;
			return result;
		}
	}
}

程序执行结果：
程序二运行结果
可见，就算try中抛出异常，且catch中有return，但finally中的语句依旧会被执行。

结合前两种情况，可以判断，无论try或catch中是否有return，finally都一定会执行。

情况三：finally中无return，但改变了result值

public class TestReturn {
	public static void main(String[] args) {
		int result = getResult01();
		System.out.println(result);
	}

	public static int getResult01() {
		int result;
		try {
			result = 10 / 1;
			return result;
		} catch (Exception e) {
			result = 20;
			return result;
		} finally {
			result = 30;
		}
	}
}

程序运行结果：
程序三运行结果
可见，try中有return, 会先将值暂存，无论finally语句中对该值做什么处理，最终返回的都是try语句中的暂存值。

情况四：finally中有return，但不改变result值

public class TestReturn{
    public static void main(String[] args){
        System.out.print(getNumber(0));
        System.out.print(getNumber(1));
        System.out.print(getNumber(2));
        System.out.print(getNumber(4));
    }

    public static int getNumber(int num){
        try{
            int result = 2 / num;
            return result;
        }catch (Exception exception){
            return 0;
        }finally{
            if(num == 0){
                return -1;
            }
            if(num == 1){
                return 1;
            }
        }
    }    
}

程序运行结果：
程序四运行结果
可见，当try与finally语句中均有return语句，会忽略try中的return，即最终方法返回的是finally对应的return内容。

4. 被屏蔽的异常

如果在执行finally语句时抛出异常，那么原来在catch中准备抛出的异常就“消失”了，因为只能抛出一个异常。没有被抛出的异常称为“被屏蔽”的异常（Suppressed Exception）。

如何保存所有的异常信息？方法是先用origin变量保存原始异常，然后调用Throwable.addSuppressed()，把原始异常添加进来，最后在finally抛出：

public class Main {
    public static void main(String[] args) throws Exception {
        Exception origin = null;
        try {
            System.out.println(Integer.parseInt("abc"));
        } catch (Exception e) {
            origin = e;
            throw e;
        } finally {
            Exception e = new IllegalArgumentException();
            if (origin != null) {
                e.addSuppressed(origin);
            }
            throw e;
        }
    }
}