反射在Java中的应用

1 反射的操作都是编译之后的操作

		ArrayList<Integer> intList = new ArrayList<Integer>();
		ArrayList<String> strList = new ArrayList<String>();
		
		intList.add(1000);
		strList.add("我是字符串");
		
		@SuppressWarnings("rawtypes")
		Class c1 = intList.getClass();
		@SuppressWarnings("rawtypes")
		Class c2 = strList.getClass();
		
		System.out.println(c1 ==c2);

c1==c2结果返回true说明编译之后集合的泛型是去泛型化的，java中集合的泛型，是防止错误输入，只在编译阶段有效， 绕过编译就无效了！

@SuppressWarnings("unchecked")
			Method m =c2.getMethod("add", Object.class);
			m.invoke(intList, "1000");
			System.out.println(intList.size());

验证：我们可以通过方法的反射来验证，绕过编译！

2 万物皆对象，就连类都是

类的类类型是Class，也就是说Class类的实例对象是类。

		@SuppressWarnings("rawtypes")
		Class c1 = int.class;//int的类类型
		@SuppressWarnings("rawtypes")
		Class c2 = String.class;//String类的类类型，String类字节码
		@SuppressWarnings("rawtypes")
		Class c3 = double.class;//double的类类型
		@SuppressWarnings("rawtypes")
		Class c4 = Double.class;//Double的类类型
		@SuppressWarnings("rawtypes")
		Class c5 = void.class;//void的类类型
		
		System.out.println(c1.getName());//不包含包名的类名称
		System.out.println(c2.getSimpleName());
		System.out.println(c3.getName());
		System.out.println(c4.getName());
		System.out.println(c5.getName());

String类本身也是一个实例对象，Class类的实例对象，任何一个类都是Class的实例对象。

//String的实例对象如何表示，s即是。
		String s = new String();
		
		//String类本身也是一个实例对象，Class类的实例对象
		//任何一个类都是Class的实例对象
		
		//1.实际告诉我们任何一个类都有一个隐含的静态成员变量Class
		@SuppressWarnings("rawtypes")
		Class c1 = String.class;
		
		//2.已知该类的对象通过getClass方法
		@SuppressWarnings("rawtypes")
		Class c2 = s.getClass();
		
		@SuppressWarnings("rawtypes")
		Class c3 = Class.forName("java.lang.String");
		
		//c1，c2表示了String类的类类型（class type）,万事万物皆为对象；
		//类也是对象，是Class类的实例对象，这个对象我们称为该类的类类型
		
		//一个类只能有一个Class类实例对象
		System.out.println(c1==c2&&c2==c3);
		
		//可以通过类的类类型创建该类的对象实例
		String str = (String)c1.newInstance();//需要有无参的构造方法
		str ="我是谁";
		System.out.println(str.length());

3 静态加载类与动态加载类

new创建对象是静态加载类，在编译时刻就需要加载所有可能使用到得类

Class.forName(),动态加载类，在运行时刻加载

4 动态加载类的三种方式

		@SuppressWarnings("rawtypes")
		Class c1 = String.class;
		
		//2.已知该类的对象通过getClass方法
		@SuppressWarnings("rawtypes")
		Class c2 = s.getClass();
		
		@SuppressWarnings("rawtypes")
		Class c3 = Class.forName("java.lang.String");

5 例子：获取私有变量的变量名以及变量值

（用于替代数据库字典，无需经常修改的字典）

package com.hrhx.mcc.bean;
/**
 * 
 * @author dhm
 *
 */
@SuppressWarnings("unused")
public class SmokeAirConstants {
	/**
	 * 污染物-二氧化硫
	 */
	private static final String POLLUTANT_SO2="二氧化硫" ;
	/**
	 * 污染物-氮氧化物
	 */
	private static final String POLLUTANT_NOX="氮氧化物" ;
	/**
	 * 污染物-烟尘
	 */
	private static final String POLLUTANT_DUST="烟尘" ;
	/**
	 * 运行情况类别-机组运行时间
	 */
	private static final String CONDITION_TYPE_RUN="机组运行时间";
	/**
	 * 运行情况类别-达标排放时间
	 */
	private static final String CONDITION_TYPE_NORMAL="达标排放时间";
	/**
	 * 运行情况类别-超限值1倍以内时间(h)
	 */
	private static final String CONDITION_TYPE_1="超限值1倍以内时间(h)";
	/**
	 * 运行情况类别-超标1倍以上5倍以下时间(h)
	 */
	private static final String CONDITION_TYPE_15="超标1倍以上5倍以下时间(h)";
	/**
	 * 运行情况类别-招标5倍及以上时间(h)
	 */
	private static final String CONDITION_TYPE_5="招标5倍及以上时间(h)";
	/**
	 * 运行情况类别-客观原因时间(h)
	 */
	private static final String CONDITION_TYPE_UNNORMAL="客观原因时间(h)";
}

