1. package cn.itcast.day1;
   
2. 
   
3. public class ReflectPoint {
   
4.         int x;
   
5.         int y;
   
6.         String str1="ab";
   
7.         String str2="abc";
   
8.         public int getX() {
   
9.                 return x;
   
10.         }
    
11.         public void setX(int x) {
    
12.                 this.x = x;
    
13.         }
    
14.         public int getY() {
    
15.                 return y;
    
16.         }
    
17.         public void setY(int y) {
    
18.                 this.y = y;
    
19.         }
    
20.         public String getStr1() {
    
21.                 return str1;
    
22.         }
    
23.         public void setStr1(String str1) {
    
24.                 this.str1 = str1;
    
25.         }
    
26.         public String getStr2() {
    
27.                 return str2;
    
28.         }
    
29.         public void setStr2(String str2) {
    
30.                 this.str2 = str2;
    
31.         }
    
32.         @Override
    
33.         public String toString(){
    
34.                 return str1+str2;
    
35.         }
    
36. }
    

复制代码

1. package cn.itcast.day1;
   
2. 
   
3. import java.lang.reflect.Field;
   
4. 
   
5. public class ReflectTest {
   
6. 
   
7.         /**
   
8.          * @param args
   
9.          * @throws Exception
   
10.          */
    
11.         public static void main(String[] args) throws Exception {
    
12.                 ReflectPoint point1= new ReflectPoint();
    
13.                 ChangerVale(point1);
    
14.                 System.out.println(point1);
    
15.         }
    
16. 
    
17.         private static void ChangerVale(Object obj) throws Exception {
    
18.                 Field[] fields= obj.getClass().getFields();
    
19.                 for(Field field:fields){
    
20.                         if(field.getType()==String.class){
    
21.                                 String oldchar= (String)field.get(obj);
    
22.                                 String newString =oldchar.replace('b', 'a');// "a" "b" 与 'a' 'b'区别
    
23.                                 field.set(obj, newString);
    
24.                         }
    
25.                         
    
26.                 }
    
27.         }
    
28. 
    
29. }
    

复制代码

按照张老师讲的应该是输出aaaac
但输出的是 ababc

class ReflectPoint {
        int x;
        int y;
        String str1="ab";
        String str2="abc";
        public int getX() {
                return x;
        }
        public void setX(int x) {
                this.x = x;
        }
        public int getY() {
                return y;
        }
        public void setY(int y) {
                this.y = y;
        }
        public String getStr1() {
                return str1;
        }
        public void setStr1(String str1) {
                this.str1 = str1;
        }
        public String getStr2() {
                return str2;
        }
        public void setStr2(String str2) {
                this.str2 = str2;
        }
        @Override
        public String toString(){
                return str1+" "+str2;
        }
}

class ReflectTest {
      public static void main(String[] args) throws Exception {
                ReflectPoint point1= new ReflectPoint();
                ChangerVale(point1);
               // System.out.println(point1);
        }
        private static void ChangerVale(Object obj) throws Exception {
                //Field[] fields= obj.getClass().getFields();//把这里改成下边的。！！
                                Field[] fields = obj.getClass().getDeclaredFields();
                for(Field field:fields){
                        if(field.getType()==String.class){
                                String oldchar= (String)field.get(obj);
                                String newString =oldchar.replace('b', 'a');// "a" "b" 与 'a' 'b'区别
                                field.set(obj, newString);
                                                                System.out.println(field.get(obj));
                        }
                        
                }
        }

}
{:soso_e100:}{:soso_e100:}{:soso_e100:}
解决方案：
①把 该句（Field[] fields= obj.getClass().getFields();）
②换成 Field[] fields = obj.getClass().getDeclaredFields();
就行了。


楼主很好的理解以下两个方法就可以了。

public Field[] getDeclaredFields()

返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。

包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。返回数组中的元素没有排序，

也没有任何特定的顺序。如果该类或接口不声明任何字段，或者此 Class 对象表示一个基本类型、

一个数组类或 void，则此方法返回一个长度为 0 的数组。


