反射就是把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);
}
}
}