文档章节

java反射机制

不最醉不龟归
 不最醉不龟归
发布于 2016/11/17 17:23
字数 3107
阅读 12
收藏 0
  1. 类加载器的loadClass()方法,如果父类加载器为Null,则使用根类加载器
  2. 调用findClass(String)方法查找该类

我们可以看到前面两步是实现父类的一些逻辑,其实这里两步实现了父类委托和缓冲机制策略,而我们只需要重新findClass(String)方法来实现我们自己的逻辑即可,这样使自定义类加载器就简单多了

四、java反射机制

 前面说了类的加载器,下面开始真正学习java反射机制,java反射机制可以时我们在运行时刻获取类的信息,如:类的成员变量类型,值,方法的信息及调用方法,获取泛型类型,获取注解等等。

java反射的相关api都在java.lang.reflect包下:学习api最好的方法还是看官网文档,因为官方文档最权威。下面我们通过一个测试类来学习反射的最常用的知识。

// 通过Class的静态方法forName加载类,该方法会初始化类
Class clazz = Class.forName("Common");
// 通过反射生成该类的实例,调用public的无参构造方法,反射生成类的实例,该类必须得有一个public的无参方法
Object newInstance = clazz.newInstance();
  • 获取类的构造方法
public static void testConstructor(Class clazz){
        System.out.println("-----------构造方法测试-----------");
        // 获取所以的构造方法
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(int i=0;i<declaredConstructors.length;i++){
            int index = i+1; // 因为i从0开始
            String str = "第"+index+"个构造方法权限修饰符为";
            if(declaredConstructors[i].getModifiers() == 1){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
                str+="public";
            }
            if(declaredConstructors[i].getModifiers() == 2){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
                str+="private";
            }
            if(declaredConstructors[i].getModifiers() == 4){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
                str+="protected";
            }
            str+="名称为:"+declaredConstructors[i].getName();
            System.out.println(str);
        }
    }
  • 获取类方法的相关信息
    ```java
    /**
    • 这个方法通过反射获取了方法的相关信息,可以看到我们得到了方法
    • 的全部信息
    • 这里字符串拼接比较多,由于是测试,所以就没用StringBuffer拼接
    • @param clazz
      */
      public static void testCommonMethodInfo(Class clazz){
      System.out.println("-----------普通方法测试-----------");
      Method[] methods = clazz.getMethods();
      System.out.println(methods.length);
      for(int i=0;i<methods.length;i++){
      int dexI = i+1;
      String str = "第"+dexI+"个方法形式为:";

      // 获取方法权限修饰符
      int modifiers = methods[i].getModifiers();
      if(modifiers == 1){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
          str+="public";
      }
      if(modifiers == 2){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
          str+="private";
      }
      if(modifiers == 4){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
          str+="protected";
      }
      
      String returnType = methods[i].getReturnType().getSimpleName(); // 获取方法返回类型
      str+=" "+returnType+" "; 
      
      String name = methods[i].getName(); // 获取方法名称
      str+= name;
      str+="(";
      
      // 获取方法参数的类型
      Class[] parameterTypes = methods[i].getParameterTypes();
      for(int j=0;i<parameterTypes.length;i++){
          str+=parameterTypes[j]+" ";
      }
      str+=")";
      System.out.println(str);

      }
      }

```

  • 调用类的方法
/**
     * 通过反射调用方法
     * @param clazz
     * @throws SecurityException 
     * @throws NoSuchMethodException 
     * @throws InvocationTargetException 
     * @throws IllegalArgumentException 
     * @throws IllegalAccessException 
     */
    public static void testMethodInvoke(Class clazz,Object newInstance) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
        System.out.println("-----------测试方法的调用-----------");
        /**
         * 由于我们知道类中有这种类型的方法,所以我们直接指定要获取的方法类型
         * 如果不知道我们要调用的 方法的类型,我们可以获取方法的参数类型等等所有信息
         * 然后匹配到我们需要调用的方法,这里做个说明,我们要调用的方法名是知道的
         */
        Method sum = clazz.getMethod("sum",int.class,int.class);
        System.out.println(sum);
        sum.invoke(newInstance, 1,1);
        Method setS = clazz.getMethod("setS",String.class);
        System.out.println(setS);
        setS.invoke(newInstance, "赋值啦");
    }
  • 测试类的属性Field