public Field[] getFields()

返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。

返回数组中的元素没有排序，也没有任何特定的顺序。如果类或接口没有可访问的公共字段，或者表示一个

数组类、一个基本类型或 void，则此方法返回长度为 0 的数组。 特别地，如果该 Class 对象表示一个类，

则此方法返回该类及其所有超类的公共字段。如果该 Class 对象表示一个接口，则此方法返回该接口及

其所有超接口的公共字段。


{:soso_e101:} {:soso_e101:} {:soso_e101:} {:soso_e133:}
//既然楼主对上边的概念不能很好的理解，那我就告诉你怎样简单的理解。

//getFields方法：打印的是本类，父类，超类中的公共字段，也就是public修饰的字段

//getDeclaredFields方法：只能打印本类中的所有字段

//以下是我给你举的例子，你看看吧。

import java.lang.reflect.*;
class Fu {
        public String name = null;
        public int age = 0;
}
class Zi extends Fu {
    public String school  = "北京黑马";
    public int money  = 0;
    public static void main(String args[]){

      System.out.println("getFields方法：打印的是本类，父类，超类中的公共字段");
      for(Field m :Zi.class.getFields())
      System.out.println(m);

      System.out.println("\t\t=========\n");

      System.out.println("getDeclareFields方法：只能打印本类中的所有字段");
      for(Field m :Zi.class.getDeclaredFields())
         System.out.println(m.getName());
     }
}

//怎么样，这回你算是彻底看懂了吧，，
//这会儿又累又困{:soso_e147:}，但我还是坚持着把你不懂的问题，给讲清楚了！用你的金币鼓励一下我吧{:soso_e100:}

//还有记得把主题分类为《！已解决！》，谢谢合作。

虽然能解决问题但是还是不太明白
getDeclaredFields 不包括继承
包括继承

帮你把main函数程序重写了下.   
public class ReflectTest {

        public static void main(String[] args) throws Exception {
                ReflectPoint rePoint = new ReflectPoint();
                changerVal(rePoint);
                System.out.println(rePoint);
               
        }
        private static void changerVal(Object obj) throws Exception {
                Field[] fields = obj.getClass().getFields();
                for (Field field : fields){
                        if (field.getType() == String.class){
                                String oldValue = (String)field.get(obj);
                                String newValue = oldValue.replace("b", "a");  // 替换字符串的..
                                field.set(obj, newValue);
                        }
                }
                        
        }
}

现在OK了..   
你的代码刚才测试了下 好像for循环都没进去..  

杨杨 发表于 2013-3-1 20:41
虽然能解决问题但是还是不太明白
getDeclaredFields 不包括继承
包括继承

我继续看了下 也郁闷了..  直接changerVale方法替换掉我刚写的  没问题了..  :L

........................

付玉光 发表于 2013-3-1 20:12
class ReflectPoint {
        int x;
        int y;

getFields()方法父类 本类的都不打印吧

司懿卓 发表于 2013-3-1 20:44
帮你把main函数程序重写了下.   
public class ReflectTest {

我测试你改的代码咋不行呢求完整代码

司懿卓 发表于 2013-3-1 20:44
帮你把main函数程序重写了下.   
public class ReflectTest {

找到原因了
public String str1="ab";
        public String str2="abc";
        public int getX() {
                return x;
        }没有加public 字段 公共方法

杨杨 发表于 2013-3-2 11:16
getFields()方法父类 本类的都不打印吧

你难道还不明白吗？

//getFields方法：打印的是本类，父类，超类中的公共字段，说的在清楚点，也就是public修饰的字段

//getDeclaredFields方法：只能打印本类中的所有字段。

付玉光 发表于 2013-3-2 11:40
你难道还不明白吗？

//getFields方法：打印的是本类，父类，超类中的公共字段，说的在清楚点，也就是pub ...

谢谢啊 本人眼拙

杨杨 发表于 2013-3-2 11:56
谢谢啊 本人眼拙

:)不用客气，明白了后，把 主题改为《已解决》。