大家看下面的两段代码，微小的差别，但结果截然相反，跪求真相，跪求解释！！！！！

1、使用反射改变传入change方法的对象的final String str成员，我们在声明str时就给str赋值为"ABC"：str没被改变仍为"ABC"

1. import java.lang.reflect.Field;
   
2. 
   
3. 
   
4. public class ReflectTest {
   
5.         private final  String str="ABC";//声明时赋值
   
6.        
   
7. 
   
8.         /**
   
9.          * @param args
   
10.          * @throws Exception
    
11.          */
    
12.         public static void main(String[] args) throws Exception {
    
13.                 // TODO Auto-generated method stub
    
14.                 ReflectTest rt=new ReflectTest();
    
15.                
    
16.                 System.out.println("---打印改变前的str字符串的值---");
    
17.                 System.out.println(rt.str);//打印出来ABC
    
18.                
    
19.                 rt.change(rt);
    
20.                
    
21.                 System.out.println("---打印改变后的str字符串的值---");
    
22.                 System.out.println(rt.str);//打印出来是ABC
    
23.         }
    
24.        
    
25.        
    
26.         /**
    
27.          * 试图改变obj对象里的的字符串成员
    
28.          * @param obj
    
29.          * @throws Exception
    
30.          */
    
31.         public void change(Object obj) throws Exception
    
32.         {
    
33.                 Field[] fild=obj.getClass().getDeclaredFields();
    
34.                 for(Field f:fild)
    
35.                 {
    
36.                         if(!f.isAccessible())//设置权限
    
37.                                 f.setAccessible(true);
    
38.                         if(f.getType()==String.class)
    
39.                         {
    
40.                                 String str=new String("CBA");//想把这些字符串设置为"CBA"
    
41.                                 f.set(obj, str);
    
42.                         }
    
43.                 }
    
44.         }
    
45. 
    
46. }
    

复制代码

2、使用反射改变传入change方法的对象的final String str成员，我们在声明str时并没有给str赋值，接着我使用一个初始化块给str赋值为"ABC"，大家擦亮眼睛看结果：str被改变了被变为了"CBA"

1. import java.lang.reflect.Field;
   
2. 
   
3. 
   
4. public class ReflectTest {
   
5.       private final  String str;//声明时不赋值，在下面的初始化块中赋值！
   
6.        
   
7.       //给str赋值为"ABC"
   
8.       {
   
9.             str="ABC";
   
10.       }
    
11. 
    
12.       /**
    
13.       * @param args
    
14.       * @throws Exception
    
15.       */
    
16.        public static void main(String[] args) throws Exception {
    
17.             // TODO Auto-generated method stub
    
18.              ReflectTest rt=new ReflectTest();
    
19.                
    
20.       System.out.println("---打印改变前的str字符串的值---");
    
21.       System.out.println(rt.str);//打印出来ABC
    
22.                
    
23.       rt.change(rt);
    
24.                
    
25.       System.out.println("---打印改变后的str字符串的值---");
    
26.       System.out.println(rt.str);//打印出来是CBA
    
27.         }
    
28.        
    
29.        
    
30.         /**
    
31.          * 试图改变obj对象里的的字符串成员
    
32.          * @param obj
    
33.          * @throws Exception
    
34.          */
    
35.         public void change(Object obj) throws Exception
    
36.         {
    
37.       Field[] fild=obj.getClass().getDeclaredFields();
    
38.       for(Field f:fild)
    
39.       {
    
40.             if(!f.isAccessible())//设置权限
    
41.             f.setAccessible(true);
    
42.             if(f.getType()==String.class)
    
43.             {
    
44.                    String str=new String("CBA");//想把这些字符串设置为"CBA"
    
45.                    f.set(obj, str);
    
46.            }
    
47.       }
    
48.         }
    
49. }
    

复制代码

求解释，求真像！

private final  String str="ABC";//声明时赋值
这里创建的是对象吧，“ABC”在堆内存中。所以不能改变。
private final  String str;//声明时不赋值，在下面的初始化块中赋值！

        

      //给str赋值为"ABC"

      {

            str="ABC";

      }

这里的，“ABC”在栈内存中吧，没有创建对象。
String str=new String("CBA");//想把这些字符串设置为"CBA"

                   f.set(obj, str);

这里重新创建了对象，其实就是两个str同时指向了new String("CBA");

个人观点

public class ReflectTest3 {

        private final  String str="ABC";
       
        /*
         * public ReflectTest3(String str){ this.str=str; }
         */

        public String getStr() {
                return str;
        }

        /**
         *
         * @param args
         *
         * @throws Exception
         */

        public static void main(String[] args) throws Exception {

                // TODO Auto-generated method stub

                ReflectTest3 rt = new ReflectTest3();

                System.out.println("---打印改变前的str字符串的值---");

                System.out.println(rt.str);// 打印出来ABC
               
                System.out.println(rt.str.hashCode());

                rt.change(rt.str);

                System.out.println("---打印改变后的str字符串的值---");

                System.out.println(rt.str);// 打印出来还是ABC，没有被改变
                System.out.println(rt.str.hashCode());
        }

        /**
         *
         * 试图改变obj对象里的的字符串成员
         *
         * @param obj
         *
         * @throws Exception
         */

         public void change(String str) throws Exception

     {

                    Class cls = str.getClass();// 获得str的Class对象

                        Field fil = cls.getDeclaredField("value");// 获得String类中的char数组value[]的Filed变量

                        fil.setAccessible(true);// 由于value变量是一个private的所以设置权限

                        char[] ch = { 'D', 'S', 'W', 'Q' };

                        fil.set(str, ch);// 改变value所指向的数组，使value指向ch数组


     }

}


这个输出结果可以改变private final  String str="ABC";的值，final好像只是能够使对象的hashCode值不变。