/**
     * 测试类的Field
     * @param clazz
     * @throws IllegalAccessException 
     * @throws IllegalArgumentException 
     */
    public static void testField(Class clazz,Object obj) throws IllegalArgumentException{
        System.out.println("-----------测试类的Field-----------");
        // 获取所以的Field,包括private修饰的,但不能直接获取和直接改变private修饰的值
        Field[] fields = clazz.getDeclaredFields();
        for(int i=0;i<fields.length;i++){
            int dexI = i+1;
            System.out.print("第"+dexI+"个name:"+fields[i].getName()+"  ");
            Class type = fields[i].getType();
            String typeStr = type.getName();
            try{
                if(typeStr.equals("int")){
                    System.out.println("value:"+fields[i].getInt(obj));
                }else if(typeStr.equals("java.lang.String")){
                    // 字符串形式通过get(Object obj)方法取得,如果该Field的权限为private,则 获取值的时候会报java.lang.IllegalAccessException
                    System.out.println("value:"+fields[i].get(obj));
                }
            }catch(IllegalAccessException ex){
                System.out.println("不能获取private修饰的属性值");
            }
        }
    }
  • 测试注解
/**
     * 测试注解(类上的注解),属性方法上的注解分别通过
     * Field对象和Method对象的getAnnotations()方法可以得到
     * 和这里是一样的
     * @param clazz
     */
    public static void testAnnotation(Class clazz){
        System.out.println("-----------测试注解-----------");
        Annotation[] annotations = clazz.getAnnotations();
        for(int i=0;i<annotations.length;i++){
            System.out.println(annotations[i]);
        }
    }
  • 测试泛型
/**
     * 泛型测试
     * @throws NoSuchFieldException
     */
    private static void genericTest() throws NoSuchFieldException {
        System.out.println("-----------获泛型测试-----------");
        Class<ReflectTest> clazz  = ReflectTest.class;
        Field f = clazz.getDeclaredField("map");
        // 直接使用getType()只对普通类型有效,并不能得到有泛型的类型
        
        Class<?> type = f.getType(); 
        // 下面的代码可以看到只输出了java.util.Map
        System.out.println(" map 的类型为:"+type);
        // 获取Field实例f的泛型类型
        Type genericType = f.getGenericType();
        // 如果genericType是ParameterizedType对象
        if(genericType instanceof ParameterizedType){
            ParameterizedType parameterizedType = (ParameterizedType) genericType;
            // 获取原始类型
            Type rawType = parameterizedType.getRawType();
            System.out.println("原始类型是:"+rawType);
            // 取得泛型类型的泛型参数
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            for(int i=0;i<actualTypeArguments.length;i++){
                System.out.println("第"+i+"个泛型类型为:"+actualTypeArguments[i]);
            }
        }else{
            System.out.println("泛型类型获取出错");
        }
    }
  • 获取泛型的实际类型
/**
     * 获取泛型T的实际类型
     */
    public static void getTType(){
        System.out.println("-----------获取泛型T的实际类型-----------");
        Dog dog = new DogImpl();
        // 注意,下面这种写法不能获取到T的实际类型,因为范式要在编译的时候就指定类型,在运行时候指定类型是获取不到真实类型的
//      Dog<Cat> dog = new Dog<Cat>();
    }

修饰符常量对应的值:

这里写图片描述

 由于注释说了很清楚了,所以这里就不过多介绍了,以上这些方法都是参考了api提供的一些方法自己写的一些测试,其实都只是一个简单方法的使用,但这些方法是反射中最基本最常用的方法,api方法很多,所以我们学习api的时候最好时刻查询文档,查看文档是个好习惯。

 总结,java反射机制是java的一个非常重要的一个知识点,其实向spring,struts等等一些知名的框架没有一个没有使用反射,所以学好java反射是提升我们技术必不可少的,我们应该掌握java反射机制。这篇文章与其说是java反射机制的讲解,其实是我自己学习java反射的学习总结,因为学习java也好久了,回顾总结一下所写的知识点,所以文章内容有说错的部分,欢迎指出。

测试代码:http://download.csdn.net/detail/ydxlt/9310157

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;
import javax.xml.ws.soap.Addressing;


/**
 * 测试反射
 * @author lt
 *
 */
public class ReflectTest {
	
	private Map<String,Integer> map;
	public static void main(String[] args) throws Exception {
		// 通过Class的静态方法forName加载类,该方法会初始化类
		Class clazz = Class.forName("Common");
		// 通过反射生成该类的实例,调用public的无参构造方法,反射生成类的实例,该类必须得有一个public的无参方法
		Object newInstance = clazz.newInstance();
		
		testConstructor(clazz);
		testCommonMethodInfo(clazz);
		testMethodInvoke(clazz,newInstance);
		testField(clazz,newInstance);
		testAnnotation(clazz);
		genericTest();
		getTType();
	}
	
