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，通过反射可以获得私有的成员变量和方法。