1. import java.lang.reflect.Field;
   
2. 
   
3. //利用反射把字符串中的a替换成b
   
4. public class FrflectFieldDemo {
   
5. 
   
6.         public static void main(String[] args) throws Exception{
   
7.                 ReflectTest rt = new ReflectTest();
   
8.                 Field[] fields = rt.getClass().getFields();
   
9.                
   
10.                 for(Field field: fields){
    
11.                         if(field.getType() == String.class){
    
12.                                 String oldStr = (String)field.get(rt);
    
13.                                 //String oldStr = (String)field.get(field);//使用field报错
    
14.                                 String newStr = oldStr.replace('a', 'b');
    
15.                                 System.out.println(newStr);
    
16.                         }
    
17.                 }
    
18.                
    
19.         }
    
20. }
    
21. 
    
22. 
    
23. class ReflectTest {
    
24.         public String str1 = "football";
    
25.         public String str2 = "pingpangball";
    
26.         public String str3 = "haha";
    
27. 
    
28.         public ReflectTest(){}
    
29. 
    
30.         public String toString(){
    
31.                 return str1+":"+str2+":"+str2;
    
32.         }
    
33. }
    

复制代码

为什么在获取oldStr时，传入tr能成功，传入field报错

你可以去查下API，这是Field类的一个方法，public Object get(Object obj) throws IllegalArgumentException,IllegalAccessException，获得参数对象在这个字段的值，如果是基本数据类型，则包装在一个对象里面，所以你那里错了。而且你见过哪个对象有方法是把自己作为参数的吗？

睡觉之前帮你解决一下吧

String oldStr = (String)field.get(rt);  field是属性，field.get(rt)指的是：你要取得field属性的值，肯定要有对象先存在才能取，那么对象就是rt。get方法传入的是根据field属性所属的字节码new出来的。我一开始学这个，还有Method中的invoke方法，是觉得挺别扭的，但是明白了面向对象设计思想之后，就能明白sun为什么会设计成这样子

1. 
   
2. <P>package Test;
   
3. import java.lang.reflect.Field;
   
4. //利用反射把字符串中的a替换成b
   
5. public class FrflectFieldDemo {</P>
   
6. <P> public static void main(String[] args) throws Exception {
   
7. 
   
8.   ReflectTest rt = new ReflectTest();
   
9.   Field[] fields = rt.getClass().getFields();</P>
   
10. <P>  for (Field field : fields) {
    
11.    if (field.getType() == String.class) {
    
12.     String oldStr = (String) field.get(rt);
    
13.     String newSctr = oldStr.replace('a', 'b');
    
14.     System.out.println(newSctr);
    
15.    }
    
16.   }
    
17.   System.out.println("==========================================");
    
18.   //获取对象
    
19.   ReflectTest  t = new ReflectTest();
    
20.   
    
21.   change(t);
    
22. }
    
23. public static void change(Object obj) throws Exception
    
24. {
    
25.   //获取要操作的类的Class对象
    
26.   Class<?> classType = obj.getClass();
    
27.   
    
28.   //获取对象中的多有成员变量
    
29.   Field[] fields = classType.getFields();
    
30.   
    
31.   //操作成员变量
    
32.   for (int i = 0; i < fields.length; i++) {
    
33.    //获取第i个成员变量对象
    
34.    Field field = classType.getDeclaredField(fields[i].getName());
    
35.    //获取对象对应的值
    
36.    String fieldValue = field.get(obj).toString();
    
37.    
    
38.    System.out.println("oldFiledValue： " + fieldValue);
    
39.    //压制JVM对字段修饰符的检查
    
40.    field.setAccessible(false);
    
41.    //替换字段中的“a”为“b”
    
42.    String changeValue = fieldValue.replace("a", "b");
    
43.    
    
44.    System.out.println("newFieldValue：  " + changeValue);
    
45.   }
    
46. }
    
47. }</P>
    
48. <P>class ReflectTest {
    
49. public String str1 = "football";
    
50. public String str2 = "pingpangball";
    
51. public String str3 = "haha";</P>
    
52. <P> public ReflectTest() {
    
53. }</P>
    
54. <P> public String toString() {
    
55.   return str1 + ":" + str2 + ":" + str2;
    
56. }
    
57. }</P>

复制代码

你只是获取字段对象的值并做替换，你并没有把替换的结果重新赋值给对象