package com.hrhx.mcc.util;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

import org.junit.Test;

public class ClassReflectUtil {
	public Map<String,String> getConstantsByClass(String clazzStr,String fieldNameEquals){
		Map<String,String> map = new HashMap<String,String>();
		try {
			@SuppressWarnings("rawtypes")
			Class clazz= Class.forName(clazzStr);
			Field[] fs = clazz.getDeclaredFields();
			for(Field field:fs){
				//成员变量的名称
				String fieldName = field.getName();
				if(fieldName.startsWith(fieldNameEquals)){
					// 通过类的字节码得到该类中声明的所有属性，无论私有或公有
			        Field fieldPassword = clazz.getDeclaredField(fieldName);
			        // 设置访问权限（这点对于有过android开发经验的可以说很熟悉）
			        fieldPassword.setAccessible(true);
					// 得到私有的变量值
			        Object value = fieldPassword.get(clazz.newInstance());
			        map.put(fieldName, value.toString());
			        // 输出私有变量的值
			        // System.out.println(value.toString());
				}
			}
		return map;
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return map;
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return map;
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();	
			return map;
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();	
			return map;
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return map;
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return map;
		}
	}
	@Test
	public void test(){
		Map<String,String> map = this.getConstantsByClass("com.hrhx.mcc.bean.SmokeAirConstants", "POLLUTANT_");
		System.out.println(map.size());
	}
}

6 例子：打印类的信息，包括类的成员函数，成员变量，构造函数

package hrhx.dhm.util;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ClassUtil {
	/**
	 * 打印类的信息，包括类的成员函数，成员变量，构造函数
	 * @param obj
	 */
	public static void printMethodMessage(Object obj){
		
		//要获取类的信息，首先要获取类的类类型
		Class c = obj.getClass();
		System.out.println("类的名称是："+c.getName());
		
		/**
		 * Method类，方法对象
		 * 一个成员方法就是一个Method对象
		 */
		Method[] ms = c.getMethods();//所有的public的函数，包括父类继承而来的
		Method[] ms_ext = c.getDeclaredMethods();//获得该类自己声明的方法，不问访问权限
		for(int i=0;i<ms.length;i++){
			//返回值类型
			Class returnType = ms[i].getReturnType();
			System.out.print(returnType.getName()+" ");
			//方法的名称
			System.out.print(ms[i].getName()+"(");
			//参数列表
			Class[] paraTypes = ms[i].getParameterTypes();
			int j = 0;
			for(Class clazz:paraTypes){
				System.out.print(clazz.getName());
				if(j!=paraTypes.length-1){
					System.out.print(",");
				}
				j++;
			}
			System.out.println(")");
		}
	}

	public static void printFieldMessage(Object obj) {
		//要获取类的信息，首先要获取类的类类型
		Class c = obj.getClass();
		System.out.println("类的名称是："+c.getName());
		/**
		 * 成员变量也是对象
		 * java.lang.reflect.Feild
		 * Field类封装关于成员变量的操作
		 */
		Field[] fs = c.getDeclaredFields();
		for(Field field:fs){
			//成员变量的类型的类类型
			Class fieldType = field.getType();
			String typeName = fieldType.getName();
			//成员变量的名称
			String fieldName = field.getName();
			System.out.println(typeName+" "+fieldName);
		}
	}
	
	public static void printConMessage(Object obj){
		//要获取类的信息，首先要获取类的类类型
		Class c = obj.getClass();
		System.out.println("类的名称是："+c.getName());
		Constructor[] cs = c.getConstructors();
		Constructor[] cs_ext = c.getDeclaredConstructors();
		for(Constructor constructor:cs){
			System.out.print(constructor.getName()+"(");
			Class[] paraTypes  = constructor.getParameterTypes();
			int j = 0;
			for(Class clazz:paraTypes){
				System.out.print(clazz.getName());
				if(j!=paraTypes.length-1){
					System.out.print(",");
				}
				j++;
			}
			System.out.println(")");
		}
	}
	
}