反射机制主要提供以下功能：  ①在运行时判断任意一个对象所属的类；
②在运行时构造任意一个类的对象；
③在运行时获取任意一个类所具有的成员变量和方法；
④在运行时调用任意一个对象的方法；
⑤生成动态代理。（有待扩充）     新建一个Test类，继承FTest类：　

 1 public class Test extends FTest{
 2     public int number;
 3     public String name;
 4     
 5     public Test() {
 6     }
 7     
 8     public Test(String name, int number) {
 9         this.number = number;
10         this.name = name;
11     }
12     
13     public int getNumber() {
14         return number;
15     }
16 
17     public void setNumber(int number) {
18         this.number = number;
19     }
20 
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28     
29     public void reflection1() {
30         System.out.println("函数reflection");
31     }
32     
33     public void reflection2(String num) {
34         System.out.println("reflection" + num);
35     }
36 }

实例化Class类对象

 1 //实例化Class类对象
 2  Class<?> class1 = null;
 3  Class<?> class2 = null;
 4  Class<?> class3 = null;
 5  try {
 6     //一般有三种方法 一般使用第一种方法
 7     class1 = Class.forName("net.cnblog.muziqiuqiu.Test");
 8     class2 = new Test().getClass();
 9     class3 = Test.class;
10     } catch (Exception e) {
11        System.out.println(e);
12   }

通过反射机制获取对象的类名、包名、父类、接口

 1 Test test = new Test();
 2 //获取对象的类名和包名
 3 System.out.println(test.getClass().getName());
 4 System.out.println(class1.getName());
 5 //获取对象的父类
 6 System.out.println(test.getClass().getSuperclass());
 7 System.out.println(class1.getSuperclass());
 8 //获取实现的接口(接口可能会有几个)
 9 System.out.println(test.getClass().getInterfaces());
10 System.out.println(class1.getInterfaces());

通过反射机制实例化类的对象

 1 //通过反射机制实例化一个类的对象
 2 //第一种方法-通过默认的构造方法实例化一个类的对象
 3 try {
 4     Test test2 = (Test)class1.newInstance();
 5     test2.setName("haha");
 6     System.out.println(test2.getName());
 7 } catch (Exception e) {
 8     System.out.println(e);
 9 }
10 //第二种方法-通过获取全部的构造函数实例化对象        
11 Constructor<?> cons[] = class1.getConstructors();
12 for(int i = 0; i < cons.length; i++) {
13     Class<?> clazzs[] = cons[i].getParameterTypes();        
14 }try {
15     Test test3 = (Test)cons[1].newInstance("haha",1); 
16 　　//System.out.println(test3.getName()+test3.getNumber());
17 } catch (Exception e) {
18     System.out.println(e);
19 }

获取某个类的全部属性

 1 //获取某个类的全部属性
 2 Field[] field = class1.getDeclaredFields();    //获取当前对象所有成员变量
 3 Field[] field1 = class1.getFields();        //获取所有为public的成员变量（包括父类和子类）
 4 for(int i = 0; i < field.length; i++) {
 5     //获取变量权限
 6     int grade = field[i].getModifiers();        //为private时结果wei2
 7     String priv = Modifier.toString(grade);    
 8     //获取变量属性
 9     Class<?> type = field[i].getType();        //type.getName()结果为变量类型
10 }

获取某个类的全部方法

 1 //获取某个类的全部方法
 2 Method method[] = class1.getDeclaredMethods();    //获取当前类中所有的方法
 3 Method method1[] = class1.getMethods();        //获取所有类型为public的方法（包括父类和子类）
 4 for(int i = 0; i<method.length; i++) {
 5     Class<?> returnType = method[i].getReturnType();
 6     Class<?> para[] = method[i].getParameterTypes();    //方法的参数
 7     Class<?> exce[] = method[i].getExceptionTypes();    //所有抛出的异常
 8     int grade = method[i].getModifiers();
 9     String priv = Modifier.toString(grade);
10 }

通过反射机制调用某个类的方法

 1 //通过反射机制调用某个类的方法
 2 try {
 3     //使用反射机制调用无参方法
 4     Method method2 = class1.getMethod("reflection1");    
 5     method2.invoke(class1.newInstance());
 6     //使用反射机制调用有参方法
 7     Method method3 = class1.getMethod("reflection2", String.class);    
 8     method3.invoke(class1.newInstance(), "20");
 9 } catch (Exception e) {
10     System.out.println(e);
11 }

通过反射机制获取某个类属性的值

 1 //通过反射机制调用某个类的属性
 2 try {
 3     Test test2 = new Test();
 4     Field field2 = class1.getDeclaredField("name");    
 5     field2.setAccessible(true);            //只能用最近的一次
 6     field2.set(test2, "i an test2");
 7     System.out.println(field2.get(test2).toString());
 8 } catch (Exception e) {
 9     System.out.println(e);
10 }