反射出类中的字段,构造函数,方法(私有的,静态的l诶)

最新推荐文章于 2022-05-04 22:43:59 发布
最新推荐文章于 2022-05-04 22:43:59 发布
阅读量677 收藏
点赞数
分类专栏： 深入理解JVM 文章标签： Class 反射 字段 方法 构造函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allenfancy/article/details/41980941
版权

反射技术：DEMO

实体类：

import java.io.InputStream;
import java.util.List;
import java.util.Map;

/**
 * 
 * @author allen
 *
 */
public class Person {

	/**
	 * 字段
	 */
	private String test1 = "allen";
	public static String test2 = "static";
	public String names = "fancy";
	public int test3 ;
	public double test4;
	public float test5;
	/**
	 * 构造函数
	 */
	public Person(){
		System.out.println("无参构造函数");
	}
	public Person(int test3){
		this.test3 = test3;
		System.out.println("有一个参数的构造函数");
	}
	public Person(double test4,String names){
		this.test4 = test4;
		this.names = names;
		System.out.println("有俩个参数的构造函数");
	}
	
	public  Person(List list){
		System.out.println("List");
	}
	
	private  Person(Map map){
		System.out.println("private  Map");
	}
	
	/**
	 * 方法
	 */
	public void getNoParamMethod(){
		System.out.println("无参数传递进来");
	}
	
	public void getNoneParamMethod(String name){
		System.out.println("参数传递进来"+name);
	}
	
	public Class[] getParamMethod(String name,int[] arr){
		return new Class[]{String.class,int[].class};
	}
	
	private void getInputStream(InputStream inputStream){
		System.out.println("private inputStream :"+inputStream);
	}
	
	public static void getStaticMethod(int number){
		System.out.println("static method:"+number);
	}
}

反射出构造函数:

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

/**
 * 
 * @author allen
 *
 */
public class TestClazzConstrutor {

	/**
	 * 反射出无参数的构造函数public Person()
	 */
	@Test
	public void testNoParamConstructor(){
		Class clazz = Person.class;
		try {
			Constructor constructor = clazz.getConstructor(null);
			Person person = (Person) constructor.newInstance(null);
			System.out.println(person);
		} 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 (InstantiationException 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();
		}
	}
	
	/**
	 * 反射出public Person(int test3)
	 */
	@Test
	public void testNoneParamConstructor(){
		Class clazz = Person.class;
		try {
			Constructor constructor = clazz.getConstructor(int.class);
			Person person = (Person) constructor.newInstance(12);
			System.out.println(person.test3);
		} 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 (InstantiationException 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();
		}
	}
	/**
	 * public Person(double test4,String names)
	 */
	@Test
	public void testTwoParamConstructor(){
		Class clazz = Person.class;
		try {
			Constructor constructor = clazz.getConstructor(double.class,String.class);
			Person person = (Person) constructor.newInstance(12,"allen");
			System.out.println(person.test4+person.names);
		} 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 (InstantiationException 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();
		}
	}
	/**
	 * public  Person(List list)
	 */
	@Test
	public void testListParamConstructor(){
		Class clazz = Person.class;
		try {
			Constructor constructor = clazz.getConstructor(List.class);
			Person person = (Person) constructor.newInstance(new ArrayList());
		} 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 (InstantiationException 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();
		}
	}
	
	/**
	 * private  Person(Map map)
	 */
	@Test
	public void testPrivateMapParamConstructor(){
		Class clazz = Person.class;
		try {
			Constructor constructor = clazz.getDeclaredConstructor(Map.class);
			//对私有的构造函数 
			constructor.setAccessible(true);
			Person person = (Person) constructor.newInstance(new HashMap());
		} 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 (InstantiationException 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();
		}
	}
}

反射出方法： 

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.junit.Test;

/**
 * 
 * @author allen
 *
 */
public class TestClazzMethod {

	/**
	 * public void getNoParamMethod()
	 */
	@Test
	public void testNoParamMethod(){
		Class clazz = Person.class;
		Person p = new Person();
		try {
			Method method = clazz.getDeclaredMethod("getNoParamMethod",null);
			method.invoke(p, null);
		} 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();
		}
	}
	@Test
	public void testgetNoneParamMethod(){
		Class clazz = Person.class;
		Person p = new Person();
		try {
			Method method = clazz.getDeclaredMethod("getNoneParamMethod",String.class);
			method.invoke(p, "allen");
		} 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();
		}
	}
	
	/**
	 * public Class[] getParamMethod(String name,int[] arr)
	 */
	@Test
	public void testgetParamMethod(){
		Class clazz = Person.class;
		Person p = new Person();
		try {
			Method method = clazz.getDeclaredMethod("getParamMethod",String.class,int[].class);
			Class[] clazz1 =  (Class[] )method.invoke(p, "allen",new int[]{1,2,3});
			System.out.println(clazz1.length);
		} 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();
		}
	}
	
	@Test
	public void testgetInputStream() throws Exception{
		Class clazz = Person.class;
		Person p = new Person();
		try {
			Method method = clazz.getDeclaredMethod("getInputStream",InputStream.class);
			//私有方法，反射获取
			method.setAccessible(true);
			method.invoke(p,new FileInputStream(new File("D://redis.txt")));
		} 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();
		}
	}
	
	/**
	 * 
	 */
	@Test
	public void testgetStaticMethod(){
		Class clazz = Person.class;
		Person p = new Person();
		try {
			Method method = clazz.getDeclaredMethod("getStaticMethod",int.class);
			method.invoke(p,12);
		} 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();
		}
	}
}
反射出字段： 

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

