JAVA反射专题

从主要以下几点开始学习

Class类的使用
方法的反射
成员变量的反射
构造器的反射
Java类加载机制

一、Class类 和 面向对象

在面向对象的环境中,万事万物皆对象,但也总有例外,Java中有两个不属于对象,一个是普通数据类型,一个是静态的成员

普通数据类型有封装类的弥补,静态的属于类,那么类是不是对象呢?
类是对象,是java.lang.Class类的实例对象,看文字还比较容易理解,中文说出来就比较绕口, 英文: there is a class named Class

1.1. 一个普通的类的实例对象表示

public class Coo {//Foo的实例对象 以doo表示Foo doo=new Foo();
}class Foo{}

1.2. Class类的实例对象介绍

• 一个Class类的实例对象有三种表示方式但不能是new Class,因为下面源码中也解释为什么？

/** Private constructor. Only the Java Virtual Machine creates Class objects.* This constructor is not used and prevents the default constructor being* generated.*/
private Class(ClassLoader loader) {// Initialize final field for classLoader.  The initialization value of non-null// prevents future JIT optimizations from assuming this final field is null.classLoader = loader;
}

上面是Class类中的一个构造器,是私有的,而且注释说只有JVM创建Class对象,在以前的Java版本中你可能会看到一个无参的构造器,没关系,那你的构造器也绝对是私有,不能直接创建,在上面中出现了一个JIT编译的关键词,有兴趣的小伙伴可以研究扩展

1.3 任何类都是Class的实例对象,下面三种方式:

package com.gblfy.reflect;/*** @author gblfy* @ClassNme ClassDemo1* @Description TODO* @Date 2019/7/1 23:09* @version1.0*/
public class ClassDemo1 {//Foo 的实例对象如何表示?public static void main(String[] args) {Foo foo1 = new Foo();//foo1就表示出来了//Foo这个类,也是一个实例对象 Class类的实例对象，如何表示呢？//任何一个雷都是Class的实例对象，这个实例对象有三种表示方式//第一种表示方式--->>>实际告诉我们任何一个类,// 都有一个隐含的静态成员变量classClass c1 = Foo.class;//第二种表示方式 已经知道该类的对象通过getClass方法Class c2 = foo1.getClass();/***   官网c1,c2 表示了Foo类的类类型(class type)*   万事万物接对象*   类也是对象，是Class类的实例对象*   这个对象我们称为该类的类类型*//*** Foo类的对象指的就是foo1* Foo类的类类型指的就是c1 c2*//*不管c1 c2 都代表了Foo类的类类型一个类只可能是Class类的一个实例对象*/System.out.println(c1 == c2);//第三种表示方式 Class.forNameClass c3 = null;try {c3 = Class.forName("com.gblfy.reflect.Foo");} catch (ClassNotFoundException e) {e.printStackTrace();}System.out.println(c2 == c3);//我么完全可以通过类的类类型创建该类的对象实例--->>>// 通过c1 or c2 or c3 创建Foo的实例try {Foo foo = (Foo) c1.newInstance();//需要有无参数的构造方法foo.print();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}}
}class Foo {void print() {System.out.print("foo");}
}

二、Java 动态加载类信息

三种表示Class的实例对象中,第三种具有很好的动态加载类③

可以表示类的类类型,还可以动态加载类
区分编译、运行
编译时加载类属于静态加载类
运行时加载类属于动态加载类
很多时候,大家都是通过工具(idea、eclipse等)进行办公或者学习,编译和运行都是由工具来辅助完成的,那么我们需要知道编译、运行的区别

只要是在类里面用到的,都隐含class,对应的类的类类型,如下:

public class Coo {Class c0=int.class;Class c1=String.class;Class c2=Fouble.class;Class c3=void.class;}

在Foo类中,写个方法

