反射

最新推荐文章于 2021-04-13 09:42:58 发布
最新推荐文章于 2021-04-13 09:42:58 发布
阅读量367 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RunAtWorld/article/details/77148563
版权

1.Java反射机制提供的功能

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时调用任意一个对象的成员变量和方法
  • 生成动态代理


一个反射的例子

package reflections;

import java.io.Serializable;

public class Person implements Serializable{
	private static final long serialVersionUID = 2567283942398849L;
	public String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public Person() {
		super();
	}
	
	public void  show(){
		System.out.println("姓名："+this.name+"     年龄:"+this.age);
	}
	
	public void  display(String nation){
		System.out.println("姓名："+this.name+"     年龄:"+this.age + "   国籍："+nation);
	}
}


package reflections;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.junit.Test;

public class TestReflection {

	public static void main(String[] args) {
		
	}

	//使用反射
	@Test
	public void testPerson() throws Exception{
		Class clazz=Person.class;

		//1.创建clazz对应的运行时的类Person的对象
		Person p=(Person) clazz.newInstance();		
		System.out.println(p);
		//2.通过反射调用指定的属性
		//调用声明为public的属性
		Field f1=clazz.getField("name");
		f1.set(p, "linlin");
		
		//调用声明为private的属性
		Field f2=clazz.getDeclaredField("age");
		f2.setAccessible(true);
		f2.set(p, 18);
		
		System.out.println(p);
		
		//3.通过反射调用运行时类指定的方法
		Method m1=clazz.getMethod("show");
		m1.invoke(p);
		Method m2=clazz.getMethod("display",String.class);
		m2.invoke(p,"CN");
		
	}
}

2.深入理解反射

java.lang.Class是反射的源头。

创建一个类，通过编译（javac.exe），生成对此应的.class文件，之后使用 java.exe加载（用JVM加载器完成）。这个.class文件加载到内存后，就是一个运行时类，存放在缓存区。这个运行时类本身就是一个Class的实例。

1.        每个运行时类只加载一次。

2.        有了Class的实例以后，可以进行如下操作：

a)        创建对应的运行时类的对象

b)        获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在的包、异常、注解）

c)        调用对应的运行时类的指定结构（属性、方法、构造器）

d)        反射的应用：动态代理

 

调用Class对象的newInstance()方法，要求：

1）类必须有一个无参数的构造器。2）类的构造器的访问权限需要足够。

 

难道没有无参的构造器就不能创建对象了吗？

不是！只要在操作的时候明确的调用类中的构造方法，并将参数传递进去之后，才可以实例化操作。步骤如下：

1）通过Class类的getDeclaredConstructor(Class… parameterTypes)取得本类的指定形参类型的构造器

2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。

3）在Constructor类中存在一个方法：

         public T newInstance(Object … initargs)

2.1 获取Class的实例的方法

