JAVA之类加载机制与反射（二）

通过反射查看类信息

JAVA程序中的对象分为两种类型——编译时类型和运行时类型，但有时，该对象的编译时类型是父类，而程序却需要调用该对象运行时的方法。

为了解决这些问题，通常有两种办法

第一种做法是假设在编译时和运行时发现对象和类的真实信息，在这种情况下，可以先使用instanceof运算符进行判断，再利用强制类型转换将其转换成其运行时类型的变量即可
若编译时根本无法预知该对象和类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射

获得Class对象

每个类被加载之后，系统就会为该类生成一个对应的Class对象，通过该Class对象就可以访问到JVM中的这个类，在JAVA中有三种获取Class对象的方式

使用Class类的forName（String clazzName）静态方法。该方法需要传入字符串参数，该字符串参数的值是某个类的全限定类名（必须添加完整包类）
调用某个类的class属性来获取该类对应的Class对象。例如，Person.class将返回Person类对应的Class对象
调用某广告对象的getClass（）方法。该方法是java.lang.Object的方法，所以所有的java对象都可以调用该方法，该方法将会返回该对象所属类对应的Class对象

第一种和第二种方法都是直接根据类来取得该类的Class对象，相比而下，第二种方法更有优势——代码更安全（系统在编译时就可以检查需要访问的Class对象是否存在）、性能更佳（因为无需调用方法）

也就是说在大多数情况下，都应当使用第二种方法来获取指定类的Class对象。单如果程序只能获得一个字符串，那么就只能使用第一种方法，使用该方法可能会抛抛出一个ClassNotFoundException异常

从Class中获取信息

Class类提供了大量的实例方法来获取该Class对象所对应类的详细信息（P831）

package 通过反射来查看类信息;

import java.util.*;
import java.lang.reflect.*;
import java.lang.annotation.*;

// 定义可重复注解
@Repeatable(Annos.class)
@interface Anno {}
@Retention(value=RetentionPolicy.RUNTIME)
@interface Annos {
Anno[] value();
}
// 使用4个注解修饰该类
@SuppressWarnings(value="unchecked")
@Deprecated
// 使用重复注解修饰该类
@Anno
@Anno
public class ClassTest
{
// 为该类定义一个私有的构造器
private ClassTest()
{
}
// 定义一个有参数的构造器
public ClassTest(String name)
{
System.out.println("执行有参数的构造器");
}
// 定义一个无参数的info方法
public void info()
{
System.out.println("执行无参数的info方法");
}
// 定义一个有参数的info方法
public void info(String str)
{
System.out.println("执行有参数的info方法"
+ "，其str参数值：" + str);
}
// 定义一个测试用的内部类
class Inner
{
}
public static void main(String[] args)
throws Exception
{
// 下面代码可以获取ClassTest对应的Class
Class<ClassTest> clazz = ClassTest.class;
// 获取该Class对象所对应类的全部构造器
Constructor[] ctors = clazz.getDeclaredConstructors();
System.out.println("ClassTest的全部构造器如下：");
for (Constructor c : ctors)
{
System.out.println(c);
}
// 获取该Class对象所对应类的全部public构造器
Constructor[] publicCtors = clazz.getConstructors();
System.out.println("ClassTest的全部public构造器如下：");
for (Constructor c : publicCtors)
{
System.out.println(c);
}
// 获取该Class对象所对应类的全部public方法
Method[] mtds = clazz.getMethods();
System.out.println("ClassTest的全部public方法如下：");
for (Method md : mtds)
{
System.out.println(md);
}
// 获取该Class对象所对应类的指定方法
System.out.println("ClassTest里带一个字符串参数的info()方法为："
+ clazz.getMethod("info" , String.class));
// 获取该Class对象所对应类的上的全部注解
Annotation[] anns = clazz.getAnnotations();
System.out.println("ClassTest的全部Annotation如下：");
for (Annotation an : anns)
{
System.out.println(an);
}
System.out.println("该Class元素上的@SuppressWarnings注解为："
+ Arrays.toString(clazz.getAnnotationsByType(SuppressWarnings.class)));
System.out.println("该Class元素上的@Anno注解为："
+ Arrays.toString(clazz.getAnnotationsByType(Anno.class)));
// 获取该Class对象所对应类的全部内部类
Class<?>[] inners = clazz.getDeclaredClasses();
System.out.println("ClassTest的全部内部类如下：");
for (Class c : inners)
{
System.out.println(c);
}
// 使用Class.forName方法加载ClassTest的Inner内部类
Class inClazz = Class.forName("通过反射来查看类信息.ClassTest$Inner");
// 通过getDeclaringClass()访问该类所在的外部类
System.out.println("inClazz对应类的外部类为：" +
inClazz.getDeclaringClass());
System.out.println("ClassTest的包为：" + clazz.getPackage());
System.out.println("ClassTest的父类为：" + clazz.getSuperclass());
}
}

