Java中的反射

系统管理员 2022-06-17 09:22 139阅读 0赞

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