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