java-基础-try、catch和finally

简介: 1、try块中没有抛出异常,try、catch和finally块中都有return语句 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ...

1、try块中没有抛出异常,try、catch和finally块中都有return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public  static  int  NoException(){
          int  i= 10 ;
          try {
            System.out.println( "i in try block is:" +i);
            return  --i;
          }
          catch (Exception e){
            --i;
            System.out.println( "i in catch - form try block is:" +i);
            return  --i;
          }
          finally {     
            System.out.println( "i in finally - from try or catch block is:" +i);
            return  --i;
          }  
}

运行代码:

1
2
3
4
5
public  static  void  main( String [] args) {
         System.out.println( "=============NoException==================" );
         System.out.println(NoException());
         System.out.println( "===============================" );   
}

运行结果:

1
2
3
4
5
=============NoException==================
in  try  block  is 10
in  finally  - from  try  or  catch  block  is 9
8
===============================


执行顺序:

   执行try块,执行到return语句时,先执行return的语句,--i,但是不返回到main方法,执行finally块,遇到finally块中的return语句,执行--i,并将值返回到main方法,这里就不会再回去返回try块中计算得到的值。

结论:try-catch-finally都有return语句时,没有异常时,返回值是finally中的return返回的。


2.try块中没有抛出异常,仅try和catch中有return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public  static  int  NoException1(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is:" +i);
                 return  --i;
             }
             catch (Exception e){
                 --i;
                 System.out.println( "i in catch - form try block is:" +i);
                 return  --i;
             }
             finally {           
                 System.out.println( "i in finally - from try or catch block is:" +i);
                 --i;
                 System.out.println( "i in finally block is:" +i);
                 //return --i;
             }
}

运行结果:

1
2
3
4
5
6
=============NoException1==================
in  try  block  is 10
in  finally  - from  try  or  catch  block  is 9
in  finally  block  is 8
9
===============================

执行顺序:

   try中执行完return的语句后,不返回,执行finally块,finally块执行结束后,返回到try块中,返回i在try块中最后的值。

结论:try-catch都有return语句时,没有异常时,返回值是try中的return返回的。


3.try块中抛出异常,try、catch和finally中都有return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public  static  int  WithException(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is:" +i);
                 i = i/ 0 ;
                 return  --i;
             }
             catch (Exception e){
                 System.out.println( "i in catch - form try block is:" +i);
                 --i;
                 System.out.println( "i in catch block is:" +i);
                 return  --i;
             }
             finally {           
                 System.out.println( "i in finally - from try or catch block is--" +i);
                 --i;
                 System.out.println( "i in finally block is--" +i);
                 return  --i;
             }
}

执行结果:

1
2
3
4
5
6
7
8
=============WithException==================
in  try  block  is 10
in  catch  - form  try  block  is 10
in  catch  block  is 9
in  finally  - from  try  or  catch  block  is -- 8
in  finally  block  is -- 7
6
===============================

执行顺序:

   抛出异常后,执行catch块,在catch块的return的--i执行完后,并不直接返回而是执行finally,因finally中有return语句,所以,执行,返回结果6。

结论:

   try块中抛出异常,try、catch和finally中都有return语句,返回值是finally中的return。


4.try块中抛出异常,try和catch中都有return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public  static  int  WithException1(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is:" +i);
                 i=i/ 0 ;
                 return  --i;
             } catch (Exception e){
                 System.out.println( "i in catch - form try block is:" +i);           
                 return  --i;
             } finally {
                                                                                                                                                                      
                 System.out.println( "i in finally - from try or catch block is:" +i);
                 --i;
                 System.out.println( "i in finally block is:" +i);
                 //return i;
             }
}

执行结果:

1
2
3
4
5
6
7
=============WithException1==================
in  try  block  is 10
in  catch  - form  try  block  is 10
in  finally  - from  try  or  catch  block  is 9
in  finally  block  is 8
9
===============================

执行顺序:

   抛出异常后,执行catch块,执行完finally语句后,依旧返回catch中的执行return语句后的值,而不是finally中修改的值。

结论:

   返回的catch中return值。


5.try、catch中都出现异常,在finally中有返回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public  static  int  WithException2(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is:" +i);
                 i=i/ 0 ;
                 return  --i;
             }
             catch (Exception e){
                 System.out.println( "i in catch - form try block is:" +i);
                 int  j = i/ 0 ;
                 return  --i;
             }
             finally {
                                                                                       
                 System.out.println( "i in finally - from try or catch block is:" +i);
                 --i;
                 --i;
                 System.out.println( "i in finally block is:" +i);
                 return  --i;
}

执行结果:

