java的反射

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

　　

 1 package com.www.invoke;

import java.lang.reflect.Method;

/**
 * 通过反射操作 类的方法
 * java的反射 是说的是运行时 。
 * 反射的总结：
 * 1，每个类都有与之对用的Class对象。
 * 2，每个方法都有与之对用的Method对象。
 * 3，每个成员变量都有与之对用的Field对象。
 * 4，第一步都是获得类对应的Class对象。
 * 5，通过反射可以获得私有的成员变量和方法。
 * @author Kelly.chen
 *
 */
public class InvokeTest {
    
    public int add(int a, int b){
        return a + b;
    }
    
    public String getName(String name){
        return "My name is "+name;
    }
    
    public static void main(String[] args) throws Exception {
        //获得类对应的的Class对象        方法一
        //Class<?> classType = InvokeTest.class;
        //获得类对应的Class对象        方法二
        Class<?> classType = Class.forName("com.www.invoke.InvokeTest");  
        //获得InvokeTest 的一个对象 相当于 InvokeTest invokeTest = new InvokeTest();
        Object invokeTest = classType.newInstance(); 
        //测试是不是 InvokeTest的对象  结果是 ture
        System.out.println(invokeTest instanceof InvokeTest);  
        
        //获得 add() 方法
        //第一个参数是方法的名字，第二个参数是Class类型的可变参数，与方法的参数对应
        Method addMethod = classType.getMethod("add", new Class[]{int.class, int.class});
        
        System.out.println(addMethod.getName());
        //调用方法
        //第一个参数是那个对象的方法，第二个参数是Object类型的可变参数，与方法参数对应
        Object object = addMethod.invoke(invokeTest, new Object[]{2, 3}); 
        
        System.out.println(object);
        
        //获得getName()方法
        Method getNameMethod = classType.getMethod("getName", new Class[]{String.class});
        //调用getName()方法
        Object objectName = getNameMethod.invoke(invokeTest, new Object[]{"chenlei"});
        System.out.println(objectName);
        //得到所有public 方法(包括继承父类的方法)
        Method[] methods = classType.getMethods();
        for (Method method : methods) {
            System.out.println(method.getName());//获得方法的名字
        }
    }
}

 获得私有方法和成员变量

package com.www.invoke;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class PrivateTest {
    
    private String address="shanghai";
    
    public int age = 20;
    
    protected String school = "北京大学";
    
    private String sayHello(String name){
        
        return "Hello :"+name;
    }
    public static void main(String[] args) throws Exception {

        Class<?> classType = PrivateTest.class;
        PrivateTest privateTest = (PrivateTest) classType.newInstance();
        //可以获得私有的方法，第一个参数是方法的名字，第二个参数是Class类型的可变参数，与方法的参数类型对应
        Method method = classType.getDeclaredMethod("sayHello", new Class[] { String.class });
        //true不再进行访问权限检查，之后就可以访问此私有方法了，false与之相反
        method.setAccessible(true); 
        //调用方法
        Object object = method.invoke(privateTest, new Object[] { "chenlei" });
        System.out.println(object);
        /* -----------------------------调用 成员变量-----------------------*/
        //只能获得public 修饰的方法的成员变量
        Field ageField = classType.getField("age"); 
        //获得变量的值
        int age = ageField.getInt(privateTest);
        System.out.println(age);
        Field addressField = classType.getDeclaredField("address");
        //true不再进行访问权限检查，之后就可以访问此私有变量了
        addressField.setAccessible(true);
        //获得变量的值
        String address = (String) addressField.get(privateTest);
        System.out.println(address);
        //获得所有public修饰的成员变量
        Field[] fields = classType.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
    }
}

总结：

java的反射 是说的是运行时 。
反射的总结：
1，每个类都有与之对用的Class对象。
2，每个方法都有与之对用的Method对象。
3，每个成员变量都有与之对用的Field对象。
4，第一步都是获得类对应的Class对象。
5，通过反射可以获得私有的成员变量和方法。