- 浏览: 253629 次
- 性别:
- 来自: 厦门
文章分类
最新评论
-
shootboss:
可以,mark学习
Freemarker页面语法 -
java_cache:
好东西,果断收藏!
Freemarker页面语法 -
fireinjava:
${.global.x}改为${.globals.x} :) ...
Freemarker页面语法 -
贾志新:
good
Freemarker页面语法 -
贾志新:
sasasa
Freemarker页面语法
Java 的这一能力在实际应用中也许用得不是很多,但是在其它的程序设计语言中根本就不存在这一特性。例如,Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。
JavaBean 是 reflection 的实际应用之一,它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。
反射除了显示类的自身信息外,它还可以创建对象和执行方法等
(1)找出类的方法
找出一个类中定义了些什么方法,这是一个非常有价值也非常基础的 reflection 用法,示例代码如下:
- 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("---------");
- }
- }
- }
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("---------"); } } }
(2) 获取构造器信息
获取类构造器的用法与上述获取方法的用法类似,示例代码如下:
- 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("-----------");
- }
- }
- }
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("-----------"); } } }
(3) 获取类的字段(域)
找出一个类中定义了哪些数据字段也是可能的,下面的代码就在干这个事情:
- 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)+"循环---");
- }
- }
- }
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) 根据方法的名称来执行方法
我们也可以用 reflection 来做一些其它的事情,比如执行一个指定了名称的方法。下面的示例演示了这一操作:
- 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());
- }
- }
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()); } }
(5) 创建新的对象
对于构造器,则不能像执行方法那样进行,因为执行一个构造器就意味着创建了一个新的对象 (准确的说,创建一个对象的过程包括分配内存和构造对象)。所以,与上例最相似的例子如下:
- 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);
- }
- }
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); } }
(6) 改变字段(域)的值
reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它,下面的例子可以说明这一点:
- reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它,下面的例子可以说明这一点:
- 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);
- }
- }
reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它,下面的例子可以说明这一点: 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); } }
(7)使用数组
reflection 的最后一种用法是创建的操作数组。数组在 Java 语言中是一种特殊的类类型,一个数组的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的:
- 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);
- }
- }
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); } }
看下更复杂的情况:
- 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]);
- }
- }
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]); } }
OK,掌握以上几点Java的反射差不多就会使用了!
发表评论
-
Java文件路径(getResource)
2014-01-07 11:30 1033Class.getResource("" ... -
java随记
2013-04-27 14:41 951ThreadLocal是为解决多线程程序的并发问题而提出的 ... -
JAVA内存使用--如何计算一个Java对象占用的字节数
2013-02-02 22:45 1995转载:http://blog.csdn.net ... -
一些得到classpath和当前类的绝对路径的方法
2013-02-01 14:54 1362一些得到classpath和当前类的绝对路径的一些方 ... -
位操作的学习总结
2012-10-09 10:18 1228^ 异或 相同为0,相异为1 & 与 ... -
深入研究java.lang.Class类
2012-08-15 11:35 2055http://winsystem.ctocio.com ... -
Jetty嵌入式开发提供WEB服务
2012-07-03 14:27 2369在Java开发的Project项目 ... -
深入Tomcat:JNDI在TOMCAT中的应用
2011-11-19 17:20 2145JNDI在TOMCAT中的应用 在J2EE应用中, ... -
使用commons-fileupload实现单个和多个文件上传
2011-06-17 17:42 4279原文>> 对于实现文件上传功能来说,Com ... -
java文件下载时文件名在ie和firefox下面表现不一致问题
2010-12-29 15:52 2218首先文件名是是以utf-8编码保存在数据库中,文件名暂定为&q ... -
java定时器的使用(Timer
2010-05-19 10:11 1594转载:http://www.cnblogs.com/wyqto ... -
Java中四种XML解析技术
2009-04-14 14:10 915原文出自:XXXX(忘记了 ...
相关推荐
Java 反射学习 Java 反射是 Java 程序设计语言的特征之一,它允许运行中的 Java 程序对自身进行检查,或者说 "自审 ",并能直接操作程序的内部属性。Java 反射的能力在实际应用中非常有价值,例如,使用它能获得 ...
在“JAVA反射学习”这个主题中,我们将深入探讨以下几个关键知识点: 1. **什么是反射**:反射是Java提供的一种能力,通过Class对象来获取关于类的所有信息,并能在运行时创建和访问对象,调用方法,甚至修改私有...
### Java反射机制详解 在Java领域,反射(Reflection)是一个强大的功能,允许程序在运行时检查和修改其结构和行为。这种能力对于框架设计、动态代理、类库扩展等场景至关重要。下面,我们将深入探讨Java反射的核心...
Java反射机制是Java编程语言中的一个强大特性,它允许程序在运行时检查和操作类、接口、对象等的内部信息。这一机制对于理解和实现高级框架、动态代理、元数据处理等场景至关重要。以下是对Java反射机制的详细说明:...
这篇博文"Java反射机制学习(二)"可能深入探讨了如何利用反射进行动态类型处理、访问私有成员以及创建对象等核心概念。在这里,我们将详细讨论Java反射的基本用法及其在实际开发中的应用。 1. **什么是反射**: ...
这是一个小型的JAVA反射学习教程,权威啊 学习它可以让你更轻松处理复杂问题
总的来说,"JAVA反射机制的入门代码"是初学者理解Java反射机制的好教材,通过它,你可以学习如何动态地操作Java类,提高代码的灵活性,并掌握处理`properties`文件的基础方法。在深入学习和实践中,你将进一步理解...
Java反射机制是Java编程语言中的一项核心特性,它允许程序在运行时动态地获取类的信息并进行操作。这使得Java能够在编译后仍然能够灵活地处理类和对象,增强了代码的动态性。在Android应用开发中,反射机制尤其重要...
通过本文的学习,我们深入了解了Java反射机制的基本概念、原理以及应用。Java反射机制为Java程序提供了一种强大的动态处理能力,使得Java不仅仅局限于静态类型语言的功能限制。掌握Java反射机制对于开发者来说是非常...
Java反射是Java编程语言中的一个强大特性,它允许运行时的程序访问并操作类、接口、字段和方法等信息,即使这些信息在编译时并未明确知晓。...学习和熟练掌握Java反射,能够显著提升编程的灵活性和解决问题的能力。
本笔记主要涵盖了四个核心知识点:Java反射机制、流(I/O流)、内存管理和Java学习的基础。以下是对这些主题的详细阐述: 一、Java反射机制 Java反射机制是Java语言的一个强大特性,允许程序在运行时检查类、接口、...
Java反射机制是Java编程语言中一个强大的工具,它允许程序在运行时动态地获取类的信息并操作类的对象。反射机制的核心在于java.lang.reflect包中的API,主要包括Class类、Constructor类、Method类和Field类。以下是...
### Java反射机制详解 #### 一、概述 ...通过以上介绍,我们不仅深入了解了Java反射的基本概念和应用场景,还学习了如何利用反射来处理各种类型的数据结构。这对于深入理解和应用Java语言具有重要意义。
对于学习Java反射,阅读和理解相关的源代码是非常有益的。你可以从Java标准库的`java.lang.reflect`包开始,研究Class、Constructor、Method和Field类的实现。通过阅读源码,可以更深入地理解反射的工作原理,提升...
在"北大青鸟java反射机制"的学习资料中,我们将会深入探讨这一核心特性。 首先,我们要理解反射的核心概念:在程序运行时,通过Class对象获取类的信息,包括类名、属性、方法等,并能够动态地创建对象和调用方法。...
Java反射是Java编程语言中的一个强大特性,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中,反射机制的核心类是`java.lang.Class`,它代表了类的信息。当我们需要在运行时动态地...
java注解和反射的个人学习笔记
Java反射是Java编程语言中的一个强大特性,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中,反射机制主要用到了java.lang.Class、java.lang.reflect.Method、java.lang.reflect....
Java反射是Java编程语言中的一个重要特性,它允许程序在运行时动态地获取类的信息并进行操作,如创建对象、调用方法、访问属性等。在本文中,我们将深入理解Java反射的概念,掌握其核心实现,并探讨它在实际开发中的...
Java反射和动态代理是Java编程中的重要特性,它们在实现高度灵活...在提供的压缩包文件"JavaReflect"中,可能包含了关于Java反射和动态代理的示例代码和教程,通过学习和实践这些内容,你可以更深入地掌握这两种技术。