1
2
3
4
5
6
7
=============WithException2==================
in  try block  is :10
in  catch - form try block  is :10
in  finally -  from  try  or  catch block  is :10
in  finally block  is :8
7
===============================

执行顺序:   

   try块中出现异常到catch,catch中出现异常到finally,finally中执行到return语句返回,不检查异常。

结论:

   返回finally中return值。


6、只在函数最后出现return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public  static  int  WithException3(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is:" +i);
                 i=i/ 0 ;
                 //return --i;
             }
             catch (Exception e){
                 System.out.println( "i in catch - form try block is:" +i);
                 //int j = i/0;
                 //return --i;
             }
             finally {
                                                                          
                 System.out.println( "i in finally - from try or catch block is:" +i);
                 --i;
                 --i;
                 System.out.println( "i in finally block is:" +i);
                 //return --i;
             }
             return  --i;
}

执行结果:

1
2
3
4
5
6
7
=============WithException3==================
in  try  block  is 10
in  catch  - form  try  block  is 10
in  finally  - from  try  or  catch  block  is 10
in  finally  block  is 8
7
===============================


总体结论:

结论一:

   return语句并不是函数的最终出口,如果有finally语句,这在return之后还会执行finally(return的值会暂存在栈里面,等待finally执行后再返回)
结论二:

   finally里面不建议放return语句,根据需要,return语句可以放在try和catch里面和函数的最后。可行的做法有四:
   (1)return语句只在函数最后出现一次
   (2)return语句仅在try和catch里面都出现。
   (3)return语句仅在try和函数的最后都出现。
   (4)return语句仅在catch和函数的最后都出现。
   注意,除此之外的其他做法都是不可行的,编译器会报错。

目录
相关文章
|
1月前
|
Java 编译器 开发者
Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面
本文探讨了Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面,帮助开发者提高代码质量和程序的健壮性。
50 2
|
2月前
|
存储 缓存 Java
java基础:IO流 理论与代码示例(详解、idea设置统一utf-8编码问题)
这篇文章详细介绍了Java中的IO流,包括字符与字节的概念、编码格式、File类的使用、IO流的分类和原理,以及通过代码示例展示了各种流的应用,如节点流、处理流、缓存流、转换流、对象流和随机访问文件流。同时,还探讨了IDEA中设置项目编码格式的方法,以及如何处理序列化和反序列化问题。
86 1
java基础:IO流 理论与代码示例(详解、idea设置统一utf-8编码问题)
|
2月前
|
存储 Java
[Java]面试官:你对异常处理了解多少,例如,finally中可以有return吗?
本文介绍了Java中`try...catch...finally`语句的使用细节及返回值问题,并探讨了JDK1.7引入的`try...with...resources`新特性,强调了异常处理机制及资源自动关闭的优势。
25 1
|
6月前
|
Java
【Java基础】输入输出流(IO流)
Java基础、输入输出流、IO流、流的概念、输入输出流的类层次结构图、使用 InputStream 和 OutputStream流类、使用 Reader 和 Writer 流类
181 2
|
3月前
|
安全 Java API
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)
String常量池、String、StringBuffer、Stringbuilder有什么区别、List与Set的区别、ArrayList和LinkedList的区别、HashMap底层原理、ConcurrentHashMap、HashMap和Hashtable的区别、泛型擦除、ABA问题、IO多路复用、BIO、NIO、O、异常处理机制、反射
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)
|
2月前
|
缓存 安全 Java
Java中 final、finally、finalize 有什么区别?
本文详细阐述了Java中`final`、`finally`和`finalize`的区别:`final`用于修饰类、方法和变量以表示不可变性;`finally`是用于确保在`try-catch`结构中无论是否发生异常都能执行的代码块;而`finalize`是`Object`类的方法,用于在对象被垃圾回收前执行清理工作,但在JDK 9中已被标记为弃用。
40 0
Java中 final、finally、finalize 有什么区别?
|
7月前
|
Java API
【JAVA】final、finally、finalize 有什么区别?
【JAVA】final、finally、finalize 有什么区别?
|
4月前
|
Java
【Java基础面试三十九】、 finally是无条件执行的吗?
这篇文章解释了Java中的finally块的特性,即无论是否发生异常或执行了return语句,finally块都会无条件执行,除非使用System.exit()退出虚拟机。
|
4月前
|
Java
【Java基础面试四十】、在finally中return会发生什么?
文章讨论了在Java中finally块中使用return语句的问题,指出如果在finally块中使用return或throw语句,将导致try块或catch块中的相应语句失效,因为finally块中的return或throw会终止方法,之后系统不会再执行try或catch块中的代码。
|
6月前
|
安全 Java