Java反射机制简析(简单实例)

一、Java反射机制：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
二、反射机制常用类

1. java.lang.Class;
2. java.lang.reflect.Constructor;
3. java.lang.reflect.Field;
4. java.lang.reflect.Method;
5. java.lang.reflect.Modifier;

三、Class类的使用

• 任何一个类都是java.lang.class的实例化对象，称为该类的类类型
• 1）三种表示方式

class foo{};

foo foo1=new foo();
A、 Class c1=foo.class;//任何一个类都有隐含的静态成员变量class

B、 Class c2=foo1.getClass();//可以通过对象的getClass方法获得
实例化

C、 Class c3=null; c3=Class.forName("com.lt.Foo")；

注：c1=c2 表明一个类只可能是class类的一个实例对象
2、创建类类型的实例化对象
Foo foo=(foo)c1.newInstance()；

四、通过反射获取类的名称和方法信息

• Class类的基本API操作

1、c.getName();//获取类的名称
2、c.getSimpleName();//不包含包名的类的名称
3、c.getMethods();//获取类的【所有方法】集合,【所有方法都是Method类的对象】
4、c.getDeclaredMethods();//获取的是所有该类【自己声明】的方法，【不问访问权限】

• Method类API操作

1、.getReturnType();//得到该方法的返回值类型的类类型（class），如int.class String.class
2、.getName();//得到方法的名称
3、.getParameterTypes();//获得参数列表类型的类类型，如参数为(int,int)则得到(int.class ,int class)

/***
     * 打印类的信息,包括类的成员函数，成员变量
     * @param obj 该对象所属的类的信息
     */
    public static void printMethodMessage(Object obj) {
        //获取类的信息，首先获取类的类类型
        Class c = obj.getClass(); //传递的是哪个子类的对象, c就是该子类的类类型

        System.out.println("类的名称是："+c.getName());
        Method[] methods = c.getMethods();
        for(Method m : methods) {
            System.out.println("方法名："+m.getName());
            System.out.println("返回值: " + m.getReturnType());

            Class[] parameterTypes = m.getParameterTypes();
            System.out.print("参数类型： ");
            for(Class cc : parameterTypes){
                System.out.print(cc.getName());
            }
            System.out.println();
            System.out.println("--------------------------------");

        }

    }

• 调用： ClassUtil.printMethodMessage(“hello”);

五、获取成员变量信息

• 成员变量是java.lang.reflect.Field的对象

1、Field类封装了关于成员变量的操作
2、Field[] fs = c.getFields()方法获取所有public的成员变量Field[]信息
3、c.getDeclaredFields()获取的是该类自己声明的成员变量信息
4、field.getType()获得成员类型的类类型
5、field.getName()获得成员的名称

/***
     * 打印成员变量信息
     * @param obj
     */
    public static void printFiledMessage(Object obj) {
        //获取类的信息，首先获取类的类类型
        Class c = obj.getClass(); //传递的是哪个子类的对象, c就是该子类的类类型
        //获取public成员变量信息
//      Field[] fields = c.getFields();
        // 这个是获取自定义的所有成员变量信息  建议用这个
        Field[] fields = c.getDeclaredFields(); 

        for(Field f : fields){
            System.out.println("变量类型: "+ f.getType()+"变量名："+f.getName());
        }
    }

调用：ClassUtil.printFiledMessage(“hello”);

六、获取类的构造方法信息

• 构造函数是java.lang.Constructor类的对象

1、通过Class.getConstructor()获得Constructor[]所有公有构造方法信息
2、建议getDeclaredConstructors()获取自己声明的构造方法
3、Constructor.getName()获取构造方法名称
4、Constructor.getParameterTypes()获取构造方法参数

/***
     * 获取构造方法
     * @param obj
     */
    public static void printConstructMessage(Object obj) {
        //获取类的信息，首先获取类的类类型
        Class c = obj.getClass(); //传递的是哪个子类的对象, c就是该子类的类类型
        //获取所有public构造方法
//      Constructor[] cons = c.getConstructors(); 
        //获取所有构造方法
        Constructor[] cons = c.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.print(con.getName()+"( ");
            Parameter[] parameters = con.getParameters();
            for (Parameter parameter : parameters) {
                System.out.print(parameter.getParameterizedType()+ " ");
                System.out.print(parameter.getName());
            }
            System.out.println( ")");
        }
    }

调用：ClassUtil.printConstructMessage(“hello”);

七、方法反射的基本操做

• 方法的反射：

1.获取A类中的print(int,int)方法：
①要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
A a1=new A();
Class c= a1.getClass();
②获取方法 由名称和参数列表来决定,getMethod获取的是public方法，getDelcaredMethod获取自己声明的方法
Method m =c.getMethod(methodName,paramtypes);//paramtypes可以用数组的形式表示new Class[]{int.class,int.class}，也可以直接列举类类型
2.方法的反射操作：是用m对象来进行方法调用，和a1.print(10,20)调用的方法相同m.invoke（a1，new Object[]｛10,20｝）
Object o=m.invoke(对象名,参数);//方法如果没有返回值返回null，如果有返回值返回具体值，参数可用数组的方式表示，也可以直接列举，没有参数就不写

package com.lt;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/***
 * 通过反射的方式来调用 A 的方法
 * @author liaot
 *
 */
public class MethodReflect {
    public static void main(String[] args) {
        //创建A类的对象
        A a1 = new A();
        //获取a1的类类型
        Class c1 = a1.getClass(); 
        //通过反射的方式获取方法      第一个参数为方法名， 第二为参数列表
        try {
            //调用方法1
            Method m1 = c1.getMethod("print", int.class);
            m1.invoke(a1, 520);

            //调用方法2
            Method m2 = c1.getMethod("print", int.class, int.class);
            m2.invoke(a1, 520, 1314);

        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}


class A {
    public void print(int a){
        System.out.println("我有一个参数: "+ a);
    }
    public void print(int a, int b){
        System.out.println("我有两个参数： " + a + " 和  "+ b);
    }
}

八、通过反射了解集合泛型的本质

1：反射的操作都是编译之后的操作，即运行阶段
2：java中集合的泛型是防止输入错误；只在编译阶段有效，绕过编译则无效，集合的在编译之后是去泛型的

eg：

ArrayList list1=new ArrayList();
ArrayList<String> list2=new ArrayList<String>();
Class c1=list1.getClass();
Class c2=list2.getClass();
System.out.print(c1==c2);//true
Method m=c2.getMethod("add",Object.class);
m.invoke(list1, 20);//绕过编译操作就绕过了泛型
System.out.println(list1);//不能直接foreach list2集合的，会报类型转换错误