什么是反射

反射（Reflection）是java的特征之一。

1 能够在运行时动态检查类自身的类和方法。
2 能够获得java类中各个成员的名称并显示出来。

javaBean是reflection的实际运用之一。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// src/HelloWorld.java
public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            Class c = Class.forName("Javass.c10.HelloWorld");
            Method ms[] = c.getDeclaredMethods();
            for (Method a : ms) {
                System.out.println(a.getName()+"->"+a.getReturnType().getName());
            }

        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

二、动态构造一个类，并动态调用其方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public static void main(String[] args) {
        try {
            Class c = Class.forName("Javass.c10.HelloWorld");
            Class paramtype[] = new Class[2];
            paramtype[0] = Integer.TYPE;//int 
            paramtype[1] = String.class;

            Constructor cs = c.getConstructor(paramtype);
            Object param[] = new Object[2];
            param[0] = 100;
            param[1] = "sunquan";
            //dynamic create one Class
            Object hellwd = cs.newInstance(param);
            System.out.println( hellwd.toString());

            //动态构造一个方法
            Class methodParamType[] = new Class[1];
            methodParamType[0] = Integer.class;//int   
            Method MgetName = c.getMethod("getName", methodParamType);
            Object mParam[] =new Object[1];
            mParam[0] = 10000;

            //入参(该类的实例,方法 实参列表) ret是该方法的返回值
            Object ret= MgetName.invoke(hellwd, mParam);
            System.out.println(ret);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

三、反射方式使用多维数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static void main(String[] args) {
        int dimens[]= new int[]{4,5,6};
        //反射: 创建一个三维数组
        Object arr = Array.newInstance(Integer.TYPE,dimens);
         
        //二维数组
        Object twoDimen= Array.get(arr, 1);
        //一位数组
        Object oneDimen= Array.get(twoDimen,1);
        //给元素a[1][1][1]赋值
        Array.set(oneDimen, 1, 100);
        int a[][][] = (int [][][]) arr;
        System.out.println(a[1][1][1]+"==="+a[1][1][2]);
    }

3F 实现一个类,似于JavaBean反射动态实例化一个类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

public class JavaBeanDemo {
    /**
     * 实现: 写一个通用的工具方法 传入一个包含值的map<key-对象属性名,value-值>
     * 传入任意的model，构造一个对象实例，然后把map中的值赋给该实例。
     * @param map 字段名和值
     * @param cls 类信息
     * @return 返回cls类实例
     */
    public Object Reflection(Map map, Class cls) throws Exception {
        Object obj = null;
        // 1 首先创建该类的实例
        obj = cls.newInstance();
        // 2 然后通过反射拿到这个对象的所有属性
        Field fd[] = cls.getDeclaredFields();

        // 3 遍历对象属性,给对象实例赋值
        for (Field onefd : fd) {
            String fieldname = onefd.getName();
            // 如果存在该字段
            if (map.containsKey(fieldname)) {
                Class fieldtype = onefd.getType();
                String setName = "set"+ fieldname.substring(0, 1).toUpperCase() + fieldname.substring(1);
                // System.out.println(setName);
                Method md = cls.getMethod(setName, fieldtype);
                // 调用方法给属性赋值
                md.invoke(obj, map.get(fieldname));
            }
        }
        // 4 返回该实例
        return obj;
    }

    public static void main(String[] args) {
        JavaBeanDemo sq = new JavaBeanDemo();
        HashMap<String, Object> map = new HashMap<>();
        map.put("uuid", 100);
        map.put("name", "sunquan");
        map.put("grade", 98.99);
        Model mdl;
        try {
            mdl =(Model) sq.Reflection(map, Model.class);
            System.out.println(mdl);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}