	public static void testConstructor(Class clazz){
		System.out.println("-----------构造方法测试-----------");
		// 获取所以的构造方法
		Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
		for(int i=0;i<declaredConstructors.length;i++){
			int index = i+1; // 因为i从0开始
			String str = "第"+index+"个构造方法权限修饰符为";
			if(declaredConstructors[i].getModifiers() == 1){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
				str+="public";
			}
			if(declaredConstructors[i].getModifiers() == 2){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
				str+="private";
			}
			if(declaredConstructors[i].getModifiers() == 4){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
				str+="protected";
			}
			str+="名称为:"+declaredConstructors[i].getName();
			System.out.println(str);
		}
	}
	
	/**
	 * 通过反射调用方法
	 * @param clazz
	 * @throws SecurityException 
	 * @throws NoSuchMethodException 
	 * @throws InvocationTargetException 
	 * @throws IllegalArgumentException 
	 * @throws IllegalAccessException 
	 */
	public static void testMethodInvoke(Class clazz,Object newInstance) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		System.out.println("-----------测试方法的调用-----------");
		/**
		 * 由于我们知道类中有这种类型的方法,所以我们直接指定要获取的方法类型
		 * 如果不知道我们要调用的 方法的类型,我们可以获取方法的参数类型等等所有信息
		 * 然后匹配到我们需要调用的方法,这里做个说明,我们要调用的方法名是知道的
		 */
		Method sum = clazz.getMethod("sum",int.class,int.class);
		System.out.println(sum);
		sum.invoke(newInstance, 1,1);
		Method setS = clazz.getMethod("setS",String.class);
		System.out.println(setS);
		setS.invoke(newInstance, "赋值啦");
	}
	
	
	/**
	 * 这个方法通过反射获取了方法的相关信息,可以看到我们得到了方法
	 * 的全部信息
	 * 这里字符串拼接比较多,由于是测试,所以就没用StringBuffer拼接
	 * @param clazz
	 */
	public static void testCommonMethodInfo(Class clazz){
		System.out.println("-----------普通方法测试-----------");
		Method[] methods = clazz.getMethods();
		System.out.println(methods.length);
		for(int i=0;i<methods.length;i++){
			int dexI = i+1;
			String str = "第"+dexI+"个方法形式为:";
			
			// 获取方法权限修饰符
			int modifiers = methods[i].getModifiers();
			if(modifiers == 1){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
				str+="public";
			}
			if(modifiers == 2){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
				str+="private";
			}
			if(modifiers == 4){ // 这里的常量值可以查看api文档,博客下面也会帖子各种修饰符对应的数字
				str+="protected";
			}
			
			String returnType = methods[i].getReturnType().getSimpleName(); // 获取方法返回类型
			str+=" "+returnType+" "; 
			
			String name = methods[i].getName(); // 获取方法名称
			str+= name;
			str+="(";
			
			// 获取方法参数的类型
			Class[] parameterTypes = methods[i].getParameterTypes();
			for(int j=0;i<parameterTypes.length;i++){
				str+=parameterTypes[j]+" ";
			}
			str+=")";
			System.out.println(str);
		}
	}
	
	/**
	 * 测试类的Field
	 * @param clazz
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	public static void testField(Class clazz,Object obj) throws IllegalArgumentException{
		System.out.println("-----------测试类的Field-----------");
		// 获取所以的Field,包括private修饰的,但不能直接获取和直接改变private修饰的值
		Field[] fields = clazz.getDeclaredFields();
		for(int i=0;i<fields.length;i++){
			int dexI = i+1;
			System.out.print("第"+dexI+"个name:"+fields[i].getName()+"  ");
			Class type = fields[i].getType();
			String typeStr = type.getName();
			try{
				if(typeStr.equals("int")){
					System.out.println("value:"+fields[i].getInt(obj));
				}else if(typeStr.equals("java.lang.String")){
					// 字符串形式通过get(Object obj)方法取得,如果该Field的权限为private,则 获取值的时候会报java.lang.IllegalAccessException
					System.out.println("value:"+fields[i].get(obj));
				}
			}catch(IllegalAccessException ex){
				System.out.println("不能获取private修饰的属性值");
			}
		}
	}
	
	/**
	 * 测试注解(类上的注解),属性方法上的注解分别通过
	 * Field对象和Method对象的getAnnotations()方法可以得到
	 * 和这里是一样的
	 * @param clazz
	 */
	public static void testAnnotation(Class clazz){
		System.out.println("-----------测试注解-----------");
		Annotation[] annotations = clazz.getAnnotations();
		for(int i=0;i<annotations.length;i++){
			System.out.println(annotations[i]);
		}
	}
	
	/**
	 * 获取泛型T的实际类型
	 */
	public static void getTType(){
		System.out.println("-----------获取泛型T的实际类型-----------");
		Dog dog = new DogImpl();
		// 注意,下面这种写法不能获取到T的实际类型,因为范式要在编译的时候就指定类型,在运行时候指定类型是获取不到真实类型的
//		Dog<Cat> dog = new Dog<Cat>();
	}
	
	/**
	 * 泛型测试
	 * @throws NoSuchFieldException
	 */
	private static void genericTest() throws NoSuchFieldException {
		System.out.println("-----------获泛型测试-----------");
		Class<ReflectTest> clazz  = ReflectTest.class;
		Field f = clazz.getDeclaredField("map");
		// 直接使用getType()只对普通类型有效,并不能得到有泛型的类型
		
		Class<?> type = f.getType(); 
		// 下面的代码可以看到只输出了java.util.Map
		System.out.println(" map 的类型为:"+type);
		// 获取Field实例f的泛型类型
		Type genericType = f.getGenericType();
		// 如果genericType是ParameterizedType对象
		if(genericType instanceof ParameterizedType){
			ParameterizedType parameterizedType = (ParameterizedType) genericType;
			// 获取原始类型
			Type rawType = parameterizedType.getRawType();
			System.out.println("原始类型是:"+rawType);
			// 取得泛型类型的泛型参数
			Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
			for(int i=0;i<actualTypeArguments.length;i++){
				System.out.println("第"+i+"个泛型类型为:"+actualTypeArguments[i]);
			}
		}else{
			System.out.println("泛型类型获取出错");
		}
	}
}