运行结果如下：



注意，只在源代码上保留的注解，使用运行时获得的Class对象无法访问到该注解对象

Java8新增的方法参数反射

Java8在java.lang.reflect包下新增了一个Excutable抽象基类，该对象代表了可执行的类成员，该类派生了Constructor、Method两个子类

Parameter也是Java8新增的API，每个Parameter对象代表方法或构造器的一个参数。Parameter也提供了大量方法来获取声明该参数的泛型

使用javac命令编译Java源文件是，默认生成的class文件并不包括方法的形参名信息，一次你调用isNamePresent（）方法将会返回false，调用getName（）方法也不能得到该参数的形参名。
所以如果需要javac命令编译Java源文件是可以保留形参信息，则需要为该命令指定-parameters选项

但不幸的是，我找不到这个选项



我的版本信息为：



按说不是版本的问题，目前还不清楚是什么情况

使用反射生成并操作对象

Class对象可以获得该类里的方法（由Method对象表）、构造器（由Constructor对象表示）、成员变量（由Field对象表示），这三个类都位于java.lang.reflect，并实现了java.lang.reflect.Member接口。程序可以通过Method来执行对应的方法，通过Constructor对象来调用对应的构造器创建实例，能通过Field对象直接访问并修改对象的成员变量值

创建对象

通过反射来生成对象有如下两种方式

使用Class对象的newInstance（）方法来创建该对象对应类的实例，这种方式要求该Class对象的对应类有默认构造器，而执行newInstance（）方法时实际上是利用默认构造器来创建该类的实例
先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance（）方法来创建该Class对象对用的实例。通过这种方式可以使用指定的构造器来创建实例
通过第一种方式创建对象是比较常见的情形，因为在很多JavaEE框架中都需要根据配置文件信息来创建Java对象，而从配置文件读取的只是某个类的字符串类名，程序需要根据该字符串来创建对应的实例，就必须用到反射

package 使用反射生成并操作对象;

import java.util.*;
import java.io.*;

public class ObjectPoolFactory
{
// 定义一个对象池,前面是对象名，后面是实际对象
private Map<String ,Object> objectPool = new HashMap<>();
// 定义一个创建对象的方法，
// 该方法只要传入一个字符串类名，程序可以根据该类名生成Java对象
private Object createObject(String clazzName)
t
d112
hrows InstantiationException
, IllegalAccessException , ClassNotFoundException
{
// 根据字符串来获取对应的Class对象
Class<?> clazz = Class.forName(clazzName);
// 使用clazz对应类的默认构造器创建实例
return clazz.newInstance();
}
// 该方法根据指定文件来初始化对象池，
// 它会根据配置文件来创建对象
public void initPool(String fileName)
throws InstantiationException
, IllegalAccessException ,ClassNotFoundException
{
try(
FileInputStream fis = new FileInputStream(fileName))
{
Properties props = new Properties();
props.load(fis);
for (String name : props.stringPropertyNames())
{
// 每取出一对key-value对，就根据value创建一个对象
// 调用createObject()创建对象，并将对象添加到对象池中
objectPool.put(name ,
createObject(props.getProperty(name)));
}
}
catch (IOException ex)
{
System.out.println("读取" + fileName + "异常");
}

}
public Object getObject(String name)
{
// 从objectPool中取出指定name对应的对象。
return objectPool.get(name);
}

public static void main(String[] args)
throws Exception
{
ObjectPoolFactory pf = new ObjectPoolFactory();
pf.initPool("obj.txt");
System.out.println(pf.getObject("a"));
System.out.println(pf.getObject("b"));
}
}

运行结果为：

调用方法

当获得某个类对应的Class对象后，就可以通过该Class对象的getMethods（）方法或getMethod（）方法来获得全部方法或指定方法

每个Method对象对应一个方法，获得Method对象后，程序就可以通过该对象来调用对应的方法

在Method里包含一个invoke（Object obj，Object ...args）方法,obj是执行该方法的主调，后面的args是执行该方法时传入该方法的实参

package 使用反射生成并操作对象;

