java反射机制反射变量，方法

今天在项目中有一个特殊功能，思来想去的觉得使用反射机制实现比较简单

结合java-API和上网得到如下结果

 

 

package com.test;

 

import java.util.List;

 

 

/**

 * 需要反射的对象

 * @author Administrator

 *

 */

public class Reflect {

    /**申明一个复合对象*/

    static User user;

    /**

     * 获得User方法

     * @return

     */

    public User getUser() {

       return user;

    }

    /**

     * 申明只有一个参数的方法

     * @param user

     */

    public static void setUser(User user) {

       Reflect.user = user;

    }

    /**

     * 申明一个带有多个参数的方法

     * @param i

     * @param str

     */

    public final static void reflectMeshod(int i,String str) {

       System.err.println("i的值是："+i);

       System.err.println("str的值是："+str);

    }

    /**

     * 参数为list的方法

     * @param list

     */

    public final static void reflectMeshod(List<User> list){

       for(User user:list){

           System.err.println(" userList 的  item是："+user.getId());

       }

    }

    /***

     * 参数为数组的方法

     * @param userArg

     */

    public final static void reflectMeshod(User[] userArg) {

       System.err.println(userArg.length);

       for(int i = 0;i<userArg.length;i++){

           System.err.println("   userarrays  的item是            "+userArg[i].getId());

       }

    }

}

 

User类

package com.test;

/**

 * 一个复合类

 * @author Administrator

 *

 */

public class User {

    /**申明一个实例变量（字段）id*/

    private int id;

    /**

     * 设置实例变量的值的方法

     * @param id

     */

    public void setId(int id) {

       this.id = id;

    }

    /**

     * 获得Id的值的方法

     * @return

     */

    public int getId() {

       return id;

    }

}

测试类:

package com.test;

 

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.List;

 

public class Test {

    public static void main(String[] args) {

       try {

           /*通过反射机制获得Reflect的user变量*/

           Reflect test =new Reflect();

           User testUser = new User();

           testUser.setId(999);

           Field userField = Reflect.class.getDeclaredField("user");

           userField.set(test, testUser);

           System.err.println(test.getUser().getId());

           /*通过反射机制获得Reflect的user变量*/

           打印结果：999

           /*通过反射机制调用多个参数的方法*/

           Method method =   Reflect.class.getDeclaredMethod("reflectMeshod",            int.class,String.class);

           method.invoke(test, 123,"String Test");

           /*通过反射机制调用多个参数的方法*/

           打印结果：

              i的值是：123

            str的值是：String Test

           /*通过反射机制调用参数为list的方法*/

           List<User> userList = new ArrayList<User>();

           User user = new User();

           user.setId(987);

           User user1 = new User();

           user1.setId(654);

           User user2 = new User();

           user2.setId(321);

           userList.add(user);

           userList.add(user1);

           userList.add(user2);

           Method listMethod = Reflect.class.getDeclaredMethod("reflectMeshod", List.class);

           listMethod.invoke(test,userList);

           /*通过反射机制调用参数为list的方法*/

           打印结果：

              userList 的  item是：987

            userList 的  item是：654

            userList 的  item是：321

           /*通过反射机制带哦用参数为数组的方法*/

           User[] userArray = new User[3];

           User arrayItem1 = new User();

           arrayItem1.setId(123);

           User arrayItem2 = new User();

           arrayItem2.setId(456);

           User arrayItem3 = new User();

           arrayItem3.setId(789);

           userArray[0]=arrayItem1;

           userArray[1]=arrayItem2;

           userArray[2]=arrayItem3;

           Method arrayMethod = Reflect.class.getDeclaredMethod("reflectMeshod", new Class[]{User[].class});

           arrayMethod.invoke(test,new Object[]{userArray});

           /*通过反射机制带哦用参数为数组的方法*/

            打印结果：

              userarrays  的item是            123

            userarrays  的item是            456

            userarrays  的item是            789

        } catch (Exception e) {

           // TODO: handle exception

           e.printStackTrace();

       }

    }

}