i++底层问题

大家都知道i++在做运算的时候，是先赋值再自加1，但底层究竟是怎样实现的呢？下面，就三个例子来说明一下i++的底层实现原理。

第一个例子：

[java] view plain copy

1. public class Test1{  
2.   
3.     public static void main(String [] args){  
4.       
5.         int i = 10;  
6.   
7.         i = i++;  
8.   
9.         System.out.println(i);  
10.     }  
11. }  

程序输出为10。

因为i++在作计算的时候要引入一个临时的变量，底层是这样实现的：

[java] view plain copy

1. _temp = i;  
2.   
3. i = i + 1;  
4.   
5. i = _temp;  

先把i的值赋给一个临时变量_temp，然后再作自加1的操作，最后又把临时变量_temp的值赋给了i，看到这里有点迷糊了吧。

如果换一种写法，int j = i++，自己就能够看懂了，底层也就是这样实现的：

[java] view plain copy

1. _temp = i;  
2.   
3. i = i + 1;  
4.   
5. j = _temp;  

所以，无论是哪种情况，最后打印出的结果都是10。

第二个例子：

[java] view plain copy

1. public class Test2{  
2.   
3.     public static void main(String[] args) {  
4.           
5.         int i = 0;  
6.           
7.         int sum = (i++)+(i++);  
8.           
9.         System.out.println(sum);  
10.     }  
11. }  

程序输出结果为1。

这个题参考第一个例子，可以这么理解：

假设有一个变量m接收第一个i++的计算结果，那么m的值一定是0，而底层i的值变成了1

再假设又有一个变量n接收第二个i++的计算结果，由于底层i的值变成了1，所以n的值是1，

那么，计算过程就变成了m+n，等于1。

第三个例子：

[java] view plain copy

1. public class Test3{  
2.   
3.     public static int test(){  
4.       
5.         int i = 0;  
6.   
7.         try{  
8.           
9.             return i++;  
10.           
11.         }finally{  
12.               
13.             i++;      
14.         }  
15.     }     
16.   
17.     public static void main(String [] args){  
18.       
19.         int j = test();  
20.   
21.         System.out.println(j);  
22.     }  
23. }  

程序打印出j的值是0。

无论什么时候，只要是有finally语句块，就一定会执行的，所以底层i的值是2。

假设有一个变量s接收try语句块中i++的值，s为0，return s，所以j的值是0。

这道题可以改一下，finally语句块中的语句改为return i++，结果是什么。

结果j的值是1，因为最后的返回结果不是try语句块中的结果，而是finally语句块中结果。

执行try语句块中的语句，i的值变成了1，所以finally语句块中的语句结果是1，底层i的值是2。

再改一下，finally语句块中的语句为return ++i，结果是什么。

结果j的值是2，因为最后finally语句块中的语句是i自加1之后，再return的。

所以finally语句块中返回的是2，底层i的值是2。