0%

Java反射学习笔记

#Java反射学习笔记

Class类

万事万物皆对象,但是在Java中有两样不是对象

  1. 静态的成员:静态成员不是属于对象,是属于类的。
  2. 普通的数据类型:普通的数据类型有封装类可以将普通数据类型封装为对象。

类是谁的对象?
类是对象,是java.lang.Class类的实例对象。

任何一个类都是Class的实例对象,Class类的实例对象有三种表示方法:

  1. 通过 类.class,可以获得该类的类类型,等价于任何一个类都有一个隐含的静态成员变量class
    Class t1 = Test.class;
  2. 已知该类的对象,通过 类对象.getClass() 可以获得该类的类类型。
    Class t2 = test1.getClass();
  3. 通过 Class.forname(“类的全称”) 可以获得该类的类类型
    Class t3 = Class.forName(“com.reflect.test”)

可以通过类的类类型创建该类的对象实例
Test test = (Test)t1.newInstance();

动态加载类

编译时刻加载类是静态加载类,运行时刻加载类是动态加载类

  • new 创建对象是静态加载类,在编译时刻就需要加载所有的可能使用到的类
  • Class.forName(“类的全称”)不仅表示了类类型,还代表了动态加载类,在运行时刻加载

功能性的类一般使用动态加载,并统一功能性接口(标准),并让功能性的类统一implements该接口,这样就不用重新编译,就可以动态的加新的功能。 这种方法一般可应用于软件在线升级,不需要删除软件重新编译。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//动态加载类,在运行时刻加载
Class c = Class.forName(arg[0]);
//通过类类型,创建该类对象
OfficeAble oa = (OfficeAble)c.newInstance();
oa.start();

//编写一个标准接口
interface OfficeAble
{
public void start();
}

//让word和EXCEL类实现oa接口
class Excel implements OfficeAble
{
····
}

获取方法信息

基本的数据类型,void关键字等都存在类类型
Class c = 基类.class (int,String,double,void等)

Class类的基本API操作的

  1. class.getName();可以获取类的名称
  2. class.getSimpleName();不包含包名的类的名称
  3. class.getMethods();获取类的public方法集合,包括继承来的
  4. class.getDeclaredMethods();获取的是所有该类自己声明的方法,不问访问权限

Method类提供了一些操作方法的方法

  1. Method.getName()得到方法的名称
  2. Method.getReturnType()得到该方法的返回值类型的类类型(class),如int.class String.class
  3. Method.getParameterTypes()获得参数列表类型的类类型数组class[],如参数为(int,int)则得到(int.class ,int class)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    public class ClassUtil {
    /**
    * 打印类的信息,包括类的成员函数、成员变量(只获取成员函数)
    * @param obj 该对象所属类的信息
    */
    public static void printClassMethodMessage(Object obj){
    //要获取类的信息 首先要获取类的类类型
    Class c = obj.getClass();//传递的是哪个子类的对象c就是该子类的类类型
    //获取类的名称
    System.out.println("类的名称是:"+c.getName());
    /*
    * Method类,方法对象
    * 一个成员方法就是一个Method对象
    * getMethods()方法获取的是所有的public的函数,包括父类继承而来的
    * getDeclaredMethods()获取的是所有该类自己声明的方法,不问访问权限(继承的就没有了)
    */
    Method[] ms = c.getMethods();//c.getDeclaredMethods()
    for(int i = 0; i < ms.length;i++){
    //得到方法的返回值类型的类类型
    Class returnType = ms[i].getReturnType();
    System.out.print(returnType.getName()+" ");
    //得到方法的名称
    System.out.print(ms[i].getName()+"(");
    //获取参数类型--->得到的是参数列表的类型的类类型
    Class[] paramTypes = ms[i].getParameterTypes();
    for (Class class1 : paramTypes) {
    System.out.print(class1.getName()+",");
    }
    System.out.println(")");
    }
    }

获取成员变量构造函数信息

Field类封装了关于成员变量的操作

  1. getFields()方法获取的是所有的public的成员变量的信息
  2. getDeclaredFields()方法获取的是该类自己声明的成员变量的信息
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    /*
    * 成员变量也是对象
    * java.lang.reflect.Field
    * Field类封装了关于成员变量的操作
    * getFields()方法获取的是所有的public的成员变量的信息
    * getDeclaredFields()方法获取的是该类自己声明的成员变量的信息
    */
    Class c = obj.getClass();
    Field[] fs = c.getFields();
    Field[] fs = c.getDeclaredFields();
    for (Field field : fs){
    //得到成员变量的类型的类类型
    Class fieldType = field.getType();
    String typeName = fieldType.getName();
    //得到成员变量的名字
    String fieldName = field.getName();
    System.out.println(typeName + " " + fieldName);
    }

Constructor类封装了构造函数的信息

  1. getConstructors()获取所有的public的构造函数
  2. getDeclaredConstructors()获取所有自己声明的构造函数(构造函数都是自己声明的,所以即得到了所有构造函数)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    /*
    * 构造函数也是对象
    * java.lang.Constructor
    * Constructor类封装了构造函数的信息
    * getConstructors()获取所有的public的构造函数
    * getDeclaredConstructors()获取所有的构造函数
    */
    Class c = obj.getClass();
    //Constructor[] cs = c.getConstructors();
    Constructor[] cs = c.getDeclaredConstructors();
    for(Constructor constructor : cs){
    //获取构造函数的参数列表--->得到的是参数列表的类类型
    System.out.println(constructor.getName() + "(";
    Class[] paramTypes = constructor.getParameterTypes();
    for(Class class1 : paramTypes){
    System.out.print(class1.getName()+ "," );
    }
    System.out.print(")");
    }

Class类还有很多获取类的信息的方法,总之,想要获取类的信息,就一定要先获取类的类类型

方法反射的基本操作

获取方法:方法的名称和方法的参数列表才能唯一决定某个方法。
方法反射的操作:method.invoke(对象,参数列表);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//1.获取一个方法就是获取类的信息,获取类的信息首先要获取类的类类型
Test test1 = new Test();
Class c = test1.getClass();
/*
*2.获取方法 通过名称和参数列表来决定
* getMethod 获取的是public的方法
* getDelcaredMethod 获取的是自己声明的方法
*/
//Method m = c.getMethod("print", new Class[]{int.class, int.class});
Method m = c.getMethod("print", int.class, int.class);

//方法的反射操作:用m对象来进行方法调用 和 test1.print调用效果完全相同
//方法如果没有返回值返回null,有返回值返回具体的返回值
m.invoke(test1, new Object[]{10, 20});
m.invoke(test1, 10, 20)

通过反射了解集合泛型的本质

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
ArrayList list1 = new ArrayList();
ArrayList<String> list2 = new ArrayList<String>()

Class c1 = list1.getClass();
Class c2 = list2.getClass();
System.out.println(c1 == c2);//True
//反射的操作都是编译之后的操作

/*
* c1==c2结果返回true说明编译之后集合的泛型失去泛型化的
* Java中集合的泛型,是防止错误输入的,只在编译阶段有效,
* 绕过编译就无效了
* 验证:可以通过方法的反射来操作,绕过编译
*/
Method m = c2.getMethod("add", Object.class);
m.invoke(list2, 20);//绕过编译操作就绕过了泛型
System.out.println(list2.size());
System.out.println(list2);//20
//注意不能使用for-each来遍历,会有类型转换错误
-------------本文结束感谢您的阅读-------------