java通过反射调类中的某个方法和获得类中的元素。

使用java的反射机制获得类中的方法并执行方法：

执行某个方法：

实体类：

package com.xy.user;
/*
 * description 实体类
 */
public class Users {
	private String userName;
	
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
}

测试类：

package com.xy.user;
public class Test {
    public static void main(String[] args) throws Exception {
        Test test = new Test();
        Users user = new Users();
        test.execute(user, "com.xy.user.Users",
                "setUserName", "许阳");
        System.out.println(user.getUserName());
    }

    public void execute(Object obj, String className, String methodName,
            String paramerValue) throws Exception {
        
            /*
             * 首先根据完整的包名+类名获得类的Class,不是class
             * Class就是类的类，用来描述某个类有那些字段，方法，构造器等。
             * 这样也可以获得实体类,即参数中的invoke参数中的obj：
             * Users user =(Users)Class.forName("com.xy.user.Users").newInstance();
             * 也可以这样获得Class：Users user = new Users(); Class cls = user.getClass();
             */
            Class cls = Class.forName(className);
            /*
             * 获得到class,class的getMethod(方法名，参数类型)可获得class中的某方法.
             * 一个class可能有多个名字一样，参数不同的方法，所以要用方法名和参数类型来获得。
             * 如果有多个参数,使用cls.getMethod(methodName, new Class[] { int.class,String.class })
             */
            Method method = cls.getMethod(methodName, String.class);
            //通过反射执行方法。invoke(类，参数值);
            method.invoke(obj, paramerValue);
    }
}

运行结果：

许阳

例子：

package com.xy.reflect;

import java.lang.reflect.*;
 
public class Test {
   public String name;
   private int age=25;
   String password;
   public static void main(String [] args) throws Exception{
       Test obj = new Test();
       Class  cls = obj.getClass();
       Field[] fields = cls.getDeclaredFields();
       for(Field f : fields){
           System.out.println("name :" + f.getName());
           System.out.println("type :" + f.getType().getName());
           System.out.println("class :" + f.getDeclaringClass());
           System.out.println("value :" + f.get(obj));
           int mod = f.getModifiers();
           System.out.println("modifiers :"+ Modifier.toString(mod));
           System.out.println("------------------------");
       }
   }
}

执行的结果：

name :name
type :java.lang.String
class :class com.xy.reflect.Test
value :null
modifiers :public
------------------------
name :age
type :int
class :class com.xy.reflect.Test
value :25
modifiers :private
------------------------
name :password
type :java.lang.String
class :class com.xy.reflect.Test
value :null
modifiers :
------------------------
备注：

Field(method)的getModifiers()方法返回int类型值表示该字段的修饰符。其中，该修饰符是java.lang.reflect.Modifier的静态属性。

对应表如下：

PUBLIC: 1  PRIVATE: 2  PROTECTED: 4  STATIC: 8
FINAL: 16  SYNCHRONIZED: 32     VOLATILE: 64     TRANSIENT: 128
NATIVE: 256   INTERFACE: 512      ABSTRACT: 1024    STRICT: 2048

可以通过Modifier.toString(int mod)得到对应的修饰符;

通过反射获得类中的元素：

获得本类中的元素：

获得变量：

Class cl = 类名.class;
Field[] fs = cl.getField();//得到公用的变量(public)
Field[] fs1 = cl.getDeclaredField();//得到所有的变量(public private protect)

获得方法：

Class cl = 类名.class;
Method[] mt = cl.getMethod();//得到公共的方法(包括继承来的)
Method[] mt1 = cl.getDeclaredField();//得到所有的方法(不包括继承来的)

获得构造方法：

Class cl = 类名.class;
Constructor[] con = cl.getConstructor();//得到公共的构造函数(public)
Constructor[] con1 = cl.getDeclaredConstructor();//得到所有的构造函数(public,private,protect)

获得包名+类名：

Class cls = Test.class;
System.out.println(cls.getName());

获得方法返回值类型和参数类型：

Class cls = Class.forName("com.xy.Test");
Method[] med = cls.getMethods();
for(Method m :med){
	//得到返回值类型
	Class returnType = m.getReturnType();
	//得到参数类型，一个方法可能有多个参数
	Class paraType[] = m.getParameterTypes();
}

获得类加载器：

Class cls = Class.forName("com.xy.Test");
cls.getClassLoader().getClass().getName();

获得其他类的元素：

获得接口：

Class cls = Class.forName("com.xy.Test");
Class<?> inter = cls.getInterfaces();

获得父类：

Class cls = Class.forName("com.xy.Test");
Class<?> superClass = cls.getSuperclass();

其他：

获得Class的3种方式：

Class cls = Class.forName("com.xy.Test");
Class cls1 = Test.class;
Class cls2 = new Test().getClass();

通过Class反向得到类的实例：

Class cls = Class.forName("com.xy.Test");
Test test =  (Test)cls.newInstance();