Java 反射机制example

什么是反射（what’s Java Reflection）

java反射是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public,static等等）、superclass（例如Object）、实现之int。erfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods

反射能做什么（what reflection can do）

在运行时判断任意一个对象所属的类

在运行时构造任意一个类的对象

在运行时判断任意一个类所具有的成员变量和方法

在运行时调用任意一个对象的方法

反射的API（ReflectionAPI）

java.lang.reflect.Method;

java.lang.reflect.Constructor;

java.lang.reflect.Field;

java.lang.reflect.Modifier;

java.lang.reflect.Array;

//获取任意一个类的方法

Class clz = String.class;或者Class
clz = Class.forName(“java.lang.String”);

//实例化对象、判断其类型

public class ReflectionExample {
               public static void main(String[] args) {
                  Class clz = ReflectionExample.class;
                  try {
                      if (clz.newInstance() instanceof String) {
                         System.out.println("instance is String");
                       } else {
                      System.out.println("instance is not String");
                        }
                       } catch (InstantiationException e) {
                     e.printStackTrace();
                   } catch (IllegalAccessException e) {
                      e.printStackTrace();
                  } }}

java.lang.reflect.Constructor

Class.getConstructors();

Class.getConstructor(Class[]);

//获取类构造函数信息

public class ReflectionExample {
    public ReflectionExample() {
        System.out.println("zero-params Constructor");
    }
    
    public ReflectionExample(String s) {
        System.out.println("String construct-arg Constructor");
    }
    
    public static void main(String[] args) {
        Class clz = ReflectionExample.class;
        Constructor[] cons = clz.getConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
    }
}

利用构造函数实例化对象:

import java.lang.reflect.Constructor;

public class ReflectionExample2 {
	String member;

	public ReflectionExample2() {
		System.out.println("zero-params Constructor");
	}

	public ReflectionExample2(String s) {
		System.out.println("String construct-arg Constructor");
		this.member = s;
	}

	public String toString() {
		return "[" + member + "]";
	}

	public static void main(String[] args) {
		Class clz = ReflectionExample.class;
		Class[] ptypes = new Class[] { String.class };
		try {
			Constructor con = clz.getConstructor(ptypes);
			Object[] conArgs = new Object[] { new String("hello") };
			System.out.println(con.newInstance(conArgs));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

java.lang.reflect.Method

Class.getMethods()

Class.getMethod(String, Class[])

Method.invoke()

获取一个类所有的方法:

import java.lang.reflect.Method;

public class ReflectionExample {
	String member;

	public ReflectionExample() {
		System.out.println("zero-params Constructor");
	}

	public ReflectionExample(String s) {
		System.out.println("String construct-arg Constructor");
		this.member = s;
	}

	public int add(int a, int b) {
		return a + b;
	}

	public String toString() {
		return "[" + member + "]";
	}

	public static void main(String[] args) {
		Class clz = ReflectionExample.class;
		Method[] methods = clz.getMethods();
		for (Method method : methods) {
			System.out.println(method);
		}
	}
}

调用类的函数:

import java.lang.reflect.Method;

public class ReflectionExample {
	String member;

	public ReflectionExample() {
		System.out.println("zero-params Constructor");
	}

	public ReflectionExample(String s) {
		System.out.println("String construct-arg Constructor");
		this.member = s;
	}

	public int add(int a, int b) {
		return a + b;
	}

	public String toString() {
		return "[" + member + "]";
	}

	public static void main(String[] args) {
		Class clz = ReflectionExample.class;
		Class partypes[] = new Class[] { Integer.TYPE, Integer.TYPE };
		Method meth;
		try {
			meth = clz.getMethod("add", partypes);
			ReflectionExample re = new ReflectionExample();
			Object arglist[] = new Object[] { new Integer(37), new Integer(47) };
			Object retobj = meth.invoke(re, arglist);
			Integer retval = (Integer) retobj;
			System.out.println(retval.intValue());
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}

java.lang.reflect.Field

Class.getFields()

Class.getDeclaredFields()

Class.getField(String)

Class.getDeclaredField(String)

获取类成员属性

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class ReflectionExample {
	String member;

	public ReflectionExample() {
		System.out.println("zero-params Constructor");
	}

	public ReflectionExample(String s) {
		System.out.println("String construct-arg Constructor");
		this.member = s;
	}

	public int add(int a, int b) {
		return a + b;
	}

	public String toString() {
		return "[" + member + "]";
	}

	public static void main(String[] args) {
		Class clz = ReflectionExample.class;
		Field[] declaredFields = clz.getDeclaredFields();
		for (Field field : declaredFields) {
			System.out.println("name = " + field.getName());
			System.out.println("type = " + field.getType());
			System.out.println("modifier = "
					+ Modifier.toString(field.getModifiers()));
		}
	}
}

修改对象属性值

import java.lang.reflect.Field;

public class ReflectionExample {
	String member;
	int publicField;

	public ReflectionExample() {
		System.out.println("zero-params Constructor");
	}

	public ReflectionExample(String s) {
		System.out.println("String construct-arg Constructor");
		this.member = s;
	}

	public int add(int a, int b) {
		return a + b;
	}

	public String toString() {
		return "[" + member + "]";
	}

	public static void testChangeFieldValue() {
		Class clz = ReflectionExample.class;
		try {
			Field fd = clz.getDeclaredField("publicField");
			ReflectionExample re = new ReflectionExample();
			System.out
					.println("Before change: publicField = " + re.publicField);
			fd.setInt(re, 100);
			System.out.println("After change: publicField = " + re.publicField);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		testChangeFieldValue();
	}
}

java.lang.reflect.Array

Array

类提供了动态创建和访问 Java 数组的方法。

Array

允许在执行 get 或 set 操作期间进行扩展转换，但如果发生收缩转换，则抛出

IllegalArgumentException

。

getLength(Object array)

以

int

形式返回指定数组对象的长度。

newInstance(Class<?> componentType, int length)

创建一个具有指定的组件类型和长度的新数组。

set(Object array, int index,Object value)

将指定数组对象中索引组件的值设置为指定的新值。

get(Object array, int index)

返回指定数组对象中索引组件的值。

......

创建数组

public void testCreateArray() {
        Class clz = String.class;
        Object arr = Array.newInstance(clz, 5);
        Array.set(arr, 2, "hello reflection");
        String s  = (String)Array.get(arr, 2);
        System.out.println(s);
    }

Array实现对数组扩容

public Object[] doubleArray(Object[] arr) {
        Class clz = arr.getClass();
        if (!clz.isArray()) return null;
        
        int oldSize = Array.getLength(arr);
        int newSize = oldSize * 2 + 1;
        Object[] newArr = (Object[]) Array.newInstance(clz.getComponentType(), newSize);
        
        for (int i = 0; i < arr.length; ++i) {
            newArr[i] = arr[i];
        }
        
        return newArr;
    }

访问私有变量:

import java.lang.reflect.Field;

public class ReflectionExample {

	private String privateString;

	public ReflectionExample(String privateString) {
		this.privateString = privateString + "Example";
	}

	public static void main(String[] args) { 
		try {
			ReflectionExample re = new ReflectionExample("New");
			Field privateStringField = ReflectionExample.class
					.getDeclaredField("privateString");

			privateStringField.setAccessible(true);

			String fieldValue = (String) privateStringField.get(re);
			System.out.println("fieldValue = " + fieldValue);

		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}

英文文章参考