//获取运行类实例的方法
	@Test
	public void testReflection1(){
		//方式1：调用运行时类本身的.class属性
		Class clazz1=Person.class;
		System.out.println(clazz1);
		
		//方式2：通过运行时类的对象获取
		Person p = new Person();
		Class clazz2=p.getClass();
		System.out.println(clazz2);
		
		//方式3：通过Class的静态方法获取
		String className="reflections.Person";
		Class clazz3;
		try {
			clazz3 = Class.forName(className);
			System.out.println(clazz3);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
		//方式4:通过类的加载器
		ClassLoader cl=this.getClass().getClassLoader();
		Class clazz4;
		try {
			clazz4 = cl.loadClass(className);
			System.out.println(clazz4);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

2.2 类加载器

类加载器是用来把类(class)装载进内存的。JVM 规范定义了两种类型的类加载器：启动类加载器(bootstrap)和用户自定义加载器(user-defined class loader)。 JVM在运行时会产生3个类加载器组成的初始化加载器层次结构。

	@Test
	public void testClassLoader() throws IOException{
		//在源文件目录下获取文件
		ClassLoader loader=this.getClass().getClassLoader();	//获取类加载器
		InputStream is = loader.getResourceAsStream("reflections\\jdbc.properties");
		
		Properties pros=new Properties();
		pros.load(is);
		String name = pros.getProperty("user");
		System.out.println(name);
		
		//在当前工程目录下获取文件
		InputStream is1 = new FileInputStream(new File("jdbc1.properties"));
		Properties pros1=new Properties();
		pros.load(is1);
		String name1 = pros.getProperty("pwd");
		System.out.println(name1);
	}

2.3 获取运行时类的结构

	//通过反射获取类的属性
	@Test
	public void testGetFields(){
		Class clazz = Person.class;
		//getFields()获取运行时类中及其父类中声明为public的属性
		Field[] fields = clazz.getFields();
		for(int i=0;i<fields.length;i++){
			System.out.println(fields[i]);
		}
		
		System.out.println();
		//getDeclaredFields()获取类本身声明的所有属性（不包含父类的属性）
		Field[] fields2 = clazz.getDeclaredFields();
		for(Field v:fields2){
			System.out.println(v);
		}
	}
	
	//获取每个属性的各部分内容：权限修饰符，变量类型，变量名
	@Test
	public void testGetFieldContent(){
		Class clazz = Person.class;
		Field[] fs1 = clazz.getDeclaredFields();
		for(Field f : fs1){			
			//获取权限修饰符
			int b= f.getModifiers();
			System.out.println(Modifier.toString(b));
			//获取属性类型
			System.out.println((f.getType()).getName());
			//获取属性名
			System.out.println(f.getName());
			System.out.println();
		}
	}
	
	//获取运行时方法
	@Test
	public void testGetMethods(){
		Class clazz = Person.class;
		//获取运行时类及其父类中所有的声明为public的方法
		Method[] mds = clazz.getMethods();
		for(Method m : mds){
			System.out.println(m);
		}
		
		System.out.println();
		//获取运行时类定义的所有方法
		Method[] mds2 = clazz.getDeclaredMethods();
		for(Method m : mds2){
			System.out.println(m);
		}
	}
	
	//获取方法的相关内容：注解，权限修饰符，返回值类型，方法名，形参列表，异常
	@Test
	public void testGetMethod2(){
		Class clazz = Person.class;
		Method[] mds2 = clazz.getDeclaredMethods();
		for(Method m : mds2){
			//注解
			Annotation[] anns = m.getAnnotations();
			for(Annotation a : anns ){		
				System.out.println(anns);
			}
			//权限修饰符
			String str = Modifier.toString(m.getModifiers());
			System.out.println(str);
			//返回值类型
			Class returnType = m.getReturnType();
			System.out.println(returnType.getName());
			//方法名
			System.out.println(m.getName());
			//形参列表
			Class[] params = m.getParameterTypes();
			for(int i =0;i<params.length;i++){
				System.out.println("arg-" + i + ":" + params[i].getName());
			}
			//异常
			Class[] exps = m.getExceptionTypes();
			for(int i =0;i<exps.length;i++){
				System.out.println("exp-" + i + ":" +exps[i].getName());
			}
			System.out.println();
		}
	}
	
	//获取构造器
	@Test
	public void getConstructor(){
		Class clazz = null ;
		try {
			clazz = Class.forName("reflections.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
		Constructor[] cons = clazz.getDeclaredConstructors();
		for(Constructor c : cons){
			System.out.println(c);
		}
	}
	
	//获取运行时类的父类
	@Test
	public void getSuperclass(){
		Class clazz = null ;
		try {
			clazz = Class.forName("reflections.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
		//获取父类
		Class sc = clazz.getSuperclass();
		System.out.println(sc);
		
		//获取带泛型的父类
		Type t1 = clazz.getGenericSuperclass();
		System.out.println(t1);
		
		//获取父类的泛型
		Type t2 = clazz.getGenericSuperclass();
		ParameterizedType param = (ParameterizedType) t2;
		Type[] ars = param.getActualTypeArguments();
		System.out.println(((Class)ars[0]).getName());
	}
	
	//获取实现的接口
	@Test
	public void getInterface(){
		Class clazz = null ;
		try {
			clazz = Class.forName("reflections.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Class[] interfaces = clazz.getInterfaces();
		for(Class i : interfaces){
			System.out.println(i);
		}
	}
	
	//获取所在的包
	@Test
	public void getPackage(){
		Class clazz = null ;
		try {
			clazz = Class.forName("reflections.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Package ps = clazz.getPackage();
		System.out.println(ps);
	}
	
	//获取注解
	@Test
	public void getAnnotation(){
		Class clazz = null ;
		try {
			clazz = Class.forName("reflections.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Annotation[] as = clazz.getAnnotations();
		for(Annotation a : as)
			System.out.println(a);
	}


2.4 获取运行时类指定的属性、方法、构造器

	// 通过反射获取类的指定属性
	@Test
	public void testGetField()
			throws NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {
		Class clazz = Person.class;
		// 获取指定属性
		Field name = clazz.getField("name");
		// 创建运行时类
		Person p = (Person) clazz.newInstance();
		System.out.println(p);
		// 设置类的public属性
		name.set(p, "zhang");
		System.out.println(p);

		Field age = clazz.getDeclaredField("age");
		// 设置类的private属性为可进入
		age.setAccessible(true);
		// 设置类的private属性
		age.set(p, 22);
		System.out.println(p);

		Field id = clazz.getDeclaredField("id");
		// 设置类的default属性为可进入
		// id.setAccessible(true);
		// 设置类的default属性
		id.set(p, 11);
		System.out.println(p);
	}

	// 获取运行类实例的指定的方法
	@Test
	public void getMethod() throws NoSuchMethodException, SecurityException, IllegalAccessException,
			IllegalArgumentException, InvocationTargetException, InstantiationException {
		Class clazz = Person.class;
		// 创建实例
		Person p = (Person) clazz.newInstance();
		//获取指定的声明为public方法:public Method getMethod(String name,Class<?>... parameterTypes)
		Method m1 = clazz.getMethod("show");
		// 调用指定的方法 ：invoke(Object obj, Object... args)
		Object retVal = m1.invoke(p); //无返回值，返回null
		System.out.println(retVal);
		
		//getMethod()获取指定的声明为public方法
		Method m2 = clazz.getMethod("toString");
		// 获取返回值对象
		Object retVal2 = m2.invoke(p);//有返回值，返回null
		System.out.println(retVal2);
		
		//调用public静态方法
		Method m3 = clazz.getMethod("info");
		m3.invoke(p);
		
		//调用非public的方法：Method getDeclaredMethod(String name,Class<?>... parameterTypes)
		Method m4 = clazz.getDeclaredMethod("display", String.class,Integer.class);
		m4.setAccessible(true);
		Object retVal4 = m4.invoke(p, "CN",10);
		System.out.println(retVal4);	
	}


	//获取指定的构造器
	@Test
	public void getConstructor() throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		Class clazz = null;
		try {
			clazz = Class.forName("reflections.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
		Constructor con = clazz.getConstructor(String.class,int.class);
		con.setAccessible(true);
		Person p = (Person) con.newInstance("zhangli",26);
		System.out.println(p);		
	}



RunAtWorld
关注
专栏目录
轻轻松松明白什么是反射，反射有什么用，简单上手反射以及反射的优缺点
走过路过不要错过
05-06 1128
1. 什么是反射 反射可以动态获取类信息并创建对象、执行方法、属性赋值等，通过反射，我们就可以通过字节码文件反推得到源代码。 2.反射怎么用 2.1 在使用反射前，我们需要介绍4个类，分别是java.lang.Class、java.lang.reflect.Constructor、java.lang.reflect.Method以及java.lang.reflect.Field。因为对于一个字节码文件来说，其实就是一个类(先不考虑接口、数组等对象)，一个类则主要是4部分：类信息、属性、构造器和方.
mds算法python函数_Python sklearn.manifold 模块，MDS 实例源码 - 编程字典
weixin_39874795的博客
12-11 1302
def validate(classifier, train, test, args, report_base_name):print('\nTraining classifier on%dsamples ...' % len(train.X))start = timeit.default_timer()classifier.fit(train.X, train.y)stop = timeit.d...
反射解决了什么问题
weixin_34247155的博客
03-20 305
反射解决了什么问题及应用场景 反射总结目录 上篇介绍了什么是反射以及FCl中反射的实现，这篇我们来讨进一步讨论反射解决的问题及其应用场景。 在软件开发的过程中我们经常遇见一些相同的问题，比如访问数据库，我们知道数据库的种类繁多，每家数据库供应商都提供了不通的API实现，这就决定我们在软件开发过程中就需要考虑使用的是哪家的数据库他们的API又是什么样子的，...
什么是反射？可以解决什么问题？
zwb的博客
04-13 628
什么是反射？可以解决什么问题？ 什么是反射？ 反射是指程序在运行状态中，可以对任意一个类，都能够获取并调用到这个类的所有属性和方法。 反射是一种能力，一种在程序运行时，动态获取当前类对象的所有属性和方法的能力，可以动态执行方法，给属性赋值等操作的能力。 Class代表的就是所有的字节码对象的抽象，类 反射，让我们的java程序具备动态性 这种动态获取类信息及调用对象方法的功能称为反射 可以破坏单例，除了枚举以外。 在java中，Class类就是关键API public class Reflection {
52.什么是反射？可以解决什么问题？
cxrlover的博客
12-16 287
反射是指程序在运行状态中，可以对任意一个类，都能获取到这个类的所有的属性和方法，可以对任意一个对象，都可以调用它的任意一个方法和属性 反射是一种能力，一种在程序运行时，动态获取当前类对象的所有属性和方法的能力，可以动态执行方法，给属性赋值等操作的能力 Class 代表的就是所有的字节码对象的抽象类 反射，可以让java程序具有动态性 这种动态获取类信息以及调用对象方法的功能成为反射 在java中，Class类就是关键的API 这种能力可以可以带来很多好处，许多框架在实现的别后都使用了反射，都采用了反射的方式
MDS（multidimensional scaling）多维尺度分析
热门推荐
迭代的是人，递归的是神
02-28 7万+
大家一般想到降维，就自然想到一种方法PCA，其实还有一种方法MDS（multidimensional scaling），可以获得样本间的相似性的空间表达。 先说说这两种方法的相似处，PCA是把观察的数据用较少的维数来表达，这点上两种方法的相似的；两种方法的不太之处在于，MDS利用的是成对样本间相似性，目的是利用这个信息去构建合适的低维空间，是的样本在此空间的距离和在高维空间中的样本间的相似性尽可
P波入射C程序_P波反射系数计算_反射系数_
10-01
对于P波来说，有两个重要的反射系数：P波反射系数（用于P波的反射）和SV波反射系数（用于剪切波，即S波的垂直分量的反射）。这里我们主要关注P波反射系数。 P波反射系数（R_PP）的计算公式为： \[ R_{PP} = \frac{\...
matlab模拟光的反射折射.pdf
07-13
标题中的"matlab模拟光的反射折射.pdf"指的是使用MATLAB软件进行光学现象的模拟，具体是关于光的反射和折射。MATLAB是一款强大的数学计算和数据可视化软件，它可以用于创建复杂的模型和模拟实验，包括物理学中的光学...
matlab计算反射阵单元相位(460652)_matlab反射阵相位_matlab反射阵_反射阵matlab_反射阵
09-14
在本文中，我们将深入探讨如何使用MATLAB进行反射阵天线单元相位的计算，这是无线通信和雷达系统中的一个重要概念。MATLAB是一种强大的数学计算软件，尤其适用于数值分析和算法开发，因此它是处理此类问题的理想工具...
computing-reflecting-series.rar_反射波 matlab_反射系数褶积_反射系数设计_合成地震_地震
07-14
本压缩包"computing-reflecting-series.rar"提供了一种使用MATLAB进行反射波模拟和处理的方法，主要涉及以下几个核心知识点： 1. 反射波：在地球内部不同介质的界面，地震波会部分反射，部分透射。这些反射波携带了...
反射：C ++ 14反射库
01-30
在C++编程语言中，反射是一种允许程序在运行时检查自身结构和行为的能力。随着C++17标准的发布，虽然官方并没有直接提供反射机制，但开发者社区已经开始探索和实现各种反射库，以弥补这一功能的缺失。"反射：C++ 14...
降维 之 MDS算法 的直觉
木剑温华 的 博客
11-30 1969
为什么 需要降维呢？   因为啊，在高维空间中，如果要满足密采样，那么需要的样本数就太多了，惹不起惹不起， （比如，1维时填充单位空间需要三个样本，   2维时填充单位空间需要九个样本，3维时需要27个。。。。。。那么 100维就需要3^100个样本，这就太可怕了。）另外，高维空间中的距离是特别奇怪的。   为什么能降维呢？ 这是因为在很多时候，人们观察或收集到的很多样本虽是高维的，但...
人工智障学习笔记——机器学习(14)mds&isomap降维
九日王朝
12-18 4221
一.概念 MDS（多维缩放）降维是一组对象之间的距离的可视化表示，也可以当做一种无监督降维算法使用。而Isomap（等度量映射）是在MDS算法的基础上衍生出的一种非迭代的全局优化算法，它是一种等距映射算法，也就是说降维后的点，两两之间距离不变，这个距离是测地距离。 二.算法 MDS算法的思想其实是巧妙的，即通过利用对点（数据）做平移，旋转，翻转等操作，点的距离是不变的这一特性来对
模式识别之 MDS Multidimensional Scaling 多维尺度法 分析及Matlab实现
Flood Sung的专栏
12-29 2万+
在模式识别中，我们会考虑到距离distance的问题，就是一个样本和另一个样本在空间中的距离。根据距离的大小来判断分类。那么，也存在这样的一类问题：我们只知道空间中的点（样本）的距离，那么怎么来重构这些点的相对位置呢？ 显然欧式距离是最直观的距离，那么我们就会想使用欧式距离来进行计算重构，我们还希望能够在不同维度上进行重构，比如2维或者3维。 怎么做？ 有这么个解决方法叫做MDS 全称为 Mult
Java中为什么需要反射？反射要解决什么问题？
dearbaba_8520的博客
06-20 447
Java中为什么需要反射？反射要解决什么问题？
使用BeanUtils完成Bean拷贝
RunAtWorld：常常想想自己能解决什么问题
08-06 1400
项目中经常要用到Bean之间的属性复制，本文主要介绍了几种常见的Bean拷贝工具以及几种在Bean拷贝过程中根据需要实现Bean字段类型转换的方法。​ 项目中经常要用到Bean之间的属性复制，如果自己使用 set 方法逐个设值，不仅运行效率低，如果用到的地方很多，代码维护也很困难。实际上，已经有很多可以完成 Bean 属性复制的工具。本文就来重点讨论一下。本文主要包括以下内容: 选择哪个框架的Bean工具效率最高 封装springBean工具自定义copyBeanProperties实现Bean拷贝 .
Java反射机制深入探索
"Java反射机制详解及应用实例" Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时获取任何已知名称的类的内部信息，并能够在运行时动态地改变对象的字段内容或调用方法。这一特性使得Java具备了更高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值