Web基础之Java中的反射机制

Web基础之Java中的反射

一、Java中的反射机制：

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都

能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

二、反射机制的功能：

· 在运行时获取任意一个对象所属的类；

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

· 在运行时获取任意一个类所具有的成员变量和方法；

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

· 生成动态代理。(了解)

三、反射API（后面会有代码演示）

通过一个对象或类获取完整的包名和类名

在运行时实例化一个类的对象

获取一个类的父类和实现的接口

获取某个类的全部构造方法

获取某个类的全部属性和方法

通过反射机制调用某个类的方法

通过反射机制操作某个类的属性

四、反射机制的应用

     在泛型为 Integer 的 ArrayList 中存放一个其他类型的对象

     通过反射取得并修改数组的信息

     通过反射机制修改数组的大小

     在 DAO 中，优化对象的封装

五、代码演示Java反射API以及简单应用

新建一个Person类,该类的属性和方法如下；

为了后面的测试，我们实现了序列化接口：

package com.hx.ref;

import java.io.Serializable;

public class Person implements Serializable{
	
	private static final long serialVersionUID = 1L;

	public static String schname;
	
	private  String name;
	
	private int age;
	
	private String sex;
	
	private float weight;
	
	public Person() {
		
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public Person(String name, int age, String sex, float weight) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.weight = weight;
	}

	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;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public float getWeight() {
		return weight;
	}

	public void setWeight(float weight) {
		this.weight = weight;
	}
	
	public String toString() {
		String str="Person:"+"Name:"+name+"Age:"+age+"Sex:"+sex+"Weight:"+weight;
		return str;
	}
}

package com.hx.ref;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

public class Test {

	public static void main(String[] args) throws Exception{
		
//		String [] str={"123","345","678","789"};
//		String [] copyStr=arrayCopyandIncres(str, 2,String.class);
//		
//		priArray(copyStr);
//		
//		Integer [] ints={1,2,3,4,5};
//		Integer[] inscopy=arrayCopyandIncres(ints, 4, Integer.class);
//		priArray(inscopy);
		
		test6();
	}