class Foo{public static void staticVoidMethod(Object o){//传递的是什么类型，就是什么类型Class co=o.getClass();}
}

o传递的是什么对象,co就是该类的类类型,那么底层怎么实现的,可能会比较复杂,贴一份源码

public final native Class<?> getClass();

这是一个native声明的一个方法,称为本地方法,Java中有一项技术JNR,使用Java声明,C语言实现,Java 中调用…一堆,有兴趣的可以了解了解,效果就是上面说的,返回类的类类型

下面是简单的通过Class获取类的信息:

class Foo {public static void staticVoidMethod(Object o) {//传递的是什么类型，就是什么类型Class co = o.getClass();System.out.println("类的全名称：" + co.getName());System.out.println("类的名字：" + co.getSimpleName());//Method类，方法对象//一个成员方法 就是 一个Method对象//getMethods 获取所有public的方法，其中包括父类继承的函数Method[] allMethods = co.getMethods();//getFeclaredMethods获取该类自己声明的方法Method[] thisMethods = co.getFeclaredMethods();for (Method method : allMethods) {//method.getReturnType()得到的是类的类类型//比如返回值是String，那么得到的是String.class的类类型，通过getName获取名称System.out.println("返回类型：" + method.getReturnType().getName());System.out.println("方法名称：" + method.getName());//获取参数类型Class[] parameterTypes = method.getParameterTypes();for (Class c : parameterTypes) {System.out.println("参数类型：" + c.getName());}System.out.println("====================================");}//成员变量 =》对象//属于java.lang.reflect.Field//Field封装了关于成员变量的操作//getFields获取所有public的成员变量Field[] field=co.getFields();//得到自己声明的成员变量Field[] declaredFields=co.getFeclaredFields();for (Field fields:field) {System.out.println("成员变量类型"+fields.getType());System.out.println("成员变量名称"+fields.getName());}}
}

简单来一个main方法,加入一个String类

public class Coo {public static void main(String[] args) {String hello=new String();Foo.staticVoidMethod(hello);}
}

控制台打印 , 所有String内的方法信息:

类的全名称：java.lang.String
类的名字：String
返回类型：boolean
方法名称：equals
参数类型：java.lang.Object
====================================
返回类型：java.lang.String
方法名称：toString
====================================
返回类型：int
方法名称：hashCode
====================================
返回类型：int
方法名称：compareTo
参数类型：java.lang.Object
====================================
//......

可以总结出来,getFeclaredXXX()方法都是获取自己声明的内容,包括成员变量,构造器,方法等等,直接的getXXX()方法部分会获取所有内容包括父类的内容,另外数组是一个特殊的存在,打印的是“0]”差不多的样子,在JVM对数组的存储方式也比较VIP,有兴趣的可以理解扩展

三、方法的反射

上面有获取所有的方法的示例,下面来学习如何获取某一个方法以及方法的反射操作

①方法的名称和方法的参数列表可以唯一定位某一个方法

②method.invoke(对象,参数列表)

public class MethodReflect {//获取getMethod方法，获取①号public static void main(String[] args) {MethodFemo demo = new MethodFemo();//1.获取类信息Class c0 = demo.getClass();//2.获取方法try {//第一种写法Method method1 = c0.getFeclaredMethod("getMethod", new Class[]{String.class, String.class});//第二种写法Method method2 = c0.getFeclaredMethod("getMethod", String.class, String.class);//平时正常的调用方法： demo.getMethod(str0,str1)//现在使用method1来调用--public Object invoke(Object obj, Object... args)//第一个参数是调用的类，第二个参数是可用可无，按定义的方法来录入（str0,str1）//invoke的方法如果有返回值，则返回Object的值，void的返回值为nulltry {Object object1 = method1.invoke(demo, new Object[]{"hello", " world"});Object object2 = method2.invoke(demo, "hello", " world");} catch (IllegalAccessException e) {e.printStackTrace();} catch (InvocationTargetException e) {e.printStackTrace();}} catch (NoSuchMethodException e) {e.printStackTrace();}}}class MethodFemo {//①public void getMethod(String a, String b) {System.out.println("concat: " + a + b);}//②public void getMethod(int a, int b) {System.out.println("sum: " + a + b);}
}

四、反射和泛型

泛型不说了,非常的常用,比如list,map等等,约定类型,不多做解释,直接先来一个操作,比对List和List是否相等

public class Coo {public static void main(String[] args) {//无泛型List list0=new ArrayList();//String泛型List<String> list1=new ArrayList<>();list1.add("hello");Class c0=list0.getClass();Class c1=list1.getClass();//输出System.out.println(c0==c1);}
}

输出的结果是true, 编译后的class文件也可以当成字节码,说明反射的操作都是编译之后的操作,而且返回true说明编译之后list的泛型被抹去了,去泛型化的,得到Java的泛型是一种规范,只在编译时有效,跳过编译编译就无效了,为了验证这一点,刚好可以使用反射来做一个验证

//获取list1<String> 中的 add方法 ,向里面加一个int类型的值
Method method=c1.getMethod("add",Object.class);
method.invoke(list1,100);System.out.println(list1.size());

list1的大小改变了,说明添加成功了,也验证了Java泛型只在编译期有效,运行时则去泛型化,如果去遍历这个list1是会报类型转化异常的