import java.util.*;
import java.io.*;
import java.lang.reflect.*;
public class ExtendedObjectPoolFactory
{
// 定义一个对象池,前面是对象名，后面是实际对象
private Map<String ,Object> objectPool = new HashMap<>();
private Properties config = new Properties();
// 从指定属性文件中初始化Properties对象
public void init(String fileName)
{
try(
FileInputStream fis = new FileInputStream(fileName))
{
config.load(fis);
}
catch (IOException ex)
{
System.out.println("读取" + fileName + "异常");
}
}
// 定义一个创建对象的方法，
// 该方法只要传入一个字符串类名，程序可以根据该类名生成Java对象
private Object createObject(String clazzName)
throws InstantiationException
, IllegalAccessException , ClassNotFoundException
{
// 根据字符串来获取对应的Class对象
Class<?> clazz =Class.forName(clazzName);
// 使用clazz对应类的默认构造器创建实例
return clazz.newInstance();
}
// 该方法根据指定文件来初始化对象池，
// 它会根据配置文件来创建对象
public void initPool()throws InstantiationException
,IllegalAccessException , ClassNotFoundException
{
for (String name : config.stringPropertyNames())
{
// 每取出一对key-value对，如果key中不包含百分号（%）
// 这就标明是根据value来创建一个对象
// 调用createObject创建对象，并将对象添加到对象池中
if (!name.contains("%"))
{
objectPool.put(name ,
createObject(config.getProperty(name)));
}
}
}
// 该方法将会根据属性文件来调用指定对象的setter方法
public void initProperty()throws InvocationTargetException
,IllegalAccessException,NoSuchMethodException
{
for (String name : config.stringPropertyNames())
{
// 每取出一对key-value对，如果key中包含百分号（%）
// 即可认为该key用于控制调用对象的setter方法设置值，
// %前半为对象名字，后半控制setter方法名
if (name.contains("%"))
{
// 将配置文件中key按%分割
String[] objAndProp = name.split("%");
// 取出调用setter方法的参数值
Object target = getObject(objAndProp[0]);
// 获取setter方法名:set + "首字母大写" + 剩下部分
String mtdName = "set" +
objAndProp[1].substring(0 , 1).toUpperCase()
+ objAndProp[1].substring(1);
// 通过target的getClass()获取它实现类所对应的Class对象
Class<?> targetClass = target.getClass();
// 获取希望调用的setter方法
<strong>Method mtd = targetClass.getMethod(mtdName , String.class);
// 通过Method的invoke方法执行setter方法，
// 将config.getProperty(name)的值作为调用setter的方法的参数
mtd.invoke(target , config.getProperty(name));</strong>
}
}
}
public Object getObject(String name)
{
// 从objectPool中取出指定name对应的对象。
return objectPool.get(name);
}
public static void main(String[] args)
throws Exception
{
ExtendedObjectPoolFactory epf = new ExtendedObjectPoolFactory();
epf.init("extObj.txt");
epf.initPool();
epf.initProperty();
System.out.println(epf.getObject("a"));
}
}

输出结果本应该为一个JFrame窗口，但是。。。



当通过Method的invoke（）方法来调用 对应的方法时，java会要求程序必须有调用该方法的权限。如果确实需要调用其private方法，那么应该先调用setAccessible（boolean flag）方法

实际上，setAccessible（）方法不属于Method，而是属于其父类AccessibleObject。因此，Method、Constructor、Field都可以调用此方法

访问成员变量值

Field提供了如下两组方法来读取或设置成员变量值
getXXX（Object obj）方法：获取obj对象的该长远变量的值。此处的XXX对应8中基本类型（首字母大写），若该成员变量的值为引用类型，则取消后面的XXX
setXXX（Object obj，XXX val）：同上

package 使用反射生成并操作对象;

import java.lang.reflect.Field;

class Person
{
private String name;
private int age;
private boolean isStudent;
@Override
public String toString()
{
return "Person [name "+name+" age "+age+" is student "+isStudent +"]";
}
}
public class FieldTest {
public static void main(String []args)throws Exception
{
Person p=new Person();
Class<Person> personClazz=Person.class;
Field pname=personClazz.getDeclaredField("name");
pname.setAccessible(true);
pname.set(p, "小明");
Field page=personClazz.getDeclaredField("age");
page.setAccessible(true);
page.setInt(p, 23);
Field pIs=personClazz.getDeclaredField("isStudent");
pIs.setAccessible(true);
pIs.setBoolean(p, true);
System.out.println(p);
}

}

输出如下：

操作数组

在java.lang.reflect包下还提供了一个Array类，Array对象可以代表所有的数组。程序可以通过使用Array来动态地创建数组，操作数组等元素

package 使用反射生成并操作对象;

import java.lang.reflect.Array;

public class ArrayTest {
public static void main(String []args)
{
Object arr=Array.newInstance(String.class, 5);
Array.set(arr, 3, "Hello");
Array.set(arr, 4, "World!");
Object book1=Array.get(arr, 3);
Object book2=Array.get(arr, 4);
System.out.println(book1);
System.out.println(book2);
System.out.println(arr);
}
}

输出结果为：