	// 获取Person类的Class对象
	@SuppressWarnings({ "unused", "rawtypes" })
	private static void test1() {
		// Class类的获取方法：通过[对象的getClass（）方法]获取Class对象
		Person p = new Person();
		Class clazz = p.getClass();
		System.out.println(clazz.getName());
		
		//获取Person类的修饰
		int m = clazz.getModifiers();
		System.out.println(Modifier.isPublic(m));
		
		// Class类的获取方法：通过对象的[类.class方法]获取Class对象
		System.out.println(Person.class.getSimpleName());
		System.out.println(Person.class.getName());
		
		//  Class类的获取方法：通过Class.forName（"+全限定名"）获取Class对象
		try {
			System.out.println(Class.forName("com.hx.ref.Person").getName());
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	// 通过Class类创建对象
	@SuppressWarnings({ "unused", "rawtypes" })
	private static void test2() throws InstantiationException,
			IllegalAccessException {
		Class clazz = Person.class;
		Person p = (Person) clazz.newInstance();
		System.out.println(p);
	}

	// 获取Class类的父类以及实现的接口
	@SuppressWarnings({ "unused", "rawtypes" })
	private static void test3() throws InstantiationException,
			IllegalAccessException {
		Class clazz = Person.class;
		Class supclazz = clazz.getSuperclass();
		Class[] intefaces = clazz.getInterfaces();
		System.out.println(supclazz);
		priArray(intefaces);
	}

	// 获取Person类构造函数
	@SuppressWarnings({ "unused", "rawtypes" })
	private static void test4() throws InstantiationException,
			IllegalAccessException {
		Class clazz = Person.class;
		Constructor[] cons = clazz.getConstructors();
		priArray(cons);
	}

	// 获取字段和方法
	@SuppressWarnings({ "unused", "rawtypes" })
	private static void test5() throws InstantiationException,
			IllegalAccessException {
		Class clazz = Person.class;
		Field[] fiels = clazz.getDeclaredFields();
		priArray(fiels);

		Method[] methods = clazz.getDeclaredMethods();
		priArray(methods);
	}

	// 获取构造函数并构造对象
	@SuppressWarnings({ "unused", "rawtypes" })
	private static void test6() throws InstantiationException,
			IllegalAccessException, IllegalArgumentException,
			InvocationTargetException {
		//获取Class类对象
		Class clazz = Person.class;
		//获取构造函数
		Constructor[] cons = clazz.getDeclaredConstructors();
		priArray(cons);
		//拿到一个构造函数
		Constructor c = cons[0];
		//获取该构造函数的参数列表的类类型
		Class[] paraClazz = c.getParameterTypes();
		//如果参数列表为0，则直接new对象
		if (paraClazz.length == 0) {
			Object o = c.newInstance(new Object[] {});
			System.out.println(o);
		} else {
			// 构建参数列表
			Object[] paras = new Object[paraClazz.length];
			for (int i = 0; i < paraClazz.length; i++) {
				//通过GETVALUE方法，该每个参数列表付初始值
				paras[i] = getValue(paraClazz[i]);
			}
			Object result = c.newInstance(paras);
			System.out.println("result:" + result);
		}
	}

	// 操作字段
	@SuppressWarnings({ "rawtypes", "unused" })
	private static void test7() throws Exception {
		Class clazz = Person.class;
		//构造实例
		Object person = clazz.newInstance();
		//获取所有字段
		Field[] field = clazz.getDeclaredFields();

		//遍历所有属性
		for (int i = 0; i < field.length; i++) {
			int m = field[i].getModifiers();
			//排除Static属性异己非私有属性
			if (Modifier.isStatic(m) || !Modifier.isPrivate(m)) {
				continue;
			}
			//拿到属性名字
			String fieldname = field[i].getName();
			//拼set方法
			String setterName = "set"
					+ Character.toUpperCase(fieldname.charAt(0));
			if (fieldname.length() > 1) {
				setterName = setterName + fieldname.substring(1);
			}
			@SuppressWarnings("unchecked")
			//获取set方法
			Method m1 = clazz.getDeclaredMethod(setterName,
					new Class[] { field[i].getType() });
			//通过方法为属性设置值
			m1.invoke(person, new Object[] { getValue(field[i].getType()) });
		}

		System.out.println("person:" + person);
	}

	// 操作字段2
	@SuppressWarnings("unused")
	private static void test8() throws InstantiationException,
			IllegalAccessException {
		@SuppressWarnings("rawtypes")
		Class clazz = Person.class;
		Object p1 = clazz.newInstance();
		Field[] fields = clazz.getDeclaredFields();
		for (int i = 0; i < fields.length; i++) {
			int m = fields[i].getModifiers();
			if (Modifier.isStatic(m) || !Modifier.isPrivate(m)) {
				continue;
			}
			// 破坏了封装性
			fields[i].setAccessible(true);
			fields[i].set(p1, getValue(fields[i].getType()));
		}

		System.out.println("p1:" + p1);
	}

	// 操作数组
	@SuppressWarnings("unused")
	private static void test9() throws Exception{
		List<String> plist = new ArrayList<String>();
		plist.add("张三");
		plist.add("李四");

		Class<?> clazz = plist.getClass();
		Method m = clazz.getMethod("add", Object.class);
		//说明了泛型只在编译阶段会检查，运行阶段没有泛型一说
		m.invoke(plist, new Integer(999));

		System.out.println("plist:" + plist);
	}

	//数组的拷贝
	@SuppressWarnings({ "unused", "unchecked" })
	private static <T> T[] arrayCopyandIncres(T[] array, int times,Class<T> clazs) {
		// 获取数组中的存储类型
		Class<?> clazz = array.getClass().getComponentType();
		Object newArray = Array.newInstance(clazz, array.length * times);
		for (int i = 0; i < array.length; i++) {
			Array.set(newArray, i, array[i]);
		}
		return (T[]) newArray;
	}

	@SuppressWarnings("rawtypes")
	private static Object getValue(Class clazz) {
		if (clazz == Boolean.class || clazz == Boolean.TYPE) {
			return Boolean.TRUE;
		}
		if (clazz == Byte.class || clazz == Byte.TYPE) {
			return Byte.valueOf((byte) 100);
		}
		if (clazz == Short.class || clazz == Short.TYPE) {
			return Short.valueOf((short) 200);
		}
		if (clazz == Character.class || clazz == Character.TYPE) {
			return Character.valueOf('a');
		}
		if (clazz == Integer.class || clazz == Integer.TYPE) {
			return Integer.valueOf(300);
		}
		if (clazz == Long.class || clazz == Long.TYPE) {
			return Long.valueOf(400L);
		}
		if (clazz == Float.class || clazz == Float.TYPE) {
			return Float.valueOf(50.0F);
		}
		if (clazz == Double.class || clazz == Double.TYPE) {
			return Double.valueOf(100.0);
		}
		// String 类型
		if (clazz == String.class) {
			return "Hello";
		}
		// 如果还没匹配到，那该类型一定是引用类型，返回null
		return null;
	}

	
	private static void priArray(Object[] obj) {
		for (int i = 0; i < obj.length; i++) {
			System.out.println(obj[i]);
		}
	}
}

六、部分运行结果：

七、总结

Java反射是Java中比较高级的知识；第一次接触会有点不可思议；会觉得不太好理解；

我觉得首先的得对反射这块的知识有所了解，然后通过自己写代码掌握好这些反射的API以及使用；

其实反射这块我也花了很长的时间才能慢慢理解；写这篇博客的时候，我已经前后两次接触Java反射了；

今天写博客再次整理这块知识的时候觉得比以前好很多了；

所以，坚持不要放弃，到最后你总会懂的；就像以前初中学知识，我感觉好多地方学得模模糊糊的，后来 来到大学给初中生做家教的时候再去看那些知识，觉得好简单；我觉得这有两个方面的原因：一是随着年龄的增长，自己的理解力变强了；二是因为通过高中的学习以及大学的学习，不断的学习让自己的思维发生了很大的变化；我觉得第二点更能说明；所以，只要坚持不懈的努力学习，任何难点都不会是难点；我们的技术也会越来越强；

共勉！