首页 > > 程序设计 > Java技术 >

反射（一）

2018-06-18 00:15:40来源：未知阅读 ()

初学反射，学习内容做了一些笔记，比较杂乱：

1、类是java.lang.Class类的实例对象

2、new 创建对象，是静态加载类，在编译时刻就需要加载可能使用到的类。

3、Class c = user.getClass(); //已知该类的对象，可通过getClass方法获取该类的类类型

　 Class c = Class.forName("类的全称"); //不仅表示了该类的类类型，还代表了动态加载类，运行时加载类是动态加载

　 Word w = (Word)c.newInstance(); //通过类类型，创建该类的对象

4、基本数据类型、void关键字等都存在类类型

 1 package com.reflect;
 2 
 3 /** 
 4 * @author 作者：方o丈
 5 * @version 创建时间：2018年6月9日 下午2:20:24 
 6 * 类说明：
 7 */
 8 public class Test {
 9 
10     public static void main(String[] args) {
11         Class c1 = int.class;
12         Class c2 = double.class;
13         Class c3 = Double.class;
14         Class c4 = String.class;
15         Class c5 = void.class;
16         
17         System.out.println(c1.getName());
18         System.out.println(c2.getName());
19         System.out.println(c3.getName());
20         System.out.println(c3.getSimpleName());
21         System.out.println(c4.getName());
22         System.out.println(c4.getSimpleName());
23         System.out.println(c5.getName());
24     }
25     
26 }

程序运行结果：

5、Class类的API操作：获取类的信息，成员函数、成员变量等信息

  1 package com.reflect;
  2 
  3 import java.lang.reflect.Constructor;
  4 import java.lang.reflect.Field;
  5 import java.lang.reflect.Method;
  6 
  7 /**
  8  * @author 作者：方o丈
  9  * @version 创建时间：2018年6月9日 下午9:55:59 
 10  * 类说明：反射类的API操作
 11  */
 12 public class ReflectClass {
 13 
 14     /**
 15      * 获取类的成员函数
 16      * @param obj 该对象所属类的信息
 17      */
 18     public static void getClassMethod(Object obj) {
 19         // 首先获取类的类类型
 20         Class c = obj.getClass();
 21         // 获取类的名称
 22         String className = c.getName();
 23         System.out.println("类的名称：" + className);
 24 
 25         /**
 26          * Method类，方法对象
 27          * 获取类的方法 getMethods()获取该类所有的public方法，包括从父类继承来的
 28          * getDeclaredMethods() 获取该类所有的自己声明的方法，不管是什么什么访问权限。但不包含从父类继承来的
 29          * 
 30          */
 31         Method[] method = c.getMethods();
 32         for (int i = 0; i < method.length; i++) {
 33             //获取方法的返回值的类类型
 34             Class returnTyepe = method[i].getReturnType();
 35             //获取方法返回值类型名
 36             System.out.print(returnTyepe.getName()+" ");
 37             
 38             //获取方法的名称
 39             System.out.print(method[i].getName()+"(");
 40             
 41             //获取参数列表的类型的类类型
 42             Class[] paramTypes = method[i].getParameterTypes();
 43             for (Class paramType : paramTypes) {
 44                 System.out.print(paramType.getName()+",");
 45             }
 46             System.out.println(")");
 47         }
 48     }
 49     
 50     /**
 51      * 获取类的成员变量
 52      * @param obj 
 53      */
 54     public static void getClassField(Object obj){
 55         //获取该类的类类型
 56         Class<? extends Object> c = obj.getClass();
 57         /**
 58          * 获取类的成员变量
 59          * Field类 封装了关于成员变量的操作
 60          * getFields() 获取该类的所有public的成员变量
 61          * getDeclaredFields()获取该类自己声明的成员变量的信息
 62          */
 63         Field[] fields = c.getDeclaredFields();
 64         for (Field field : fields) {
 65             //首先，获取成员变量的类类型
 66             Class fieldType = field.getType();
 67             //获取成员变量的类类型名称
 68             String typeName = fieldType.getName();
 69             
 70             //获取成员变量的名称
 71             String fieldName = field.getName();
 72             System.out.println(typeName+" "+fieldName);
 73         }
 74     }
 75     
 76     /**
 77      * 获取类的构造函数
 78      * @param obj 
 79      */
 80     public static void getClassConstructor(Object obj){
 81         //获取该类的类类型
 82         Class<? extends Object> c = obj.getClass();
 83         /**
 84          * 构造函数也是对象
 85          * java.lang.reflect.Constructor封装了构造函数的信息
 86          * getConstructors获取该类所有的public的构造函数
 87          * getDeclaredConstructors获取该类自己声明的构造函数
 88          */
 89         Constructor[] cs = c.getDeclaredConstructors();
 90         for (Constructor constructor : cs) {
 91             //构造函数没有返回值，所以直接获取构造器名称
 92             System.out.print(constructor.getName()+"(");
 93             //获取构造函数的参数列表-->得到构造函数参数列表的类型的类类型
 94             Class[] paramType = constructor.getParameterTypes();
 95             for (Class class1 : paramType) {
 96                 System.out.print(class1.getTypeName()+",");
 97             }
 98             System.out.println(")");
 99         }
100     }
101     
102     /**
103      * 测试
104      * @param args
105      */
106     public static void main(String[] args) {
107         getClassConstructor(new Integer(1));
108     }
109 }