篇六：Java反射基础

一、反射机制定义

　　状态：运行状态

　　1、对于任意一个类，获取该类所有的属性和方法；

　　2、对于任意一个对象，可以调用该类的所有方法和属性。

　　动态获取类的属性、方法和调用对象的属性和方法的功能叫做反射

 

二、反射机制作用

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

　　2、在运行时，构建任何一个类的对象；

　　3、在运行时，判断任意一个类所有的属性和方法；

　　4、在运行时，调用任意一个对象的所有属性和方法；

　　5、生成动态代理。

 

三、Class类理解与API

　　1、Class类理解

　　　 基础：Class类实例是Java运行时的类(enum/interface/annotation/class)，每个Java类运行时在JVM中表现为一个class对象

　　　 JVM中表现class对象的类型：boolean，byte，char，short，int，long，float，double，void，array，enum，interface，annotation，class

　　2、获取Class类对象--实例化

　　　 a、类名.class

  　　  b、类型.getClass()

　　　 c、Class.forClass("路径/类名")

　　3、常用API

public static Class<?> forName(String className) ：natice 方法，动态加载类
public T newInstance() ：根据对象的class新建一个对象，用于反射
public ClassLoader getClassLoader() ：获得类的类加载器Bootstrap
public String getName() ：获取类或接口的名字(包名、类名)。记住enum为类，annotation为接口
public String getSimpleName()：获取类或接口的名字（类名）
public native Class getSuperclass()：获取类的父类，继承了父类则返回父类，否则返回java.lang.Object
public java.NET.URL getResource(String name) ：根据字符串获得资源
public Constructor<?>[] getConstructors() ：获得所有的构造函数。
public boolean isEnum() ：判断是否为枚举类型。
public native boolean isArray() ：判断是否为数组类型。
public native boolean isPrimitive() ：判断是否为基本类型。
public boolean isAnnotation() ：判断是否为注解类型。
public Package getPackage() ：反射中获得package，如java.lang.Object 的package为java.lang。
public native int getModifiers() ： 反射中获得修饰符，如public static void等 。
public Field getField(String name)：反射中获得域成员。
public Field[] getFields() :获得域数组成员。    
public Method[] getMethods() ：获得方法。
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)：加个Declared代表本类，继承，父类均不包括。
public Constructor<?>[] getConstructors() ：获得所有的构造函数。

  

四、实例

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 org.junit.Test;
import com.common.model.user.UserInfo;

/**
 * 反射测试
 * @author liuguangping
 *
 */
//@RunWith(SpringJUnit4ClassRunner.class)  
//@ContextConfiguration(locations = {"classpath*:spring/spring-context.xml"})
public class ReflectTest extends BaseTest{

