java反射机制学习笔记

最新推荐文章于 2021-12-01 11:04:12 发布
最新推荐文章于 2021-12-01 11:04:12 发布
阅读量384 收藏
点赞数 1
分类专栏： Java语言基础 文章标签： Class java反射机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fly_zxy/article/details/59541075
版权

java反射机制学习笔记

计划想系统的学习一下java反射机制、注解知识，然后自己实现一个ORM框架来加深和巩固对这部分知识的理解。本片文章对java反射机制常用的API进行了总结，并提供了一个代码事例来理解java反射API。

java反射机制总结


如果看不清图片，请鼠标右键选择在新标签也打开。

这张思维导图并没有用连接线关联出它们之间的继承关系，但是有几个重要的继承和实现关系我们需要知道。
  1. Class类实现了以下接口：
    java.io.Serializable;用于序列化
    java.lang.reflect.GenericDeclaration;读取泛型
    java.lang.reflect.Type;读取泛型
     java.lang.reflect.AnnotatedElement:用于读取注解
  2. Constructor<T>和Method类实现了以下接口：
    java.lang.reflect.GenericDeclaration;读取泛型
    java.lang.reflect.Member;获取方法名字、访问修饰符等相关信息
    继承了以下类：
    java.lang.reflect.AccessibleObject;取消默认的java语言控制访问检查能力

  3. Field类实现了以下接口：
    java.lang.reflect.Member;获取字段名字、访问修饰符等相关信息
    继承了一下类：
    java.lang.reflect.AccessibleObject;取消默认的java语言控制访问检查能力

  4. AccessibleObject类继承了以下类：
     java.lang.reflect.AnnotatedElement;用于读取注解

java反射这一部分对泛型的读取以及读取泛型的用途还没有搞清楚，希望在以后的应用中能接触到并搞懂。

java反射代码事例

CleverAnimal.java 
package reflection;

public class CleverAnimal {
	
	public String color;
	
	private int height;
	private int  weight;
}
Sports.java 
package reflection;

public interface Sports {
	
	String SPROTS_TYPE = "RUN";
	
	void run();
}
People.java 
package reflection;

public class People extends CleverAnimal implements Sports {
	
	public String SPROTS_TYPE = "RUN";
	
	public String name;
	
	private long id;
	private int age;
	
	public People(){}
	
	public People(long id, int age){
		this.id=id;
		this.age=age;
	}
	
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("学生跑步");
	}
	
}
ElementDesc.java 
package reflection;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.FIELD,ElementType.TYPE,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ElementDesc {
	//对应用此注解元素的一个描述(或者说简介)
	public String value() default "什么都没有";
}
Student.java 
package reflection;

import java.io.Serializable;

@ElementDesc(value = "Student类,为了理解反射和注解读取的事例")
public class Student extends People implements Serializable {
	
	@ElementDesc(value="schoolName字段,代表学校名称")
	public String schoolName;
	
	private String subject;
	private int grade;
	
	public Student(){}
	
	public Student(long id, int age, String subject,int grade){
		this(id, age);
		this.subject=subject;
		this.grade=grade;
	}
	
	@ElementDesc(value="我是一个私有的Student构造方法,你或许可以通过反射来调用我")
	private Student(@ElementDesc(value="唯一凭证")long id, int age){
		super(id,age);
	}
	
	public String getSubject() {
		return subject;
	}
	public void setSubject(String subject) {
		this.subject = subject;
	}
	public int getGrade() {
		return grade;
	}
	public void setGrade(int grade) {
		this.grade = grade;
	}
	
	@ElementDesc(value="我是一个Student类私有方法,你或许可以通过反射来调用我,我叫 privateMethod.")
	private void privateMethod(){
		System.out.println("学生的私有方法。");
	}	
}
ReflectionExample.java 
package reflection;

