Java中的反射

反射就是把Java类中的各种成分映射成相应的Java类。

Constructor 类代表某个类中的一个构造方法

*得到某个类所有的构造方法：

Constructors[] constructors = Class.forName("java.lang.String").getConstructors();

*得到某个类的一个构造方法：

Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);

*通过反射方式来创建实例对象：

String str = (String) constructor.newInstance(new StringBuffer("abc"));

*Class.newInstance()方法：

Sample code : String obj = (String) Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法来创建实例对象。（该方法用到了缓存机制来保存默认构造方法的实例对象）。

Field类代表某个类中的一个成员变量。

通过反射获得某个类的成员变量的名称，类型，修饰符和值 , 并将为String类型的成员变量的值中的a 替换成b 。

Sample code :

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class ReflectTest {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		ReflectPoint rp = new ReflectPoint();
		Class rpClass = rp.getClass();
		Field[] fields = rpClass.getDeclaredFields();
		for(Field field:fields){
			field.setAccessible(true);
			System.out.println("Field name:"+field.getName()+"\n"+"Type:"+field.getType()+"--"+"Modifiers:"+field.getModifiers()+"-- Value:"+field.get(rp));		}
		changeStringValue(rp);
		System.out.println(rp);
	}
	
	public static void changeStringValue(Object obj) throws Exception{
		Class objClass = obj.getClass();
		Field[] fields = objClass.getDeclaredFields();
		for(Field field:fields){
			if(field.getType()==String.class){
				field.setAccessible(true);
				String oldString =(String)field.get(obj);
				String newString = oldString.replace('b', 'a');
				field.set(obj, newString);
			}
		}
	}
}

public class ReflectPoint {
	private int x;
	protected int y;
	public String str1 = "ball";
	public String str2 = "basketball";
	public String str3 = "aaabb";
	String str4= "test4";
	public int getX() {
		return x;
	}
	public int getY() {
		return y;
	}
	public String getStr1() {
		return str1;
	}
	public String getStr2() {
		return str2;
	}
	public String getStr3() {
		return str3;
	}
	public String getStr4() {
		return str4;
	}
	public void setX(int x) {
		this.x = x;
	}
	public void setY(int y) {
		this.y = y;
	}
	public void setStr1(String str1) {
		this.str1 = str1;
	}
	public void setStr2(String str2) {
		this.str2 = str2;
	}
	public void setStr3(String str3) {
		this.str3 = str3;
	}
	public void setStr4(String str4) {
		this.str4 = str4;
	}
    
	public String toString(){
		return x+":"+y+":"+str1+":"+str2+":"+str3+":"+str4;
	}
}

运行结果：

Field name:x
Type:int--Modifiers:2-- Value:0
Field name:y
Type:int--Modifiers:4-- Value:0
Field name:str1
Type:class java.lang.String--Modifiers:1-- Value:ball
Field name:str2
Type:class java.lang.String--Modifiers:1-- Value:basketball
Field name:str3
Type:class java.lang.String--Modifiers:1-- Value:aaabb
Field name:str4
Type:class java.lang.String--Modifiers:0-- Value:test4
0:0:aall:aasketaall:aaaaa:test4

Method 类代表某个类中的一个成员方法

得到类中的某一个方法：

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

调用方法：

通常方式： str.charAt(1);

反射方式： charAt.invoke(str,1);

jdk 1.4 和 jdk 1.5 的invoke方法的区别：

jdk1.5 : public Object invoke(Object obj , Object... args)

jdk1.4 : public Object invoke(Object obj , Object[] args) , 既按jdk 1.4 的语法，需要将一个数组作为一个参数传递给invoke方法时，数组中的每个元素分别对应被操作方法的每个参数。

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

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectTest {

	public static void main(String[] args) throws Exception{
		ReflectTest2 rt2= (ReflectTest2)Class.forName("javase.day18.ReflectTest2").newInstance();
		//mainMethod.invoke(rt2,(Object)(new String[]{"1","2","3"}));
		mainMethod.invoke(rt2, new Object[]{new String[]{"1","2","3"}});
	}

}

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