反射总结

用反射来实现一个可以读取配置生成对象的对象池

public class ObjectPoolFactory {
	//定义一个对象池 名字   对应的对象
	private Map<String,Object> map = new HashMap<>();
	//传入一个字符串就能返回一个对象
	private Object createObject(String clazz) throws ClassNotFoundException, InstantiationException, IllegalAccessException
	{
		Class<?> c = Class.forName(clazz);
		return c.newInstance();
	}
	//根据指定的文件来初始化对象池
	public void initPool(String fileName)
	{
		try(FileInputStream fis = new FileInputStream(fileName);)
		{
			Properties pro = new Properties();
			pro.load(fis);
			for(String name:pro.stringPropertyNames())
			{
				map.put(name,createObject(pro.getProperty(name)));
			}
		} 
		catch (Exception e)
		{
			
			System.out.println("初始化异常");
		}
	
		
	}
	//取出指定对象
	public Object getObject(String name)
	{
		return map.get(name);	
	}
	
}

配置文件

内容

测试

@Test
	public void test()
	{
		ObjectPoolFactory pf = new ObjectPoolFactory();
		pf.initPool("src//fanshe//obj.properties");
		System.out.println(pf.getObject("a"));
		System.out.println(pf.getObject("b"));
		
	} 

输出：

通过反射访问对象私有属性

新建Persion类

public class Persion {
	String name;
	private int age;
	public Persion() {
	
	
	}
	public Persion(String name) {
		super();
		this.name = name;
	
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

测试访问Person的私有属性

//访问属性值
	@Test
	public void test3() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException
	{
		Persion p = new Persion("aaa");
		Class<?> clazz=p.getClass();
		//暴力反射可获取私有字段
		Field nameField = clazz.getDeclaredField("age");
		//将私有字段设置为可访问
		nameField .setAccessible(true);
		//为字段设值
		nameField .set(p, 12);
		System.out.println(p.getAge());
		
	}

输出：

通过反射获取泛型信息

getType()获得该字段的数据类型    getGenericType()方法获得带泛型信息的参数类型

测试类

class GenericTest{
		private Map<String,Integer> map ;
		
	}

测试方法

@Test
	public void test4() throws NoSuchFieldException, SecurityException
	{
		Class<?> clazz = GenericTest.class;
		Field f = clazz.getDeclaredField("map");
		f.setAccessible(true);
		//获得数据得数据类型
		Class<?> a = f.getType();
		System.out.println(a);//输出interface java.util.Map
		//获得带泛型信息的数据类型
		Type gtype=f.getGenericType();
		System.out.println(gtype);//输出java.util.Map<java.lang.String, java.lang.Integer>
		//ParameterizedType代表参数化类型如果gtype的类型是它就强制转化
		if(gtype instanceof ParameterizedType)
		{
			//强制转化
			ParameterizedType type=(ParameterizedType) gtype;
			//获得原始类型
			Type t=type.getRawType();
			System.out.println(t);//输出interface java.util.Map
			//获得泛型类型的参数信息
			Type[] targes = type.getActualTypeArguments();
			for(Type p:targes)
			{
				System.out.println(p);//输出class java.lang.String  class java.lang.Integer
			}
		}
		
	}

输出

以上是java疯狂讲义第13章反射的总结