根据java语法finally是总会执行的
在如下程序中为什么输出结果是4呢？
finally代码块中a++后应该是 a = 5,不解？

1. public static void main(String[] args) {
   
2.                 int a = 3;
   
3.                 try{
   
4.                         a++;
   
5.                         System.out.println(a);//为什么a输出是4呢？
   
6.                 }
   
7.                 finally{
   
8.                         a ++;
   
9.                 }
   
10.                
    
11.         }

复制代码

哎...你这个代码有异常么?没有异常就按顺序执行啊,难不行程序正确,你try{} finally{}后,还能搞出个异常来不成.
try{}的目的只是为了测试这{}内的程序有没有异常,如果有.就catth(){},没有就正常执行罗

1. public static void main(String[] args) {
   
2.                 int a = 3;
   
3.                 try{
   
4.                         a++;//程序是从上至下按顺序执行的，运行到此处,a=4
   
5.                         System.out.println(a);//运行到此处自然打印4
   
6.                 }
   
7.                 finally{//接着运行到下面，那么a就是5了，它没有回头去执行，程序执行遵循从上至下，finally的确是最后必须执行的，但是以上的输出语句已经执行过了
   
8.                         a ++;
   
9.                 }
   
10.                
    
11.         }

复制代码

1. package com.itheima.day01;
   
2. 
   
3. public class test {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.                 int a = 3;
    
11.                 try
    
12.                 {
    
13.                         a++;
    
14.                         System.out.println("第一步");
    
15.                         System.out.println(a);
    
16.                 }
    
17.                 finally
    
18.                 {
    
19.                         System.out.println("第二步");
    
20.                         a++;
    
21.                         System.out.println("第三部");
    
22.                 }
    
23.         }
    
24. 
    
25. }
    

复制代码

运行结果是:
第一步
4
第二步
第三部

你就可以看出这个是从上往下执行. .

try{} finally{}是处理代异常的代码?
没有异常就按顺序执行

异常处理语法：
try{｝代码块是捕获异常
catch（异常类 变量）{}抛出异常,
finally｛｝一定户处理的代码
如果没有检测异常就按顺序执行
  记住张老师一句经典的话，代码出现问题是，多找找人自身的原因！

1. public static void main(String[] args) {
   
2.                 int a = 3;
   
3.                 try{
   
4.                         a++;             //这地方没有抛出异常，程序自然继续执行，所以下面的输出a的值为4
   
5.                         System.out.println(a);//为什么a输出是4呢？
   
6.                 }
   
7.                 finally{
   
8.                         a ++;
   
9.                 }
   
10.                
    
11.         }

复制代码

finally{}是一定要执行的，也最后才执行的
而你的输出语句是在finally前面执行的，所以就是4了

代码是这样的，刚才代码有点问题

1. public static void main(String[] args) {
   
2.                 System.out.println(method());//输出4
   
3.         }
   
4.         public static int method(){
   
5.                         int a = 3;
   
6.                 try{
   
7.                         a++;
   
8.                         return a;
   
9.                 }
   
10.                 finally{
    
11.                         a ++;
    
12.                 }
    
13.                        
    
14.         }

复制代码

这是一道面试题，原理涉及到底层，看了解释还是不怎么明白，debug调试，return 是在finally代码块执行完后才执行的，或者有人说是同步执行的，搞不清楚

return是在finally之后执行的，finally块中的a也确实变成了5
但是，return 返回的值是在finally之前就确定了，相当于把a复制了一份给了return，而后不管finally怎样改变a
return返回的a的值是不会再变的。

恩，try 执行，木有异常，输出4，然后执行finally  值变成5。

1. <blockquote><span class="Apple-tab-span" style="white-space:pre">        </span>public static void main(String[] args) {

复制代码

try
{
        需要被检测的代码；
}
catch(异常类 变量)
{
        处理异常的代码；(处理方式)
}
finally
{
        一定会执行的语句；
}

finally中无法改变try块中的变量

finally是一定会执行的，但并非是最后执行的：
1、当程序执行到try语句中最后一句时，转去执行finally语句，然而再返回执行try中最后语句；
2、在内存中程序是顺序执行，执行的时候是没法知道自已执到哪一行，肯定是编译器在编译的
时候在最后一句语句的代码前插入了一个跳转指令，好让程序跳转到finally块中执行,然后编译器
还会在finally块中加一些代码，好让finally中的语句不改变 变量的值，执行完后再返回执行最后一个语句;
其实这是java中通常用于回收资源的一种机制
下面是测试代码：
package test1;
public class FinallyTest {
public static void main(String[] args) {
        
  int i=0;
  //调用函数并打印返回结果
        System.out.println(funtion(i));
        try{
            i = 20;
          //打印执行效果
            System.out.println(i);
         }
         finally{
          i = 200;
          //打印执行效果
            System.out.println("finally2:"+i);
         }
        
}
public static int funtion(int i){
        try{
           i = 10;
           return i;
           
        }
        finally{
         i = 100;
         //打印执行效果
            System.out.println("finally:"+i);
        }
}
}
打印结果：
finally:100
10
20
finally2:200

public static void main(String[] args) {

                int a = 3;

                try{

                        a++;

                        System.out.println(a);//为什么a输出是4呢？     因为自加一次了

                }

                finally{

                        a ++;

                }

               
        }

try{}catch()块使用来捕获异常用的，一般将有问题部分放到try里面哈，fianlly表示总是执行