首页 > 程序开发 > 软件开发 > 其他 >

JAVA之类加载机制与反射(二)

2016-10-18

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)  
        throws 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<!--{cke_protected}{C}%3C!%2D%2D%3F%2D%2D%3E--> 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<!--{cke_protected}{C}%3C!%2D%2D%3F%2D%2D%3E--> 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);  
}  
}  

输出结果为:
\

相关文章
最新文章
热点推荐