JAVA——Day 14反射机制

最新推荐文章于 2024-09-30 10:36:33 发布
最新推荐文章于 2024-09-30 10:36:33 发布
阅读量182 收藏
点赞数
分类专栏： JAVA学习 文章标签： java 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YiRenGengShangBuQi/article/details/104388101
版权

反射

反射机制，就是通过一个抽象的类名能够在自己记忆（加载类的内存）中找到相匹配的类的具体信息
注：java能够反射的前提：已经加载过这个类，就可以通过类名来寻找到这个类的所有相关信息

Java Reflection

Reflection(反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能够直接操作任何对象的内部属性及方法
在这里插入图片描述在这里插入图片描述

一、Class类

在这里插入图片描述在这里插入图片描述在这里插入图片描述

package day14;

/**
 * 一、Class类
 */
public class ClassLearn {
	public static void main(String[] args) {
		Person p = new Person();
		Class clazz = p.getClass();	
		//clazz包含了p所属的Person类的所有信息
		
		Class c0 = Person.class;
		//创建指定类的class实例
		
		Class c1 = p.getClass();
		//通过一个类的实例对象的getClass()方法
		
		try {
			Class c2 = Class.forName("day14.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		//通过Class的静态方法forName(String name)
		//传入参数是包名.类名
		//常用
	}
}

通过反射调用类的完整结构

package day14;

public class Test {
	public static void main(String[] args) {
		try {
			Class clazz = Class.forName("day14.Student");
			Class superClass = clazz.getSuperclass();
			System.out.println("父类名："+superClass.getName());
			//获取父类
			Class[] interfaces = clazz.getInterfaces();
			//获取当前类的所有接口
			for(Class a:interfaces) {
				System.out.println("接口:"+a.getName());
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

在这里插入图片描述

package day14;

import java.lang.reflect.Constructor;

public class Test {
	public static void main(String[] args) {
		try {
			Class clazz = Class.forName("day14.Student");
			Class superClass = clazz.getSuperclass();
			System.out.println("父类名："+superClass.getName());
			//获取父类
			Class[] interfaces = clazz.getInterfaces();
			//获取当前类的所有接口
			for(Class a:interfaces) {
				System.out.println("接口:"+a.getName());
			}
			Constructor[] con = clazz.getConstructors();
			//获取类共有构造方法
			
			for(Constructor c :con) {
				System.out.println("构造方法名称："+c.getName());
				System.out.println("修饰符是："+c.getModifiers());
				//返回数字1代表public
			}
			
			Constructor[] con1 = clazz.getDeclaredConstructors();
			//获取类的所有构造方法
			
			for(Constructor c :con1) {
				System.out.println("构造方法名称："+c.getName());
				System.out.println("修饰符是："+c.getModifiers());
				Class[] cp = c.getParameterTypes();
				for(Class c2 :cp) {
					System.out.println("参数类型是："+c2.getName());
				}
				//返回数字2代表private
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

通过反射创建一个对象&&调用私有构造

package day14;

import java.lang.reflect.Constructor;

/**
 * 通过反射创建一个对象
 */
public class ReflectCreatClassLearn {
	public static void main(String[] args) {
		try {
			testCraet();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void testCraet() throws Exception{
		Class clazz = Class.forName("day14.Student");
		Object obj = clazz.getDeclaredConstructor().newInstance();
		//Class.newinstance方法废弃了
		Student stu = (Student)obj;
		
		Constructor con = clazz.getConstructor(String.class);
		Student stu2 = (Student)con.newInstance("阳光小学");
		System.out.println(stu2.school);
		//Constructor.newInstance没被废弃
		//通过反射构造器的方法创建对象
		//通过反射机制可以强制的调用私有的构造方法
		Constructor pri = clazz.getDeclaredConstructor(String.class,int.class);
		pri.setAccessible(true);
		//解除私有封装，对私有方法强制调用
		Student stu3 = (Student)pri.newInstance("吼吼吼",123);
		System.out.println(stu3.age);
		System.out.println(stu3.name);
	}
}

反射机制获取类的方法

在这里插入图片描述

package day14;

import java.lang.reflect.Method;

/**
 * 通过反射机制来调用方法及私有方法
 *
 */
public class ReflectionGetPrivateMethod {
	public static void main(String[] args) {
		try {
			test();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	private static void test() throws Exception{
		Class clazz = Class.forName("day14.Student");
		Method[] m = clazz.getMethods();
		//获取到类的所有公有方法
		for(Method s:m) {
			System.out.println(s.getName());	//方法名
			System.out.println(s.getReturnType());//返回值类型
			System.out.println(s.getModifiers());//修饰符
			Class[] obj = s.getParameterTypes();
			//参数类型，是一个数组，方法的参数几个，数组就几个元素
			if(obj != null && obj.length>0) {
				for(Class j:obj) {
					System.out.println("参数类型："+j.getName());
				}
			}
			System.out.println("****************************");
		}
	}
}

反射机制获取类的属性和包

在这里插入图片描述

package day14;

import java.lang.reflect.Field;
/**
 * 反射机制调用类的属性
 */
public class ReflectionGetFieldAndPackageLearn {
	public static void main(String[] args) {
		try {
			testGetFieldAndPackage();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void testGetFieldAndPackage() throws Exception {
		Class clazz = Class.forName("day14.Student");
		Field[] fd = clazz.getDeclaredFields();
		//不包含父类属性
		Field[] fd2 = clazz.getFields();
		//公有属性，包含父类公有属性
		for(Field f:fd) {
			System.out.println("修饰符："+f.getModifiers());
			System.out.println("值类型："+f.getType());
			System.out.println("属性名："+f.getName());
		}
		
		Package p = clazz.getPackage(); //获取包
		System.out.println(p.getName());
	}
}

通过反射调用类中的指定方法、指定属性

在这里插入图片描述

调用指定方法

package day14;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * 使用反射机制调用指定方法和属性
 *
 */
public class ReflectUseMethodAndFieldLearn {
	public static void main(String[] args) {
		try {
			testuse();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 此时obj对象就相当于Student类的实例化
	 */
	public static void testuse() throws Exception{
		Class clazz = Class.forName("day14.Student");
		Constructor con = clazz.getConstructor();
		Object obj = con.newInstance();
		Method m = clazz.getMethod("movetype");
		m.invoke(obj);
		//不能调用private的方法
		
		Method m2 = clazz.getDeclaredMethod("testReflectGetPrivate");
		//可以访问到private方法
		m2.setAccessible(true);//强制调用
		m2.invoke(obj);
	}
}

调用指定属性

在这里插入图片描述

package day14;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * 使用反射机制调用指定属性
 *
 */
public class ReflectUseMethodAndFieldLearn {
	public static void main(String[] args) {
		try {
			testuse();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void testuse() throws Exception{
		Class clazz = Class.forName("day14.Student");
		Constructor con = clazz.getConstructor();
		Student stu = (Student)con.newInstance();
		Field f = clazz.getDeclaredField("secrect");
		f.setAccessible(true);
		f.set(stu, "秘密能说？");//对stu对象的secrect属性设置
		System.out.println(f.get(stu));
		//获取stu对象的secrect属性的值
		
	}
}

Java动态代理

在这里插入图片描述

package day14;

public interface Itest {
	void test1();
	void test2();
}

package day14;

/**
 * Java动态代理
 */
public class JavaDynamicProxyLearn implements Itest{
	@Override
	public void test1() {
		System.out.println("这是方法一");
	}

	@Override
	public void test2() {
		System.out.println("这是方法二");
	}
}

package day14;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 这是动态代理类
 */
public class ProxyDemo implements InvocationHandler{
	
	Object obj;//被代理的对象
	public ProxyDemo(Object obj) {
		this.obj =obj;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println(method.getName()+"方法开始执行");
		Object result = method.invoke(this.obj,args);
		//执行的是指定代理对象的指定方法
		System.out.println(method.getName()+"方法执行完毕");
		return result;
	}
	
}

package day14;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class TestProxy {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		JavaDynamicProxyLearn jd = new JavaDynamicProxyLearn();
		jd.test1();
		jd.test2();
		/**
		 * 需求
		 * 在执行test1,test2方法时需要加东西
		 * 在执行方法前打印test1或test2开始执行
		 * 在执行方法后打印test1或test2执行完毕
		 */
		InvocationHandler handler = new ProxyDemo(jd);
		/**
		 * Proxy.newProxyInstance(loader, interfaces, h)
		 * 参数1是代理对象的类加载器
		 * 参数2是被代理对象的接口
		 * 参数3是代理对象
		 * 返回的值就是成功被代理后的对象
		 */
		Itest t = (Itest)Proxy.newProxyInstance(
				jd.getClass().getClassLoader()
				, jd.getClass().getInterfaces(), handler);
		//注意这里要用接口来转换，参数1和参数2用的是要代理的对象，不是InvocationHandler的对象
		t.test1();
		t.test2();
	}
}
Vincent_frost
关注
专栏目录
Java学习——Day15：Java反射机制
zxzx666的博客
08-05 202
8.1 Java反射机制概述 Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期 借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内 部属性及方法。 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个 类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可 以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。 Java反射机制提供的功能 在运行时判断
Java基础day25 ——反射
liang79096的博客
04-23 676
补充说明 不会改变结构@Override 说明重写@Deprecated 说明当前结构过时@SuppressWarnings 抑制警告/*注解：注解用来对类中的一些结构进行补充说明 并不会改变原有的结构系统中的注解：@Override ：用来说明当前方法是一个重写的方法@Deprecated : 用来说明当前结构（比如：方法，属性）已经过时@SuppressWarnings : 抑制警告（警告不是错误可以忽略）*/class A{@Override自定义注解。
Java学习笔记——Java反射机制
Runner1st的博客
02-25 234
文章目录1 简介2 Class 类2.1 获取Class类的实例2.2 创建类对象3 获取运行时类的完整结构3.1 类的属性3.2 类的方法3.3 构造器3.4 其他4 调用类中的指定属性、方法和构造器5 动态代理 1 简介 Java Reflection ​ Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信...
JavaDay5——注解和反射
qq_41256473的博客
07-28 136
1、类加载器 1.1类加载 当你需要使用某个类的时候，但是这个类还没有被加载到内存中，系统会通过类的加载，连接，初始化三个步骤对要加载的类进行初始化，这三个步骤也被统称为类加载或类的初始化 1.2类加载器 作用：负责将.class文件加载到内存中，并与之生成对应的java.lang.class对象 三种类加载器关系：Bootstrap class loader>Platform class loader>System class loader public static void main(
java——了解反射
jtjeeeee的博客
05-05 96
一，Java反射机制 1、是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。 2、由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定。在运行期仍然可以扩展 二，获得Class类的对象 使用类的class属性来获取该类对应的Class对象。举例: Student.class将会返回Student类对应的Class对象 调用对象的getClass()方法，返回该对象所属类对应的Class对象 使用Class类中的静态方法forName(St
Java复习——核心机制之反射
u014792301的博客
04-10 153
反射 能够分析类能力的程序称之为反射 反射机制可以用来： 在运行时分析类的能力 在运行时查看对象 实现通用的数组操作代码 利用Method对象 Class类 在程序运行期间，Java 运行时系统始终为所有的对象维护一个被称为运行时的类型标识 。这个信息跟踪着每个对象所属的类。虚拟机利用运行时类型信息选择相应的方法执行 。 然而，可以通过专门的 Java 类访问这些信息。保存这些信息的类被称为C...
小汤学编程之JAVA基础day14——xml和反射
SoupTC的博客
11-10 227
一、xml 1.简介     2.特点     3.使用步骤 二、Reflect反射 1.概念     2.理解Class类     3.反射的功能     4.两个案例 一、xml 1.简介 xml是一种可扩展标记语言，简称XML。可用来存储和传输数据。 例如： <families> <family> &lt.
Java进阶 —— 注解与反射
荔枝当大佬的博客
07-24 231
在了解完Java中的集合和IO流之后，荔枝继续梳理有关Java反射的知识，这个基础知识点也是在面试中可能会考到滴哦~~~在这篇文章中，荔枝主要梳理了有关Java反射、动态代理类的实现和注解的相关知识。其中Java反射中通过反射来获取指定方法、属性、父类和接口等内容需要掌握，还有一个重点就是如何实现动态代理类。
java基础类库——反射机制（七）
weixin_54811122的博客
04-29 733
java基础类库——反射机制
JavaSE——反射机制
weixin_56341892的博客
01-01 368
反射机制 一、反射机制概述 反射机制的作用 通过java语言中的反射机制可以操作字节码文件。优点类似于黑客。（可以读和修改字节码文件。）通过反射机制可以操作代码片段。（class文件。） 反射机制的相关类在哪个包下？ java.lang.reflect.*; 反射机制相关的重要的类 java.lang.Class：代表整个字节码，代表一个类型，代表整个类。 java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。 java.lang.reflect.Co
Java核心基础——06 - 反射与注解
m0_47360542的博客
09-02 145
Java的反射与注解
Java选择题日常记录——Day16—Day30
Terio的博客
03-24 5604
Java选择题刷题记录Day16Q1题解Q2题解Q3题解Q4题解 Day16 Q1 下面有关 JAVA 异常类的描述,说法正确的有() 异常的继承结构:基类为 Throwable,Error 和 Exception 。实现 Throwable, RuntimeException 和 IOException 等继承 Exception 非 RuntimeException 一般是外部错误(不考虑Error的情况下),其可以在当前类被 try{}catch 语句块所捕获 Error 类体系描述了 Java 运
【Java】反射机制介绍与Class类的基本使用
Hello, New World!
03-19 408
Java反射机制与Class类1.Java反射机制1.1 Java的反射机制是什么1.2 Java的反射的应用场合1.3 Java反射的常用类1.4 反射使用步骤2. Class类2.1 常用方法和示例2.2 获取Class对象的3种方法2.3 反射创建对象的2种方法3. 工厂设计模式 1.Java反射机制 1.1 Java的反射机制是什么 在运行状态中，对于任意一个类都能够知道这个类所有的属性和...
工厂模式的介绍及实现
户伟伟的博客
09-25 153
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 543
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
最新发布
Lxn2zh的博客
09-30 418
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
JPA+Thymeleaf增删改查
y050505的博客
09-25 502
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 975
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java MBeanInstantiator 0day 漏洞分析
这个漏洞利用了Java的反射机制，这是一种允许程序在运行时动态访问和修改类的方法和属性的能力。攻击者通过构造恶意的MBean类名，触发了递归反射，这可能导致无限循环或者堆栈溢出，从而执行不受限制的代码。 利用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值