    @Test
    public void test(){
        try {
            UserInfo info = new UserInfo();
            //获取Class实例和类名
            System.out.println("--------------获取Class实例和类名--------------");
            Class<?> class1 = UserInfo.class;
            Class<?> class2 = info.getClass();
            Class<?> class3 = Class.forName("com.common.model.user.UserInfo");
            
            System.out.println("class1--包名、类名:"+class1.getName());
            System.out.println("class2--包名、类名:"+class2.getName());
            System.out.println("class3--包名、类名:"+class3.getName());
            System.out.println("class3--类名:"+class3.getSimpleName());
            
            
            //获取父类及继承的接口
            System.out.println("---------------获取父类及继承的接口-------------");
            Class<?> parentClass = class1.getSuperclass();
            System.out.println("父类："+parentClass.getName());
            Class<?>[] interfaces = class1.getInterfaces();
            for(int i=0;i<interfaces.length;i++){
                System.out.println(i+1+":"+interfaces[i].getName());
            }
            
            //获取类的全部构造函数
            System.out.println("---------------获取类的全部构造函数-------------");
            Constructor<?>[] cons =  class1.getConstructors();
            for(int i=0;i<cons.length;i++)
            {
                StringBuffer buffer = new StringBuffer("cons"+i+1+":");
                Class<?>[] clazz = cons[i].getParameterTypes();
                for(int j=0;j<clazz.length;j++)
                {
                    buffer.append(clazz[j].getName());
                }
                System.out.println(buffer.toString());
            }
            
            //反射实例化对象
            System.out.println("---------------反射实例化对象-------------");
            UserInfo userInfo = (UserInfo) class1.newInstance();
            userInfo.setRealName("张三");
            System.out.println(userInfo.getRealName());
            
            //获取本类的全部属性
            System.out.println("----------------获取本类的全部属性------------");
            Field[] field = class1.getDeclaredFields();
            for(int i=0; i<field.length;i++)
            {
                //获取权限修饰符
                int mo = field[i].getModifiers();
                String priv = Modifier.toString(mo);
                //获取属性类型
                Class<?> type = field[i].getType();
                System.out.println(priv+"--"+type.getName()+"--"+field[i].getName());
            }
            
            //获取本类和父类的全部属性
            System.out.println("----------------获取本类和父类的全部属性------------");
            Field[] attrs = class1.getFields();
            for(int i=0; i<attrs.length;i++)
            {
                //获取权限修饰符
                int mo = attrs[i].getModifiers();
                String priv = Modifier.toString(mo);
                //获取属性类型
                Class<?> type = attrs[i].getType();
                System.out.println(priv+"--"+type.getName()+"--"+attrs[i].getName());
            }
            
            //获取某个类的全部方法
            System.out.println("获取某个类的全部方法");
            Method[] methods = class1.getDeclaredMethods();
            for(Method method:methods){
                //获取权限
                int modifier = method.getModifiers();
                String priv = Modifier.toString(modifier);
                //获取返回值类型
                Class<?> returnClass = method.getReturnType();
                String returnStr = returnClass.getName();
                //获取方法
                String methodName = method.getName();
                //获取入参
                Class<?>[] pars = method.getParameterTypes();
                StringBuffer buffer = new  StringBuffer("(");
                for(Class<?> par:pars){
                    buffer.append(par.getTypeName());
                    buffer.append(" ");
                    buffer.append(par.getName());
                    buffer.append(",");
                }
                String params = buffer.append(")").toString();
                System.out.println(priv+" "+returnStr+" "+methodName+params);
            }
            
            //获取本类、父类的全部方法
            System.out.println("---------------获取本类、父类的全部方法--------------");
            Method[] localMethods = class1.getMethods();
            for(Method method:localMethods){
                //获取权限
                int modifier = method.getModifiers();
                String priv = Modifier.toString(modifier);
                //获取返回值类型
                Class<?> returnClass = method.getReturnType();
                String returnStr = returnClass.getName();
                //获取方法
                String methodName = method.getName();
                //获取入参
                Class<?>[] pars = method.getParameterTypes();
                StringBuffer buffer = new  StringBuffer("(");
                for(Class<?> par:pars){
                    buffer.append(par.getTypeName());
                    buffer.append(" ");
                    buffer.append(par.getName());
                    buffer.append(",");
                }
                String params = buffer.append(")").toString();
                System.out.println(priv+" "+returnStr+" "+methodName+params);
            }
            
            //反射执行方法--getDeclaredMethod("方法名",入参类型.class,...,入参类型.class)
            System.out.println("--------------反射执行方法------------");
            Method setRealName = class1.getDeclaredMethod("setRealName", String.class);
            UserInfo user = new UserInfo();
            setRealName.invoke(user, "刘广平");
            Method getRealName = class1.getDeclaredMethod("getRealName");
            String realName = (String) getRealName.invoke(user);
            System.out.println(realName);
            
            //反射操作属性
            System.out.println("--------------反射操作属性------------");
            UserInfo userPar = (UserInfo) class1.newInstance();
            Field realNamePar = class1.getDeclaredField("realName");//获取属性对象
            realNamePar.setAccessible(true);
            realNamePar.set(userPar, "张三");
            System.out.println(realNamePar.get(userPar));
            System.out.println(userPar.getRealName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

}