Java基础——反射 reflect
什么是反射
（1）Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。
（2）反射(Reflection)是Java程序开发语言的特征之一，它允许运行中的Java程序对自身进行检查， 也称自审，并能直接操作程序的内部属性。例如，使用它能获得Java类中各成员的名称并显示出来。
（3）Java的这一能力在实际应用中应用得很多，在其它的程序语言中根本就不存在这一特性。例如，Pascal、C或者C++中就没有办法在程序中获得函数定义相关的信息。
（4）JavaBean是类反射的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过类反射动态的载入并取得Java组件(类)的属性。后面学习的各种框架，基本上都会有反射的使用。
使用反射的基本步骤
用于反射的类，如Method，可以在java.lang.reflect包中找到。使用这些类的时候必须要遵循三个步骤：
第一步：获得你想操作的类的java.lang.Class对象。在运行中的Java程序中，用java.lang.Class类来描述类和接口等。
第二步：调用诸如getDeclaredMethods的方法，取得该类中定义的所有方法的列表。
第三步：使用反射的API来操作这些信息。
认识 java.lang.Class 类
在面向对象的世界里，万事万物皆对象。
那么类（java语言中，静态的成员、普通数据类型除外)是不是对象呢?
类是(哪个类的对象呢?)谁的对象呢?
There is a class named Class .
定义的每一个类都是对象，类是java.lang.Class类的实例对象。
定义一个Foo类
package com.demo.reflect;
class Foo{ public void print(){ System.out.println("Foo"); } }
Foo 类的实例对象表示方式：
Foo f = new Foo();
//f 就可以表示了 Foo 类的一个对象，这个表示很清晰明了。
定义的 Foo 类也是一个对象，是 java.lang.Class 的对象。
查看源码发现，java.lang.Class类没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象。
那么问题来了：怎么表示这个对象呢？
在 java 语言中，任何一个类都是Class的实例对象，这个实例对象有三种表示方式。
第一种表示方式: 类.class 告诉我们任何一个类都有一个隐含的静态成员变量class
Class c1 = Foo.class;
第二中表达方式 : 通过该类的对象调用 getClass() 方法
Class c2 = foo1.getClass();
第三种表达方式 : 使用Class类的中静态forName('类的全称')方法获得与字符串对应的Class对象
Class c3 = Class.forName("com.demo.reflect.Foo");
在java官网中说明：c1 、c2、c3 表示了 Foo类的类类型(class type)。
代码测试c1\c2\c3是否代表同一个对象？
System.out.println(c1==c2);//true
System.out.println(c1==c3);//true
根据输出结果，表示一个类只可能是Class类的一个实例对象。
实际情况下：虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类（型）都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否 所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。
小结：万事万物皆对象，类也是对象，是Class类的实例对象，这个对象我们称为该类的类类型（不仅仅代表是类或者接口）。
备注：基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也都对应一个 Class 对象。 每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
细说：Class.forName(String className)
Class.forName() 不仅表示了类的类类型，还代表了动态加载类。
那什么是静态加载和动态加载？
动态加载：程序在运行时调用相应方法，即使其他方法是错误的，程序依旧会执行。通过动态加载可以让程序的可延长性大大提升，对以后的维护和扩展有重要意义。
静态加载：程序在编译时执行。在执行过程中加载所有可能执行到的程序。在这种加载方式下，只要加载中一个方法出错，程序就不能运行。我们一般写程序默认的是静态加载。
通过下面案例进行分析：
public class Test{ public static void main(String[] args) { // 静态加载。编译时加载，编译时就需要加载全部可能使用到的的类，一个类出错，其他类的功能都不能得到执行 if ("Word".equals(args[0])) { Word Word = new Word(); System.out.println("Word"); } if ("Excel".equals(args[0])) { Excel excel = new Excel(); System.out.println("Excel"); } } }
如果你不定义Word类和Excel类，则会出现编译错误。
若你想程序能运行，必须定义Word类和Excel类。
假想如下场景，Test中有100个功能，你只想使用A功能，如果你使用的是静态加载的机制，你必须定义其余的99种功能才能使用A功能，如果使用动态加载机制，不仅不用定义99中功能，通过实现某种标准（继承某个接口），将大大方便了代码的编写。
创建一个接口：
public interface MyStandard{
public void print();
}
新建一个程序入口：
public static void main(String[] args) {
//运行时加载，动态加载类
Class c1 = Class.forName(args[1]);
//通过类类型加载对象。
//返回的是包含N个class的接口，以免程序编译错乱
RunBetter rb = (RunBetter)c1.newInstance();
rb.print();
}
实现接口：
class Word implements MyStandard{
public void print(){
System.out.println("Word ");
}
}
class Excel implements MyStandard{
public void print(){
System.out.println("A");
}
}
想要使用那个类就传入该类。这使得程序更加的多样，就算程序已经运行了，也可以通过这个方式进行加载新的类，实现某种升级。Class.forName()加载得到类类型。
得到类的类类型，我们可以干什么呢？
Class 类里面提供了很多解析、操作类的方法，详情可以查看API 文档。最重要的方法：Class.forName(String className)
得到类的构造方法
/**
* 打印对象的构造函数的信息
* @param obj
*/
public static void printConMessage(Object obj){
Class c = obj.getClass();
/*
* 构造函数也是对象
* java.lang. Constructor中封装了构造函数的信息
* getConstructors获取所有的public的构造函数
* getDeclaredConstructors得到所有的构造函数
*/
//Constructor[] cs = c.getConstructors();
Constructor[] cs = c.getDeclaredConstructors();
for (Constructor constructor : cs) {
System.out.print(constructor.getName()+"(");
//获取构造函数的参数列表--->得到的是参数列表的类类型
Class[] paramTypes = constructor.getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
得到类的属性
/**
* 获取成员变量的信息
* @param obj
*/
public static void printFieldMessage(Object obj) {
Class c = obj.getClass();
/*
* 成员变量也是对象
* java.lang.reflect.Field
* Field类封装了关于成员变量的操作
* getFields()方法获取的是所有的public的成员变量的信息
* getDeclaredFields获取的是该类自己声明的成员变量的信息
* field.setAccessible(true); 破除封装，属性强制可见
*/
//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);
}
}
得到类的方法
/*
* 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(")");
}
}
反射的基本操作
public class Book { private String name; private double price; public void setPrice(double price) { this.price = price; } public void setName(String name) { this.name = name; } public Book(){ System.out.println("****无参数构造"); } @Override public String toString() { return "Book [name=" + name + ", price=" + price + "]"; } public Book(String name, double price) { super(); this.name = name; this.price = price; } }
构造方法反射实例化对象
getConstructor(Class[])
返回当前 Class 对象表示的类的指定的公有构造子对象。
getConstructors()
返回当前 Class 对象表示的类的所有公有构造子对象数组。
getDeclaredConstructor(Class[])
返回当前 Class 对象表示的类的指定已说明的一个构造子对象。
getDeclaredConstructors()
返回当前 Class 对象表示的类的所有已说明的构造子对象数组。
@Test
public void testBookConstructor() throws Exception{
Class<?> cs = Class.forName("com.jcy.po.Book");
//调用类的无参构造器
Object obj = cs.newInstance();
Book b = (Book) obj;
b.setName("无参构造器");
System.out.println(b);
//调用类的有参构造器
Constructor constructor =cs.getConstructor( new Class [] { String.class,double.class});
//也可以 --> cs.getConstructor( String.class,double.class);
Book b2 = (Book)constructor.newInstance("有参构造器",100.00);
System.out.println(b2);
//输出结果：
//Book [name=无参构造器, price=0.0]
//Book [name=有参构造器, price=100.0]
}
反射操作属性
getDeclaredField(String)
返回当前 Class 对象表示的类或接口的指定已说明的一个域对象。
getDeclaredFields()
返回当前 Class 对象表示的类或接口的所有已说明的域对象数组。
getField(String)
返回当前 Class 对象表示的类或接口的指定的公有成员域对象。
getFields()
返回当前 Class 对象表示的类或接口的所有可访问的公有域对象数组。
@Test public void testBookField() throws Exception{ Book book = new Book("反射书",10.00); Class cs = book.getClass(); System.out.println(book); Field [] fields = cs.getDeclaredFields(); for (Field field : fields) { System.out.println(field.getName()); } Field field = cs.getDeclaredField("name"); //此处报错java.lang.IllegalAccessException //私有属性不可以直接访问 //field.set("name", "强行赋值"); field.setAccessible(true);//设置该属性为可使用 field.set(book, "强行赋值");//不报错 System.out.println(book); }
//输出结果：
Book [name=反射书, price=10.0]
name
price
Book [name=强行赋值, price=10.0]
方法反射的调用
getMethod(String, Class[])
返回当前 Class 对象表示的类或接口的指定的公有成员方法对象。
getMethods()
返回当前 Class 对象表示的类或接口的所有公有成员方法对象数组，包括已声明的和从父类继承的方法。getDeclaredMethod(String, Class[])
返回当前 Class 对象表示的类或接口的指定已说明的一个方法对象。
getDeclaredMethods()
返回 Class 对象表示的类或接口的所有已说明的方法数组。
@Test
public void testBookMethod() throws Exception{
//获得类中的方法
//getMethod获取的是public的方法，包括继承的方法
//getDelcaredMethod自己声明的方法
//getMethod 根据方法名和方法的参数类类型得到对应方法
Class<?> cs = Class.forName("com.jcy.po.Book");
Book b = (Book) cs.newInstance();
//方法的反射操作
//m.invoke(b,"格林童话");方法的反射操作是用m对象来进行方法调用
//和b.setName(格林童话);调用的效果完全相同
//方法如果没有返回值返回null,有返回值返回具体的返回值
Method m =cs.getMethod("setName", String.class);
System.out.println(b);
m.invoke(b,"格林童话");
System.out.println(b);
Method[] ms = cs.getMethods();
for (Method method : ms) {
System.out.println(method.getName());
}
//输出结果：
/*
* Book [name=null, price=0.0]
Book [name=格林童话, price=0.0]
toString
setName
setPrice
wait
wait
wait
equals
hashCode
getClass
notify
notifyAll
*
*/
}
类反射调用图
