3.2 反射
3.2.1 反射介绍
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制
简单的说:一个类有多个组成部分，例如：成员变量，方法，构造方法等。反射就是加载类，并解剖出类的各个组成部分
Java反射机制主要提供了以下功能：
- 在运行时判断任意一个对象所属的类；
- 在运行时构造任意一个类的对象；
- 在运行时判断任意一个类所具有的成员变量和方法；
- 在运行时调用任意一个对象的方法；生成动态代理
备注:程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言
3.2.2 反射的API介绍
Java反射所需要的类并不多，主要有java.lang.Class类和java.lang.reflect包中的Field、Constructor、Method、Array类。
注意：Class类是Java反射的起源，针对任何一个你想探勘的类，只有先为它产生一个Class类的对象，接下来才能通过Class对象获取其他想要的信息。
- Class类
- JVM为每种类型管理着一个独一无二的Class对象---每个类（型）都有一个Class对象
- Java程序运行过程中，当需要创建某个类的实例时，JVM首先检查所要加载的类对应的Class对象是否已经存在。如果还不存在，JVM就会根据类名查找对应的字节码文件并加载，接着创建对应的Class对象，最后才创建出这个类的实例。
- Java的基本数据类型都对应着一个Class对象；关键字void也都对应着一个Class对象；每个数组属性也被映射为 Class 对象，所有具有相同类型和维数的数组都共享该 Class 对象
因此，运行中的类或接口在JVM中都会有一个对应的Class对象存在，它保存了对应类或接口的类型信息。要想获取类或接口的相应信息，需要先获取这个Class对象。
- 加载类
- Java中有一个Class类用于代表某一个类的字节码
- Class类即然代表某个类的字节码，它当然就要提供加载某个类字节码的方法：forName()。forName方法用于加载某个类的字节码到内存中，并使用class对象进行封装
- 另外两种得到class对象的方式
类名.class: Manager.class; int.class; double[].class;
对象.getClass()
- 解剖类
-
Class对象提供了如下常用方法
Public Constructor getConstructor(Class... parameterTypes) Public Method getMethod(String name, Class... parameterTypes) Public Field getField(String name) public public Constructor getDeclaredConstructor(Class... parameterTypes) public Method getDeclaredMethod(String name,Class... parameterTypes) public Field getDeclaredField(String name)
这些方法分别用于从类中解剖出构造函数、方法和成员变量（属性）。解剖出的成员分别使用Constructor、 Method 、 Field 对象表示。
3.2.3 反射案例
案例5:Java反射案例
class Person {
private int age;
private String name;
public Person() {
}
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
interface ActionInterface {
public void walk(int m);
}
class SuperMan extends Person implements ActionInterface {
private boolean blueBriefs;
public void fly() {
System.out.println("超人会飞耶～～");
}
public boolean isBlueBriefs() {
return blueBriefs;
}
public void setBlueBriefs(boolean blueBriefs) {
this.blueBriefs = blueBriefs;
}
@Override
public void walk(int m) {
System.out.println("超人会走耶～～走了" + m + "米就走不动了！");
}
}
示例1：通过Java反射机制得到类的包名和类名
public static void main(String[] args){
Person person = new Person();
System.out.println("包名：" + person.getClass().getPackage().getName());
System.out.println("完整类名：" + person.getClass().getName());
}
示例2：验证所有的类都是Class类的实例对象
public static void main(String[] args){
// 定义两个类型都未知的Class，设置初值为null，看看如何给它们赋值成Person类
Class class1 = null;
Class class2 = null;
// 写法1，可能抛出 ClassNotFoundException 异常，多用这个写法
try {
class1 = Class.forName("shuang.com.demo.Person");//包名要写正确，不然抛异常
System.out.println("写法1，包名：" + class1.getPackage().getName() + " , 完整类名：" + class1.getName());
} catch (ClassNotFoundException e) {
System.out.println("写法1找不到类");
}
// 写法2
class2 = Person.class;
System.out.println("写法2，包名：" + class2.getPackage().getName() + " , 完整类名：" + class2.getName());
}
示例3：通过Java反射机制，用 Class 创建类对象，这也就是反射存在的意义所在
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
Class class1 = null;
class1 = Class.forName("shuang.com.demo.Person");
// 由于这里不能带参数，所以你要实例化的这个类Person，一定要有无参构造函数
Person person = (Person) class1.newInstance();
person.setName("xiaoming");
person.setAge(20);
System.out.println(person.getName() + " , " + person.getAge());
}
示例4：通过Java反射机制得到一个类的构造函数，并实现创建带参实例对象
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException,IllegalArgumentException, InvocationTargetException{
Class class1 = null;
Person person1 = null;
Person person2 = null;
class1 = Class.forName("shuang.com.demo.Person");
Constructor[] constructors = class1.getConstructors();
person1 = (Person) constructors[0].newInstance();
person1.setName("xiaoming");
person1.setAge(20);
System.out.println(person1.getName() + " , " + person1.getAge());
person2 = (Person) constructors[1].newInstance(21, "xiaohong");
System.out.println(person2.getName() + " , " + person2.getAge());
}
示例5：通过Java反射机制操作成员变量, set 和 get
public static void main(String args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, SecurityException{
Class class1 = Class.forName("shuang.com.demo.Person");
Object obj = class1.newInstance();
Field personNameField = class1.getDeclaredField("name");
personNameField.setAccessible(true); // 取消访问检查
personNameField.set(obj, "小虎");
System.out.println("修改属性之后得到属性变量的值：" + personNameField.get(obj));
}
示例6：通过Java反射机制得到类的一些属性：继承的接口、父类、函数信息、成员信息、类型等
public static void main(String[] args) throws ClassNotFoundException{
Class class1 = Class.forName("shuang.com.demo.SuperMan");
// 取得父类名称
Class superclass = class1.getSuperclass();
System.out.println("SuperMan类的父类名：" + superclass.getName());
Field[] fields = class1.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
System.out.println("类中的成员" + i + "： " + fields[i]);
}
// 取得类方法
Method[] methods = class1.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
System.out.println("取得SuperMan类的方法" + i + "：");
System.out.println("函数名：" + methods[i].getName());
System.out.println("函数返回类型：" + methods[i].getReturnType());
System.out.println("函数访问修饰符：" + Modifier.toString(methods[i].getModifiers()));
System.out.println("函数代码写法： " + methods[i]);
}
// 取得类实现的接口，因为接口类也属于Class，所以得到接口中的方法也是一样的方法得到哈
Class interfaces[] = class1.getInterfaces();
for (int i = 0; i < interfaces.length; i++) {
System.out.println("实现的接口类名： " + interfaces[i].getName());
}
}
示例7：通过Java反射机制调用类方法
public static void main(String[] args)throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException,InstantiationException, InvocationTargetException{
Class class1 = Class.forName("shuang.com.demo.SuperMan");
System.out.println("调用无参方法fly()：");
Method method = class1.getMethod("fly");
method.invoke(class1.newInstance());
System.out.println("调用有参方法walk(int m)：");
method = class1.getMethod("walk", int.class);
method.invoke(class1.newInstance(), 100);
}