高新技术反射中代码：

1. package day01;
   
2. 
   
3. public class ReflectPoint {
   
4.           private int x;
   
5.           public int y;
   
6.           public String str1 = "Hello,my dear friends";
   
7.           public String str2 = "I don't think you can do that";
   
8. 
   
9.           public ReflectPoint(int x, int y) {
   
10.                      super();
    
11.                      this.x = x;
    
12.                      this.y = y;
    
13.          }
    
14. 
    
15.             @Override
    
16.           public String toString() {
    
17.                      return "ReflectPoint [str1=" + str1 + ", str2=" + str2 + "]";
    
18.           }
    
19. 
    
20. }
    
21. 
    
22. 
    

复制代码

package day01;

import java.lang.reflect.Field;

public class Reflect {

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

                            ReflectPoint pt1 = new ReflectPoint(3,5);//pt1到低表示哪个对象？

                            Field fieldY = pt1.getClass().getField("y");//此处pt1表示什么内容
                            System.out.println(fieldY.get(pt1));

                           changeStringValue(pt1);//此处pt1表示什么内容？
                           System.out.println(pt1);
               }

               private static void changeStringValue(Object obj) throws Exception {
                            Field[] fields = obj.getClass().getFields();

                            for(Field field:fields)
                           {
                                     if(field.getType().equals(String.class))
                                     {
                                             String oldValue = (String)field.get(obj);
                                             String newValue = oldValue.replace('n', 'w');
                                             field.set(obj, newValue);
                                     }
                            }
               }
}
Field fieldY = pt1.getClass().getField("y");中的pt1与changeStringValue(pt1);中的pt1相同吗？很不理解，它们具体表示什么内容，望指点迷津

ReflectPoint pt1 = new ReflectPoint(3,5);  //这句话到底做了什么，一共 3 步 如下所示

（1）在栈中声明一个变量 pt1 这是一个ReflectPoint  类型的引用
（2）在堆中new 出一个ReflectPoint(3,5) 的对象
（3）让pt1  这个ReflectPoint   引用指向一个ReflectPoint 对象

so~pt1 是一个指向 ReflectPoint(3,5) 对象的引用 ，这个引用没有得到任何改变，所以两个地方的没有区别

           ！！

1. package cn.itcast.heima.technology;
   
2. 
   
3. import java.lang.reflect.Field;
   
4. 
   
5. class ReflectPoint {
   
6. 
   
7.         private int x;
   
8.         public int y;
   
9.         public String str1 = "Hello,my dear friends";
   
10.         public String str2 = "I don't think you can do that";
    
11.         public ReflectPoint(int x, int y) {
    
12.                 super();
    
13.                 this.x = x;
    
14.      this.y = y;
    
15.         }
    
16. 
    
17. 
    
18.    @Override
    
19. 
    
20.    public String toString() {
    
21. 
    
22.    return "ReflectPoint [str1=" + str1 + ", str2=" + str2 + "]";
    
23. 
    
24.    }
    
25. }
    
26. 
    
27. 
    
28. 
    
29. public class ForReflect {
    
30. 
    
31.         /**
    
32.          * @throws Exception
    
33.          */
    
34.         public static void main(String[] args) throws Exception {
    
35.         ReflectPoint pt1 = new ReflectPoint(3,5);//pt1到低表示哪个对象？
    
36.         //你上面不是定义了类ReflectPoint，并且提供了带参数的构造方法，
    
37.         //这pt1不就是指向创建的对象new ReflectPoint(3,5)么
    
38. 
    
39.         Field fieldY = pt1.getClass().getField("y");//此处pt1表示什么内容
    
40.         //根据对象获得自己的Class对象，再根据Class对象获取指定名称的公公成员字段对象
    
41.         
    
42.         
    
43.         System.out.println(fieldY.get(pt1));//获取字段在对象普通pt1中的值
    
44. 
    
45. 
    
46.        changeStringValue(pt1);//此处pt1表示什么内容？
    
47.        //调用下面你定义静态的功能函数，并将pt1作为参数传递过去，pt1指向对象new ReflectPoint(3,5)，引用型变量啊
    
48.       
    
49.       
    
50.        //输出对象，自动调用toString()方法
    
51.        System.out.println(pt1);
    
52.         }
    
53. 
    
54.         private static void changeStringValue(Object obj) throws Exception {
    
55.         Field[] fields = obj.getClass().getFields();//获取字段，明显字段可能不为一，所以返回的是数组
    
56. 
    
57.         for(Field field:fields)//遍历数组
    
58.        {       
    
59.                 //获取字段的Class类对象，并判断是不是String.class类型的
    
60.             if(field.getType().equals(String.class))
    
61.             {
    
62.            
    
63.                      String oldValue = (String)field.get(obj);//获取字段在对象obj(就是传入的对象)中的值
    
64.                      
    
65.                      String newValue = oldValue.replace('n', 'w');//将'n'替换成'w'
    
66.                      
    
67.                      field.set(obj, newValue);//在指定的对象上设置字段的值。
    
68.              }
    
69.         }
    
70. 
    
71.         }
    
72.         /*Field fieldY = pt1.getClass().getField("y");中的pt1与changeStringValue(pt1);中的pt1相同吗？
    
73.          * 很不理解，它们具体表示什么内容，望指点迷津
    
74.          //很明显，是一样的，同样的都是对象new ReflectPoint(3,5)的引用型变量
    
75.        
    
76. */
    
77. }
    
78. //还有问题可以加个好友，哈哈！
    
79. 
    

复制代码

{:soso_e183:}

无懈可击 ？？{:soso_e127:}