import org.junit.Test;

/**
 * 
 * @author allen
 *
 */
public class TestClazzField {

	/**
	 * public
	 * @throws Exception
	 */
	@Test
	public void testField() throws Exception{
		Class clazz = Person.class;
		Person p = new Person();
		try {
			Field f = clazz.getField("names");
			Class type=f.getType();
			if(type.equals(String.class)){
				String names = (String)f.get(p);
				System.out.println(names);
				//设置值
				f.set(p, "xxxxxxxx");
				System.out.println(f.get(p));
			}
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
	/**
	 * private
	 * @throws Exception
	 */
	@Test
	public void testPrivateField() throws Exception{
		Class clazz = Person.class;
		Person p = new Person();
		try {
			Field f = clazz.getDeclaredField("test1");
			f.setAccessible(true);
			Class type=f.getType();
			if(type.equals(String.class)){
				String names = (String)f.get(p);
				System.out.println(names);
				//设置值
				f.set(p, "xxxxxxxx");
				System.out.println(f.get(p));
			}
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * static
	 * @throws Exception
	 */
	@Test
	public void testStaticField() throws Exception{
		Class clazz = Person.class;
		Person p = new Person();
		try {
			Field f = clazz.getDeclaredField("test2");
			f.setAccessible(true);
			Class type=f.getType();
			if(type.equals(String.class)){
				String names = (String)f.get(p);
				System.out.println(names);
				//设置值
				f.set(p, "xxxxxxxx");
				System.out.println(f.get(p));
			}
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}



wt598717394
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习C#静态函数及变量的一个精典例子与代码
01-20
 （5）如果类中包含用来开始执行的 Main 方法，则该类的静态构造函数将在调用 Main 方法之前执行。任何带有初始值设定项的静态字段，则在执行该类的静态构造函数时，先要按照文本顺序执行那些初始值设定项。 
Java反射获取私有构造函数、属性、方法
开发笔记
10-13 444
我一直以为类的私有构造函数、属性、方法除了类自身其他类是无法访问的，前几天正好学习Spring框架，在学习Spring框架基础 Bean包时，写了一个简单的例子，类似如下： 　　package study.spring.bean; 　　public class SimpleBean 　　{ 　　private String beanName; 　　private S...
C#---第八课：类中的字段、方法及属性、静态类与非静态类的区别、构造函数、析构函数
Alien-Hu
05-04 2678
文章目录1.字段 & 属性的区别2.类的最基本结构3.类中属性的设置 1.字段 & 属性的区别 字段：一个类中可以有多个字段，例如Person类中，可以有姓名、年龄、性别等字段。用这些字段来区分Person的不同。 属性：一个字段，可以设置一个属性。这个属性又有两个方法get、set方法。分别控制字段获取时候的取值规则与字段赋值时候的规则。 【 字段与属性的区别：】 1.字段一般可以理解为是私有的，只有类本身能调用。实例化的对象是不能调用的。 2.字段代表的是类的最根本的性质
C#中的构造函数，私有构造函数，静态构造函数以及构造函数的执行顺序
weixin_36504157的博客
08-21 1995
1.默认构造函数：如果类中没有定义构造函数那么程序会默认的为类创建一个无参数构造函数用以对类进行实例化，如果有构造函数的话，那么程序就不会创建默认构造函数 2静态构造函数，不能访问实例成员，只能用来初始化一些静态字段或者属性，仅在第一次调用类的任何成员时自动执行，不带访问修饰符，不带任何参数，每个类只能有一个静态构造函数，但可以同时还有一个无参实例构造函数， 3.私有构造函数：把访问的属性设置...
C# 类的成员——字段、方法、构造函数和属性
追求。
04-17 3174
本博文为半摘记性质，收集整理自菜鸟教程、微软C#文档及其他互联网资料 —— 类的成员：主讲字段、方法和属性 字段又称为“成员变量”，一般用在一个类内部做数据交互使用，通常使用private修饰； 方法是把一些相关的语句组织在一起，用来执行一个任务的语句块； 类的 构造函数 是类的一个特殊的成员函数，是一种特殊的方法，主要用来在创建对象时初始化对象； 属性属于高级概念，在OOP（面向对象）中，主要使用属性来描述对象的静态特征。
浅学C#（12）——实例构造函数、静态构造函数、析构函数
衡与墨的博客
01-23 1506
实例构造函数 [构造函数修饰符] 标识符（[参数列表] ) [ : base ( [参数列表] ) ] [ : this ( [参数列表] ) ] { 构造函数语句块 } 构造函数修饰符有public、protected、internal、private 构造函数可以重载 :base表示调用直接基类中的实例构造函数 :this调用该类本身所声明的其他构造函数 构造函数语句块既...
C#静态static的用法实例分析
12-26
其次，它防止在类的内部声明任何实例字段或方法。 静态类的主要特性： 1：仅包含静态成员。 2：无法实例化。 3：静态类的本质，是一个抽象的密封类，所以不能被继承，也不能被实例化。 4：不能包含实例构造函数。 5...
proposal-static-class-features:新类功能的静态部分，在单独的提案中
04-29
创建该建议是为了跟踪和建议（即静态公共字段，静态私有字段和静态私有方法）的“静态”（即，构造函数的）方面。 在2017年11月的TC39会议上，这些提案的静态维度降级为第2阶段，在实例维度保留在第3阶段时分解为一...
ClassicJS:添加对ES6类的完全私有和受保护的支持，而不会阻止代理
05-12
经典构造函数上的私有静态成员和受保护的静态成员。 静态构造函数。 原型可修改的字段初始化。 抽象和最终课程。 支持HTML自定义元素。 可定位的super访问器。 实例上的构造方法参考。如何使用您可以使用2种不同的...
C# 使用方法 入门教程
03-01
4.2.6 派生类的构造函数..... 104 4.3 修饰符...... 109 4.3.1 可见性修饰符..... 109 4.3.2 其他修饰符..... 110 4.4 接口...... 111 4.4.1 定义和实现接口..... 112 4.4.2 派生的接口..... 116 4.5 小结...... 118...
JVM调优总结(参考深入理解Java虚拟机书籍)
JAVA浩如烟海
10-10 3612
1.堆大小设置： 最大的堆大小限制：操作系统的数据，虚拟机内存限制，物理内存限制 典型设置：-Xmx3550m -Xms3550m -Xmn2g -Xss128K -Xmx3550m ：设置JVM最大可用的内存3550M -Xms3550M ：设置JVM促使内存3550m。此值可以设置与-Xmx相同，以避免垃圾回收完成后JVM重新分配内存。 -Xmn2g  ：设置年轻代大小为2G。整
JAVA内存区域与内存溢出异常
JAVA浩如烟海
12-16 589
1.运行时数据区： 程序计数器：     作用：可以看做是当前线程所执行的字节码的行号指示器。字节码工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支，循环，跳转，异常处理，线程恢复等基础的功能都需要依赖这个计数器来完成  JAVA虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器（对于多核
Eclipse启动时;的调优处理
JAVA浩如烟海
12-16 544
Eclipse开发的时候，有时候会出现oom(out of memory)问题 -Xms256M -Xmx256M -XX:PermSize=256M -XX:MaxPermSize=256M /***  * 关于对Eclipse启动时;的调优处理：eclipse.ini文件  * 原版：  * -vm  * D:/_devSpace/jdk1.
JVM（四）
JAVA浩如烟海
12-17 456
对象的访问定位： 建立对象是为了能够是使用对象；通过栈上的reference数据来操作堆上的具体的对象。然而Reference类型在虚拟机的规范只是指定了一个对象的引用，具体如何去访问，就的需要取决于虚拟机。主要的俩中方式：句柄和直接指针俩种。 句柄式访问：JAVA堆中会划分出一个句柄池，Reference存储的是句柄地址。句柄中包含了对象实例数据与类型数据各自的具体的地址信息。    好处
JVM（三）
JAVA浩如烟海
12-16 438
1.对象已死？     引用计数算法（Reference counting）：     根搜索算法（GC Roots Tracing）：判断对象是否存活的。基本思路：通过一系列的名为“GC ROOTS”的对象作为起始点，从这些点开始乡下搜索，搜索所走过的路径成为引用链（Reference Chain），当一个对象到GC Roots没任何引用链项链（用图论解释：G
springboot(酒店管理系统)
04-25
开发语言：Java JDK版本：JDK1.8（或11） 服务器：tomcat 数据库：mysql 5.6/5.7（或8.0） 数据库工具：Navicat 开发软件：idea 依赖管理包：Maven 代码+数据库保证完整可用，可提供远程调试并指导运行服务（额外付费）～ 如果对系统的中的某些部分感到不合适可提供修改服务，比如题目、界面、功能等等... 声明： 1.项目已经调试过，完美运行 2.需要远程帮忙部署项目，需要额外付费 3.本项目有演示视频，如果需要观看，请联系我 4.调试过程中可帮忙安装IDEA，eclipse，MySQL，JDK，Tomcat等软件 重点： 需要其他Java源码联系我，更多源码任你选，你想要的源码我都有！ 需要加v19306446185
BP神经网络matlab实例.doc
最新发布
04-25
数学模型算法
设计.zip
04-25
设计.zip
java 私有构造函数
07-27
2. 工具类：某些类只包含静态方法和静态字段，无需创建对象，因此可以将构造函数声明为私有，防止误创建对象。 3. 防止继承：如果一个类不希望被继承，可以将其构造函数声明为私有。 下面是一个私有构造函数的示例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值