反射(成员变量Field和成员函数Method的反射)

------- java学习型技术博客、期待与您交流 ----------

 

java基础总结之反射(成员变量Field和成员函数Method的反射)

Field类

       类中的成员变量也是用一个类来表示的，这个类就是Field，Field类代表某个类中的一个成员变量

在学习成员变量的反射之前我们需要创建一个类，并在类中定义两个成员变量，通过构造方法进行赋值。

package com.itheima.day1;

public class ReflectPoint {
private int x;//修饰符为private
public int y;//修饰符为public
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}
}

对上面类中定义的成员变量进行反射

package com.itheima.day1;
import java.lang.reflect.Field;
public class ReflectFieldTest {

/**
* @param args
*/
public static void main(String[] args)throws Exception {
// TODO Auto-generated method stub
ReflectPoint pt1 = new ReflectPoint(3,5);
//注意fieldY的值不是5，这个y代表的是字节码上的变量，并没有对应到对象身上
//fieldY不是对象身上的变量，而是类上的要用它去取某个对象的值。
Field fieldY = pt1.getClass().getField("y");
System.out.println(fieldY.get(pt1));

//由于x是私有的，所以要用getDeclaredField()方法
Field fieldX = pt1.getClass().getDeclaredField("x");
//强行将其设置为可以访问的,暴力反射
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt1));
}
}

 

成员变量的综合示例：

需求：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。

1，在类中定义两字字符串常量：

package com.itheima.day1;

public class ReflectPoint {
private int x;//修饰符为private
public int y;//修饰符为public

public String str1 = "ball";
public String str2 = "basketball";
public String str3 = "itheima";

public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}
//为了打印方便，覆盖toString()方法
public String toString(){
return str1+"::"+str2+"::"+str3;
}
}

2，通过反射进行替换

package com.itheima.day1;
import java.lang.reflect.Field;
public class ReflectFieldTest {

/**
* @param args
*/
public static void main(String[] args)throws Exception {

// TODO Auto-generated method stub
ReflectPoint pt1 = new ReflectPoint(3,5);/*
//注意fieldY的值不是5，这个y代表的是字节码上的变量，并没有对应到对象身上
//fieldY不是对象身上的变量，而是类上的要用它去取某个对象的值。
Field fieldY = pt1.getClass().getField("y");
System.out.println(fieldY.get(pt1));

//由于x是私有的，所以要用getDeclaredField()方法
Field fieldX = pt1.getClass().getDeclaredField("x");
//强行将其设置为可以访问的,暴力反射
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt1));
*/
changeStringValue(pt1);
System.out.println(pt1);
}

private static void changeStringValue(Object obj)throws Exception {
Field[] fields = obj.getClass().getFields();
for(Field field : fields)
{
//判断是否为String类型的字节码(判断是否是同一个字节码最好用"==")，如果是，开始取值
if(field.getType() == String.class)
{
//在对象身上取值，因为已经判断是String类型的了，用(String)进行强转
String oldValue = (String)field.get(obj);
//将b替换为a
String newValue = oldValue.replace('b', 'a');
//通过get取得对象身上的值并进行修改后还要对其进行set，不然对象的值还是没有发生改变。
field.set(obj, newValue);
}
}
}
}

运行结果：

aall::aasketaall::itheima

 

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Method类
       类中的方法也是对象，Method类代表某个类中的一个成员方法。

得到类中的某一个方法：

 Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

方法的调用

常规方式：

System.out.println(str.charAt(1));

运用反射的方式：

System.out.println(charAt.invoke(str, 1));
如果传递给Method对象的invoke()方法的第一个参数为null，说明该Method对象对应的是一个静态方法！

示例，通过反射得到String类的charAt()方法并调用。

String str = "abc";
Method methodCharAt = String.class.getMethod("charAt", int.class);//方法有参数，参数的类型也是对象
System.out.println(methodCharAt.invoke(str, 1));

方法是一个Method对象，那么方法中也有“调用”的方法invoke。

例如：

1，一个人在黑板上画圆，需要圆心半径，画圆这个方法要用到圆心和半径，他们是私有的，如果把画圆的方法分配给了人，意味着人要去访问圆的私有方法，不合适。同理把画圆的方法给黑板也不合适，所以这个方法只能分配给圆，圆有一个动作：画我circle.draw()。

2，列车司机踩下离合和刹车调用列车的停车方法，但只有列车自己能停下来，司机只是调用了这个方法而已。

3，人推门让门关上，人只是通过推这个动作调用了门自身的关门方法，门是其自身转动后关上的。

 

jdk1.4和jdk1.5的invoke方法的区别：

Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

 

用反射方式执行某个类中的main方法

需求：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法

为什么要用反射去执行？

因为有可能在写程序的时候根本不知道要执行那个类，只是在运行的时候接受到一个参数，根据参数去执行对应的类。

首先定义一个类

class TestArguments{
public static void main(String[] args){
for(String arg : args){
System.out.println(arg);
}
}
}

普通方式：

TestArguments.main(new String[]{"333","444","555"});

反射的方式：

String startingClassname = args[0];
Method mainMethod = Class.forName(startingClassname).getMethod("main", String[].class);
mainMethod.invoke(null, new Object[]{new String[]{"333","444","555"}});

这时候编译会报错，解决办法如下：

在类名TestArguments上按下F2--->复制出现的完整类名---->在写反射调用的类中右键---->Run As---->Run Configurations--->Arguments---->在Program arguments中写上完整的类名。



注意一个问题：

       启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new
String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。 

解决办法：

将String数组当成Object数组中的一个元素传入

mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});

或者用下面的方法：

mainMethod.invoke(null,(Object)new String[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

 

ps:反射的概念看起来和简单， 就是将各种成分映射成各种对象，但我觉得弄清楚用反射能干什么，什么时候需要用，为什么要用才是重点，怎么用只是其次。加强积累！

 

------- java学习型技术博客、期待与您交流 ----------