@SuppressWarnings(value="unchecked")
@Deprecated
@Addressing
class Common{
	public int a = 3;
	private String s = "dfdff";
	protected int b = 4;
	int c = 5;
	
	public Common(){
		System.out.println("public Constructor invoked");
	}
	
	private Common(String s){
		System.out.println("private Constructor invoked");
	}
	
	protected Common(int i){
		System.out.println("protected Constructor invoked");
	}
	
	
	public void method1(){
		System.out.println("method1 invoked");
	}
	
	public void sum(int x,int y){
		int z = x+y;
		System.out.println("sum="+z);
	}
	
	public void setS(String s){
		System.out.println("s 的之前的值为:"+this.s);
		this.s = s;
		System.out.println("s 赋值之后的值为:"+this.s);
	}
}

class Dog<T>{
	public Class<T> clazz;
	public Dog(){
		getTType();
	}

	private void getTType() {
		// getGenericSuperclass获得带有泛型的父类
		ParameterizedType parameterizedType = (ParameterizedType) getClass().getGenericSuperclass(); 
		clazz = (Class) parameterizedType.getActualTypeArguments()[0];
		System.out.println("clazz的实际类型为:"+clazz.getSimpleName());
	}
}

class Cat{}

class DogImpl extends Dog<Cat>{}

 

本文转载自:http://www.cnblogs.com/ydxlt/p/5031755.html

共有 人打赏支持
不最醉不龟归
粉丝 15
博文 423
码字总数 445380
作品 0
深圳
程序员

暂无文章

八种排序算法的时间复杂度复杂度

1、稳定性 归并排序、冒泡排序、插入排序。基数排序是稳定的 选择排序、快速排序、希尔排序、堆排序是不稳定的 2、时间复杂度 最基础的四个算法:冒泡、选择、插入、快排中,快排的时间复杂度...

陈刚生
35分钟前
2
0
大数据学习系列 Hadoop+Spark+Zookeeper+HBase+Hive集群搭建 图文详解

目录 引言 目录 一、环境选择 1,集群机器安装图 2,配置说明 3,下载地址 二、集群的相关配置 1,主机名更改以及主机和IP做相关映射 2,ssh免登录 3,防火墙关闭 4,时间配置 5,快捷键设置...

董黎明
49分钟前
1
1
六元一个的私有博客系统,了解一下?

神说要有光,于是便有了光 写代码的,偶尔都想装点逼,想要自己写点博客。刚开始还能在各大社区写,比如说CSDN,开源中国,博客园什么的。但是越写就会越觉得,那些博客平台都不是自己想要的...

耒耒耒耒耒
54分钟前
1
0
maven环境隔离

一.maven项目环境根据实际情况进行隔离: 开发环境 dev 测试环境 beta 线上环境 prod 二.pom 配置: build节点 <build> <resources> <resource> <directory>src/......

imbiao
55分钟前
1
0
webrtc收包流程源码分析

版本: webrtc M59 收包流程: AsyncUDPSocket::OnReadEvent AllocationSequence::OnReadPacket HandleIncomingPacket UDPPort::OnReadPacket Connection::OnReadPacket P2PTransportChannel......

bill_shen
56分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部