import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class ReflectionExample {

	public static void main(String [] args){
		//fieldExample();
		//methodExample();
		//constructorExample();
		//invokeMethod();
		//invokeField();
		parserAnnotation();
		//arrayExample();
		//parserGeneric();
	}
	
	/**
	 * 获取类的Fields
	 */
	public static void fieldExample(){
		Student student = new Student();
		Class<?> studentClass = student.getClass();
		
		System.out.println("=================getFields()");
		Field [] fields = studentClass.getFields();
		for(Field f:fields){
			System.out.println(f);
		}
		
		System.out.println("\n=================getDeclaredFields()");
		fields = studentClass.getDeclaredFields();
		for(Field f:fields){
			System.out.println(f);
		}
	}
	/**
	 * 获取类的Method
	 */
	public static void methodExample(){
		Class<?> studentClass = Student.class;
		
		System.out.println("=================getMethods()");
		Method [] method = studentClass.getMethods();
		for(Method m:method){
			System.out.println(m);
		}
		
		System.out.println("\n=================getDeclaredMethods()");
		method = studentClass.getDeclaredMethods();
		for(Method m:method){
			System.out.println(m);
		}
		
		try {
			//按顺序声明setId()方法的类型已经个数
			//一个long类型的参数
			Class<?> [] parameterTypes = {long.class};
			//如果parameterTypes传递null,则按空数组处理
			Method m = studentClass.getMethod("setId", parameterTypes);
			System.out.println("获取getMethod(\"setId\", parameterTypes):"+m);
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 获取类的Constructor
	 */
	public static void constructorExample(){
		try {
			Class<?> studentClass = Class.forName("reflection.Student");
			
			System.out.println("=================getConstructors()");
			Constructor [] cons = studentClass.getConstructors();
			for(Constructor c:cons){
				System.out.println(c);
			}
			
			System.out.println("\n=================getDeclaredConstructors()");
			cons = studentClass.getDeclaredConstructors();
			for(Constructor c:cons){
				System.out.println(c);
			}

		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 通过反射调用方法
	 */
	public static void invokeMethod() {
		
		try {
			Class<?> studentClass = Student.class;
			Object inst = studentClass.newInstance();
			
			Method setSubjectMethod = studentClass.getDeclaredMethod("setSubject", String.class);
			Object reObj = setSubjectMethod.invoke(inst, "计算机科学");
			System.out.println(reObj);
			
			Method getSubjectMethod = studentClass.getDeclaredMethod("getSubject", null);
			reObj = getSubjectMethod.invoke(inst, null);
			System.out.println(reObj);
			
			//invoke一个private方法
			Method privateMethod = studentClass.getDeclaredMethod("privateMethod", null);
			privateMethod.setAccessible(true);
			reObj = privateMethod.invoke(inst, null);
			System.out.println(reObj);

		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 通过反射设置字段
	 */
	public static void invokeField(){
		try {
			Class<?> studentClass = Student.class;
			Object inst = studentClass.newInstance();
			
			Field schoolNameField = studentClass.getDeclaredField("schoolName");
			schoolNameField.set(inst, "黑龙江大学");
			Object obj = schoolNameField.get(inst);
			System.out.println(obj);
			
			Field subjectField = studentClass.getDeclaredField("subject");
			subjectField.setAccessible(true);
			subjectField.set(inst, "计算机科学");
			obj = subjectField.get(inst);
			System.out.println(obj);
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 读取注解
	 */
	public static void  parserAnnotation(){
		Class<?> stuClass = Student.class;
		Class<ElementDesc> annClass = ElementDesc.class;
	
		try {
			Object stuObj = stuClass.newInstance();
			
			if(stuClass.isAnnotationPresent(annClass)){
				ElementDesc elDesc = stuClass.getAnnotation(annClass);
				System.out.println("\n读取Student类上的ElementDesc注解:\n"+elDesc.value());
			}
			
			Constructor cons = stuClass.getDeclaredConstructor(long.class, int.class);
			if(cons.isAnnotationPresent(annClass)){
				ElementDesc elDesc = (ElementDesc) cons.getAnnotation(annClass);
				System.out.println("\n读取Student类构造方法上的ElementDesc注解:\n"+elDesc.value());
			}
			System.out.println("\n读取Student类构造方法形参上的ElementDesc注解:");
			Annotation [][] annss = cons.getParameterAnnotations();
			for(int i=0;i<annss.length;i++){
				Annotation[] anns = annss[i];
				if(anns.length==0) continue;
				Annotation ann = anns[0];
				if(ann instanceof ElementDesc){
					System.out.println( ((ElementDesc) ann).value() );
				}
			}
			
			System.out.println("\n读取Student类构造方法向形参类型：");
			Class [] parTypes = cons.getParameterTypes();
			Long ll = new Long(1L);
			for(Class c:parTypes){
				System.out.println("type name:"+c.getName());
			}
			
			
			Method method = stuClass.getDeclaredMethod("privateMethod", null);
			if(method.isAnnotationPresent(annClass)){
				ElementDesc elDesc = method.getAnnotation(annClass);
				System.out.println("\n读取Student类privateMethod()上的注解:\n"+elDesc.value());
			}
			
			Field field = stuClass.getDeclaredField("schoolName");
			if(field.isAnnotationPresent(annClass)){
				ElementDesc elDesc = field.getAnnotation(annClass);
				System.out.println("\n读取Student类schoolName字段上的注解:\n"+elDesc.value());
			}
			
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 读取泛型
	 */
	public static void parserGeneric(){
		Class arrListCls = ArrayList.class;
		try {
			
			TypeVariable<Class> [] classTypeVars = arrListCls.getTypeParameters();
			for(TypeVariable<Class> tv:classTypeVars){
				System.out.println(tv.toString());
				Type [] ts = tv.getBounds();
				Arrays.toString(ts);
				
			}
			
			Constructor<ArrayList<String>> cons = arrListCls.getConstructor(Collection.class);
			System.out.println( cons.toGenericString() );
			
			TypeVariable<Constructor<ArrayList<String>>> [] consTypeVars = cons.getTypeParameters();
			for(TypeVariable<Constructor<ArrayList<String>>> tv:consTypeVars){
				System.out.println(tv.toString());
			}
			
			Type [] types = cons.getGenericParameterTypes();
			for(Type t:types){
				System.out.println(t.toString());
			}
			
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	/**
	 * Array操作事例
	 */
	public static void arrayExample(){
		Object arr1 = Array.newInstance(String.class, 10);
		String [] arr2 = (String[]) arr1;
		for(int i=0;i<Array.getLength(arr2);i++){
			System.out.println(Array.get(arr2, i));
		}
		
		System.out.println("==========");
		
		Object arr3 = Array.newInstance(int.class, 10,2);
		int [][] arr4 = (int[][]) arr3;
		for(int i=0;i<Array.getLength(arr3);i++){
			int []arr5 = arr4[i];
			System.out.println( Arrays.toString(arr5) );
		}
	}
}
参考文章：
http://www.infoq.com/cn/articles/cf-java-generics
SuperMan-zhang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Java学习笔记]-反射机制
xyzhang的博客
10-22 144
一.反射机制获取类对象 类对象概念： 所有的类，都存在一个类对象，这个类对象用于提供类本身的信息，比如有几种构造方法， 有多少属性，有哪些普通方法。 获取类对象： 在一个ClassLoader中，一种类只会有一个类对象存在，获取类对象有以下三种方式，但这三种方式取出来的类对象都是一样的 String classname = "reflection.Heros"; try { ...
Java反射机制笔记
yinhuanxu
08-07 2301
很多时候，java程序运行中，我们需要在运行时了解类的信息，得到类的实例，并且进而继续得到类的方法，构造函数，权限，变量以及其他信息。这时候我们需要用到一门技术，java反射反射说白了，就是把我们的一些文件，一些字符串，一些地址上具体的配置信息，能够把他们动态的在运行期实例化，并且我们能够操作这些实例
Java 反射机制 学习笔记
cjdgg的博客
12-01 3143
Java 反射机制 学习笔记前言什么是 Java Reflection 前言 上次学了Java RMI相关的知识后，感觉收获挺大的，今天跟着H0t-A1r-B4llo0n师傅继续学习Java 反射机制这篇文章算是读完师傅文章做的一些记录吧 什么是 Java Reflection ...
Java 反射机制学习笔记
DeMonnnnnn
08-22 639
概念JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。 反射是Java中一种强大的工具，能够使我们很方便的创建
Java反射机制学习笔记
命里有时终须有
08-21 249
资源：《java反射机制》——侯捷
java反射机制学习笔记+反射机制实操案例
05-27
总结来说，Java反射机制是Java语言的一个重要特性，它使得程序能够在运行时动态地获取类的信息并进行操作，提高了代码的通用性和适应性。在实际开发中，反射机制常用于框架设计、插件系统、数据持久化等领域，但同时...
java学习笔记java反射机制
最新发布
08-23
java学习笔记java反射机制
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java基础学习笔记之反射
09-02
Java反射是Java编程语言的一个重要特性，它允许程序在运行时检查类的信息并动态地创建和操作类的对象。反射提供了一种方式，使得程序能够访问和修改私有成员（包括字段和方法），甚至调用私有构造器。这种能力使得...
java 继承中的重写父类方法
热门推荐
fly_zxy的专栏
05-10 2万+
重写父类方法子类扩展(extends)了父类，子类是一种特殊的父类。子类可以获得父类所有的属性和方法，达到代码复用的目的。子类总以父类为基础增加新的属性和方法。但是有时候我们还需要重写(覆盖)父类的方法。子类覆盖父类的方法遵循的是“两同两小一大”原则。两同指的是方法名和形参列表相同。两小指的是子类方法的返回值类型要小于或等于父类被覆盖方法的返回值，子类方法声明抛出的异常应比父类方法抛出的异常要小或相
记一次将spring-boot应用发布到weblogic的步骤以及遇到的问题
fly_zxy的专栏
06-28 9059
说明 环境 linux：Red Hat 4.8.3-9 weblogic：weblogic 12.1.3 JDK：JDK1.8 程序环境 构建构建：Apache Maven 3.6.1 框架：ijcf 3.2.0(啊，使我们公司的一个内部框架，你可以理解为Spring、Spring-boot、Spring-web、Spring-MVC等对Spring开源框架的二次封装) 应用程序本身是一个后台ja...
javac、java和jar命令
fly_zxy的专栏
08-16 7401
javac和java命令 背景 我是一个java程序员，平时运行程序都是由IDE或Maven来完成，应用上线部署都是由其他人来写Shell或bat启动停止脚本，有一天让我把一个后台应用打包jar在Linxu或Window部署运行我竟然蒙B了，好半天才想起来javac和java。 javac命令 javac命令的作用是将java文件编译为class文件。 用法：javac <options&g...
java web.xml配置文件中url-pattern路径匹配方式
fly_zxy的专栏
12-13 7052
java web.xml配置文件中url-pattern路径匹配方式 url-pattern元素用于匹配对应的Servlet或Filter。使用事例如下： dispatcherServlet org.springframework.web.servlet.DispatcherServlet contextClass org.springf
Java组成部分、JDK和SDK的区别、JDK的安装
fly_zxy的专栏
04-28 6105
一，java组成部分 java分为三个组成部分JavaSE、JavaEE、JavaME： 1，JavaSE(Java SE Development Kit)：中文是Java标准开发工具，是JavaEE和JavaME的核心和基础。对应的开发包就是我们常用的JDK。2，JavaEE：Java技术中应用最广泛的技术，JavaEE提供了企业的开发解决方案。对应的开发包就是Java
服务启动tomcat时 执行Runtime.getRuntime().exec() 卡死
fly_zxy的专栏
04-08 5981
问题描述 项目里要实现一个功能：用java代码 Runtime.getRuntime().exec("C:\smryglclient\smryglhostmsg.exe gensn") 去执行cmd命令，并接受返回结果。一开始在我本机STS里运行时没有问题的，其它同事的机器也是正常运行。把整个web项目做成一个exe可执行程序。在测试机器上安装后执行到这段代码是卡住没有反应。具体是卡到读取执行c
http https session丢失
fly_zxy的专栏
03-27 4991
现象描述 项目中仅在登录时使用https连接进行登录请求，登录成功会使用http访问服务器的其它资源。也就说从https连接切换到http。输入正确的用户和密码后总是跳转到登录页面，并没有跳转到主页面。debug了一下程序，发现在跳转到主页时，程序认为 request.getSession("userInfo") 获取的用户信息为 null，用户没有登录。而不适用https连接请求登录，输入正确
java中replace()和replaceAll()总结
fly_zxy的专栏
04-08 4136
replace()和replaceAll()比较 示例 我么有这么一个需求：将字符串中的"\"替换成"\\"。实现如下： public static void main(String [] args){ String sourceStr = "A\\B\\C\\D"; System.out.println("sourceStr:"+sourceStr)
Maven学习笔记(一)-使用Maven创建项目以及常用Maven命令
fly_zxy的专栏
11-18 3819
使用Maven创建项目以及常用Maven命令 现在技术书籍上的代码事例和公司的项目大多数都会选择Maven做项目管理和构建工具。所以对Maven都有一个较全面的理解多我们会有很大的收益。下面我们使用Maven来创建一个java项目。按照Maven就不再接受网上有很多文章。 使用Maven创建项目 我们的需求是创建一个java项目(非web项目)。首先打开cmd，切换到你要放项目的目录。我的这
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值