1、获取指定类的构造器相关信息
Java代码
import java.lang.reflect.*;
import java.io.IOException;
/**
*获取指定类的构造器相关信息
*/
public class ConstructorTest
{
private int i;
private double j;
//默认的构造器
public ConstructorTest(){
}
//重载的构造器
public ConstructorTest(int i,double j)throws IOException{
this.i=i;
this.j=j;
}
public static void main(String[] args) throws Exception
{
//得到本类的类对象
Class cls=Class.forName("ConstructorTest");
//取得所有在本类声明的构造器
Constructor []cs=cls.getDeclaredConstructors();
//遍历
for(Constructor c:cs){
//构造器名称
System.out.println("构造器名="+c.getName());
//构造器声明所在的类
System.out.println("其声明的类="+c.getDeclaringClass());
//取得参数的类型集合
Class []ps=c.getParameterTypes();
//遍历参数类型
for(int i=0;i<ps.length;i++){
System.out.println("参数类型"+i+"="+ps[i]);
}
//取得异常的类型集合
Class []es=c.getExceptionTypes();
//遍历异常类型
for(int j=0;j<es.length;j++){
System.out.println("异常类型"+j+"="+es[j]);
}
//结束一层循环标志
System.out.println("-----------");
}
}
}
2、通过反射创新类的新对象
Java代码
import java.lang.reflect.*;
/**
*通过反射创新类的新对象
*/
class CreateNewObj
{
//显式默认的构造器
public CreateNewObj(){
}
//重载构造器
public CreateNewObj(int a,int b){
System.out.println("a= "+a+" b="+b);
}
public static void main(String[] args) throws Exception
{
//得到本类的类对象
Class c=Class.forName("CreateNewObj");
//声明构造器的参数类型集合
Class []paramTypes=new Class[2];
//都为int型
paramTypes[0]=Integer.TYPE;
paramTypes[1]=Integer.TYPE;
//根据参数类型决定得到哪个构造器
Constructor cs=c.getConstructor(paramTypes);
//声明要传入的参数集合
Object []argList=new Object[2];
//传入37和43
argList[0]=new Integer(37);
argList[1]=new Integer(43);
//根据符合上述参数类型的构造器来创建新的对象
Object rtnObj=cs.newInstance(argList);
}
}
3、获取指定类的字段相关信息
Java代码
import java.lang.reflect.*;
/**
*获取指定类的字段相关信息
*/
class FieldTest
{
//字段1
private double d;
//字段2
public static final int i=37;
//字段3
String str="fieldstest";
public static void main(String[] args) throws Exception
{
//获取本类的类对象
Class c=Class.forName("FieldTest");
//获取所有声明的的字段,getFields()包括继承来的字段
Field []fs=c.getDeclaredFields();
//遍历
for(int i=0;i<fs.length;i++){
Field f=fs[i];
//字段名
System.out.println("字段名"+(i+1)+"="+f.getName());
//字段声明所在的类
System.out.println("该字段所在的类为："+f.getDeclaringClass());
//字段的类型
System.out.println("字段"+(i+1)+"的类型："+f.getType());
//查看修饰符
int mod=f.getModifiers();
//为0就是默认的包类型
if(mod==0){
System.out.println("该字段的修饰符为：默认包修饰符");
}else{
//否则就是相应的类型
System.out.println("该字段的修饰符为："+Modifier.toString(mod));
}
System.out.println("---结束第"+(i+1)+"循环---");
}
}
}
4、获取指定类的方法相关信息
Java代码
import java.lang.reflect.*;
/**
*获取指定类的方法相关信息
*/
class InformationTest
{
public static void main(String[] args) throws Exception
{
//得到String类对象
Class cls=Class.forName("java.lang.String");
//得到所有的方法，包括从父类继承过来的方法
Method []methList=cls.getMethods();
//下面是得到的是String类本身声明的方法
//Method []methList=cls.getDeclaredMethods();
//遍历所有的方法
for(Method m:methList){
//方法名
System.out.println("方法名="+m.getName());
//方法声明所在的类
System.out.println("声明的类="+m.getDeclaringClass());
//获取所有参数类型的集体
Class []paramTypes=m.getParameterTypes();
//遍历参数类型
for(int i=0;i<paramTypes.length;i++){
System.out.println("参数 "+i+" = "+paramTypes[i]);
}
//获取所有异常的类型
Class []excepTypes=m.getExceptionTypes();
//遍历异常类型
for(int j=0;j<excepTypes.length;j++){
System.out.println("异常 "+j+" = "+excepTypes[j]);
}
//方法的返回类型
System.out.println("返回类型 ="+m.getReturnType());
//结束一层循环标志
System.out.println("---------");
}
}
}
5、通过反射改变字段的值
Java代码
import java.lang.reflect.*;
/**
*通过反射改变字段的值
*/
class ModifyField
{
//声明一个字段
public double d;
public static void main(String[] args) throws Exception
{
//得到类的类对象
Class c=Class.forName("ModifyField");
//根据字段名得到字段对象
Field f=c.getField("d");
//创建类的实例
ModifyField mf=new ModifyField();
//打印修改前字段的值
System.out.println("修改 "+f.getName()+" 前的值为："+mf.d);
//修改d的值为12.34
f.setDouble(mf,12.34);
//打印修改后的值
System.out.println("修改 "+f.getName()+" 后的值为："+mf.d);
}
}
6、通过反射执行类的方法
Java代码
import java.lang.reflect.*;
/**
*通过反射执行类的方法
*/
class PerformMethod
{
//声明一个简单的方法，用于测试
public int add(int a,int b){
return a+b;
}
public static void main(String[] args)throws Exception
{
//获取本类的类对象
Class c=Class.forName("PerformMethod");
/**
*声明add方法参数类型的集合
*共有两个参数，都为Integer.TYPE
*/
Class []paramTypes=new Class[2];
paramTypes[0]=Integer.TYPE;
paramTypes[1]=Integer.TYPE;
//根据方法名和参数类型集合得到方法
Method method=c.getMethod("add",paramTypes);
//声明类的实例
PerformMethod pm=new PerformMethod();
//传入参数的集合
Object []argList=new Object[2];
//传入37和43
argList[0]=new Integer(37);
argList[1]=new Integer(43);
//执行后的返回值
Object returnObj=method.invoke(pm,argList);
//类型转换下
Integer returnVal=(Integer)returnObj;
//打印结果
System.out.println("方法执行结果为："+returnVal.intValue());
}
}
7、通过反射来操作数组
Java代码
import java.lang.reflect.*;
/**
*通过反射来操作数组
*/
class UserArray
{
public static void main(String[] args) throws Exception
{
//得到String类的类对象
Class c=Class.forName("java.lang.String");
//通过Array类的反射创建一个含有10个元素的String类型的数组
Object arr=Array.newInstance(c,10);
//为数组第5个位置元素赋一个值
Array.set(arr,5,"第5个位置元素");
//取得第5个位置元素的值
String s=(String)Array.get(arr,5);
//打印这个元素的值
System.out.println("值为："+s);
}
}
8、通过反射创建和使用更复杂的数组
Java代码
import java.lang.reflect.*;
/**
*通过反射创建和使用更复杂的数组
*/
class UserArrayComplex
{
public static void main(String[] args) throws Exception
{
//声明数组的维数为5X10X15
int dims[]=new int []{5,10,15};
//创建该类型的数组，元素的类型为Integer
Object arr=Array.newInstance(Integer.TYPE,dims);
//得到第3个10X15的二维数组
Object arrObj=Array.get(arr,3);
//Class c=arrObj.getClass().getComponentType();
//System.out.println(c);
//得到第2维中的第2个15位长度的数组
arrObj=Array.get(arrObj,5);
//然后设置该数组里第10个元素的值为37
Array.set(arrObj,10,37);
//再将数组还原
int [][][]arrCast=(int [][][])arr;
//打印刚刚那个值
System.out.println(arrCast[3][5][10]);
}
}
转自http://www.iteye.com/topic/1114312
分享到：
相关推荐
在讨论C++反射机制实现的过程中，我们首先需要明确反射机制的概念和分类。反射的定义源自人工智能领域，它主要涉及到两种反射结构：结构反射和计算反射。结构反射侧重于元类与类之间的关系，计算反射则关注于计算...
### Java中的反射机制 #### 一、反射的概念 反射的概念最早由Smith于1982年提出，是指程序能够访问、检测和修改其自身状态或行为的能力。这一概念的引入促进了计算机科学领域对反射性的研究，并迅速被应用于程序...
Java反射机制深入研究，什么是Java的反射，Java反射的原理是什么
通过本文的研究可以看出，Java的反射机制为数据持久层提供了一种灵活的操作方式。结合Java Bean技术，可以有效地减少代码量，提高开发效率。当然，反射机制在提升灵活性的同时，也会带来一些性能损耗，因此在实际...
### Java反射机制详解 #### 一、反射的基本概念与历史背景 反射的概念最早由Smith在1982年提出，其核心思想是程序有能力访问、检测甚至修改自身的状态和行为。这种能力一经提出，迅速成为了计算机科学领域的研究...
### Java反射机制的研究 #### 反射机制简介 Java反射机制是Java语言提供的一种能够使程序在运行时访问自身信息并进行操作的功能。通过反射，Java程序可以动态地获取类的信息（如方法、属性等）并对其进行操作。...
### Java反射机制总结 #### 反射的概念与起源 反射的概念最早由Smith于1982年提出，指的是程序能够访问、检测并修改其自身状态或行为的能力。这一概念的提出迅速引起了计算机科学领域的广泛关注，并在之后的研究中...
在编程领域，反射机制是一种强大的工具，特别是在C#这样的面向对象编程语言中。它允许程序在运行时检查自身，获取类型信息，创建对象，以及调用方法和访问字段，这为程序员提供了高度的灵活性和动态性。下面我们将...
Android平台与Web服务数据交互时运用Java反射机制解析数据的研究 本文研究了Android平台与Web服务数据交互时运用Java反射机制解析数据的技术。Java反射机制是一种在运行状态中动态获取类的信息以及动态调用对象方法...
【反射机制】是Java编程语言中的一个重要特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在本案例中，"简单实现...通过这些文件，我们可以进一步研究和学习如何使用反射机制来实现ORM。
本研究提出了一种改进型的Excel文件读写操作方法，该方法通过Java注解和反射机制，实现了业务逻辑与文件操作的分离，使得应用程序能够更灵活地处理Excel文件数据。 4. 松耦合编程思想：在软件工程中，松耦合是一种...
详细说明了反射机制RMRSA的元级体系结构模型和基级体系结构模型，描述了元级软件体系结构和基级软件体系结构之间进行交互和互操作的协议PMB，以及反射机制RMRSA支持软件体系结构重用的过程。利用所提出的基于反射...
Java反射机制是Java编程语言中的一个强大特性，它允许程序在运行时检查和操作类、接口、对象等的内部信息。这一机制对于理解和实现高级框架、动态代理、元数据处理等场景至关重要。以下是对Java反射机制的详细说明：...
"基于反射机制的数据流Java多态性实现及研究" 本文主要介绍了基于反射机制的数据流Java多态性实现及研究。数据流Java是一种并行程序设计模型，它也具有面向对象程序多态的概念，反射机制允许程序运行时动态地加载一...
### JAVA反射机制详解 #### 一、JAVA反射机制概述 **反射**是在1982年由Smith首次提出的概念，指的是程序有能力访问、检测并修改其自身的状态或行为。这一概念一经提出，便迅速引起了计算机科学领域的关注，并在多...
《Android动态加载与反射机制的静态污点分析研究》 在当前的Android安全领域，隐私泄露是一个至关重要的问题。其中，污点分析是检测隐私泄露的主要手段。静态污点分析因其高代码覆盖率和低假阴性率而在Android隐私...
Java注解和反射机制是Java开发中的重要工具，它们极大地增强了代码的可读性和灵活性。在结合JDBC（Java Database Connectivity）API时，可以构建出更高效、更易维护的数据访问层。本案例通过注解的方式，简化了JDBC...
### Java中的类反射机制 #### 一、反射的概念与历史 反射的概念最早由Smith于1982年提出，指的是程序有能力访问、检测并修改其自身的状态或行为。这一概念一经提出，便迅速引起了计算机科学领域的关注，并在多个...
【标题】：“C++坦克大战游戏与反射机制实现” 在这个项目中，我们主要探讨的是C++编程语言在创建游戏——坦克大战中的应用，以及如何利用C++的反射机制来增加程序的灵活性。C++是一种静态类型、编译式的、通用的、...