精编范文reflection范例范文模板 23页.docx
《精编范文reflection范例范文模板 23页.docx》由会员分享，可在线阅读，更多相关《精编范文reflection范例范文模板 23页.docx（22页珍藏版）》请在冰点文库上搜索。
精编范文reflection范例范文模板23页
本文部分内容来自网络整理，本司不为其真实性负责，如有异议或侵权请及时联系，本司将立即删除！
==本文为word格式，下载后可方便编辑和修改！
==
reflection范例
篇一：
Java反射机制reflection完整例子详细解释工程实践
Java反射机制reflection完整例子详细解释工程实践
一、什么是反射机制
简单的来说，反射机制指的是程序在运行时能够获取自身的信息。
在java中，只要给定类的名字，
那么就可以通过反射机制来获得类的所有信息。
二、哪里用到反射机制
有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码，
Class.forName（"com.mysql.jdbc.Driver.class"）.newInstance（）;但是那时候只知道那行代码是生成
驱动对象实例，并不知道它的具体含义。
听了反射机制这节课后，才知道，原来这就是反射，现在很多开
框架都用到反射机制，hibernate、struts都是用反射机制实现的。
三、反射机制的优点与缺点
为什么要用反射机制？
直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，
静态编译：
在编译时确定类型，绑定对象,即通过。
动态编译：
运行时确定类型，绑定对象。
动态编译最大限度发挥了java的灵活性，体现了多
态的应用，有以降低类之间的藕合性。
一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中
它的灵活性就表现的十分明显。
比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编
译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如
这样的话，这个软件肯定是没有多少人用的。
采用静态的话，需要把整个程序重新编译一次才可以实现功能
的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功
能。
它的缺点是对性能有影响。
使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它
满足我们的要求。
这类操作总是慢于只直接执行相同的操作。
四、利用反射机制能获得什么信息
一句话，类中有什么信息，它就可以获得什么信息，不过前提是得知道类的名字，要不就没有后文了
首先得根据传入的类的全名来创建Class对象。
Classc=Class.forName（"className"）;注明：
className必须为全名，也就是得包含包名，比如，java.pojo.UserInfo;
Objectobj=c.newInstance（）;//创建对象的实例
OK，有了对象就什么都好办了，想要什么信息就有什么信息了。
获得构造函数的方法
ConstructorgetConstructor（Class[]params）//根据指定参数获得public构造器
Constructor[]getConstructors（）//获得public的所有构造器
ConstructorgetDeclaredConstructor（Class[]params）//根据指定参数获得public和非public的构造器
Constructor[]getDeclaredConstructors（）//获得public的所有构造器
获得类方法的方法
MethodgetMethod（Stringname,Class[]params）,根据方法名，参数类型获得方法
Method[]getMethods（）//获得所有的public方法
MethodgetDeclaredMethod（Stringname,Class[]params）//根据方法名和参数类型，获得public和非public的方法
Method[]getDeclaredMethods（）//获得所以的public和非public方法
获得类中属性的方法
FieldgetField（Stringname）//根据变量名得到相应的public变量
Field[]getFields（）//获得类中所以public的方法
FieldgetDeclaredField（Stringname）//根据方法名获得public和非public变量
Field[]getDeclaredFields（）//获得类中所有的public和非public方法
常用的就这些，知道这些，其他的都好办……
五、用反射机制能干什么事
刚开始在使用jdbc时侯，在编写访问数据库时写到想吐，有八个表，每个表都有增删改查中操作
那时候还不知道有反射机制这个概念，所以就对不同的表创建不同的dao类,这样不仅开发速率地，而且代码
冗余的厉害，最要命的是看着差不多的，然后直接复制修改，由于容易犯各种低级的错误（大小写啊，多一
个或少一个字母啊……）,一个错误就可以让你找半天。
有了java反射机制，什么都好办了，只需要写一个dao类，四个方法，增删改查，传入不同的对象，就OK啦，
无需为每一个表都创建dao类，反射机制会自动帮我们完成剩下的事情，这就是它的好处。
说白了，反射机制就是专门
帮我们做那些重复的有规则的事情，所以现在很多的自动生成代码的软件就是运用反射机制来完成的，只要你按照规则
输入相关的参数，所以低级的程序员慢慢的就被抹杀了，为什么？
因为代码都不用写了，随便一个人都会开发，还要程
序员干什么啊？
所以我们只有一条出路，那就是努力努力再努力，成为高级程序员，专门开发傻瓜软件，让其他程序员到一边凉快去，呵呵~
六、用反射机制实现对数据库数据的增、查例子
基本原理；保存数据时，把需要保存的对象的属性值全部取出来再拼凑sql语句查询时，将查询到的数据全部包装成一个java对象。
游戏规则：
俗话说的好，无规矩不成方圆，特别是程序来说，它只能做有规则的事情，没有规则的它干不了，好，那就
先定规则
1）数据库的每一个表对象一个pojo类，表中的每一个字段对应pojo类的中的一个属性。
并且pojo类的名字和表的名字相同，属性名和字段名相同，大小写没有关系，因为数据库一般不区分大小写
2）为pojo类中的每一个属性添加标准的set和get方法。
有了游戏规则，那么开始游戏吧。
1、首先数据库的有一个表，假设数据库名称为：
blogsystem,里面的一个表名userinfo。
如图：
2、创建对应的pojo类：
?
1
2
3
4
5
6
7
8
9
10
11
篇二：
Java反射经典实例JavaReflectionCookbook
Java反射经典实例JavaReflectionCookbook
201X-06-1309:
28
Java提供了一套机制来动态执行方法和构造方法，以及数组操作等，这套机制就叫——反射。
反射机制是如今很多流行框架的实现基础，其中包括Spring、Hibernate等。
原理性的问题不是本文的重点，接下来让我们在实例中学习这套精彩的机制。
1.得到某个对象的属性
1.publicObjectgetProperty（Objectowner,StringfieldName）throwsException{
2.ClassownerClass=
owner.getClass（）;3.
4.Fieldfield=
ownerClass.getField（fieldName）;
5.
6.Objectproperty=
field.get（owner）;7.
8.return
property;
9.}
ClassownerClass=owner.getClass（）：
得到该对象的Class。
Fieldfield=ownerClass.getField（fieldName）：
通过Class得到类声明的属性。
Objectproperty=field.get（owner）：
通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。
2.得到某个类的静态属性
1.publicObjectgetStaticProperty（StringclassName,String
fieldName）
2.throwsException
{
3.ClassownerClass=
Class.forName（className）;
4.
5.Fieldfield=
ownerClass.getField（fieldName）;
6.
7.Objectproperty=
field.get（ownerClass）;
8.
9.return
property;
10.}
ClassownerClass=Class.forName（className）：
首先得到这个类的Class。
Fieldfield=ownerClass.getField（fieldName）：
和上面一样，通过Class得到类声明的属性。
Objectproperty=field.get（ownerClass）：
这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。
3.执行某对象的方法
1.publicObjectinvokeMethod（Objectowner,StringmethodName,Object[]args）throwsException{
2.ClassownerClass=owner.getClass（）;
3.Class[]argsClass=newClass[args.length];
4.for（inti=0,j=args.length;i5.argsClass[i]=args[i].getClass（）;
6.}
7.Methodmethod=ownerClass.getMethod（methodName,
argsClass）;
8.returnmethod.invoke（owner,args）;
9.}
Classowner_class=owner.getClass（）：
首先还是必须得到这个对象的Class。
3～6行：
配置参数的Class数组，作为寻找Method的条件。
Methodmethod=ownerClass.getMethod（methodName,argsClass）：
通过Method
名和参数的Class数组得到要执行的Method。
method.invoke（owner,args）：
执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。
返回值是Object，也既是该方法的返回值。
4.执行某个类的静态方法
1.publicObjectinvokeStaticMethod（StringclassName,StringmethodName,
2.Object[]args）throwsException
{
3.Classow
nerClass=
Class.forName（className）;
4.
5.Class[]argsClass=new
Class[args.length];
6.
7.for（inti=0,j=args.length;i{
8.argsClass[i]=
args[i].getClass（）;
9.}
10.
11.Methodmethod=ownerClass.getMethod（methodName,
argsClass）;
12.
13.returnmethod.invoke（null,
args）;
14.}
基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。
5.新建实例
1.publicObjectnewInstance（StringclassName,Object[]args）throwsException{
2.ClassnewoneClass=
Class.forName（className）;
3.
4.Class[]argsClass=new
Class[args.length];
5.
6.for（inti=0,j=args.length;i{
7.argsClass[i]=
args[i].getClass（）;
8.}
9.
10.Constructorcons=
newoneClass.getConstructor（argsClass）;
11.
12.return
cons.newInstance（args）;
13.
14.}
这里说的方法是执行带参数的构造函数来新建实例的方法。
如果不需要参数，可以直接使用newoneClass.newInstance（）来实现。
ClassnewoneClass=Class.forName（className）：
第一步，得到要构造的实例的Class。
第6～第10行：
得到参数的Class数组。
Constructorcons=newoneClass.getConstructor（argsClass）：
得到构造子。
cons.newInstance（args）：
新建实例。
6.判断是否为某个类的实例
1.publicbooleanisInstance（Objectobj,Classcls）{
2.returncls.isInstance（obj）;
3.}
7.得到数组中的某个元素
1.publicObjectgetByArray（Objectarray,intindex）{
2.returnArray.get（array,index）;
3.}
附完整源码：
1.importjava.lang.reflect.Array;
2.importjava.lang.reflect.Constructor;
3.importjava.lang.reflect.Field;
4.importjava.lang.reflect.Method;
5.
6.
7.publicclassReflection{
8.publicObjectgetProperty（Objectowner,StringfieldName）throwsException{
9.ClassownerClass=owner.getClass（）;
10.
11.Fieldfield=ownerClass.getField（fieldName）;12.
13.Objectproperty=field.get（owner）;
14.
15.returnproperty;
16.}
17.publicObjectgetStaticProperty（StringclassName,StringfieldName）
18.throwsException{
19.ClassownerClass=Class.forName（className）;20.
21.Fieldfield=ownerClass.getField（fieldName）;22.
23.Objectproperty=field.get（ownerClass）;
24.
25.returnproperty;
26.}
27.
28.publicObjectinvokeMethod（Objectowner,StringmethodName,Object[]args）
29.throwsException{
篇三：
反射案例
反射
反射在下列情况下很有用：
需要访问程序元数据的属性。
请参见主题使用反射访问属性。
检查和实例化程序集中的类型。
在运行时构建新类型。
使用System.Reflection.Emit中的类。
执行后期绑定，访问在运行时创建的类型的方法。
请参见主题动态加载和使用类型。
反射的一般概念：
反射提供了封装程序集、模块和类型的对象。
您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现
有对象中获取类型。
然后，可以调用类型的方法或访问其字段和属性。
我觉得这个已经是对反射比较干脆利落的诠释。
这里的”动态”二字非常重要，即指的是运行时刻，在运行的时刻我们可以根据程序逻辑或外部要求（比如配置文件等）创建类型的实例，然后实现象用new构造对象一样同等的效果。
当然构造了这个实例之后下来的访问和以前就一样。
反射的效率：
采用反射构造对象的实例，机器明显出现延迟，不言而喻，反射是以牺牲效率为代价的。
优点：
1.反射是一个非常优秀的代码生成替代工具，能够显著减少代码长度，并缓解应用维护压力。
2.可以降低不同模块之间的依赖关系，大大提高可维护性。
缺点：
反射是以牺牲效率为代价的即消耗性能大。
下面是测试反射性能的代码：
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
namespaceWindowsFormsApplication1
{
publicclassCTester
{
privatedoublea;
publicCTester（）
{
a=10;
}
publicvoidtest1（）
{
a=（a-0.0001）*1.0001;
}
publicdoubleGeta（）
{
returna;
}
}
usingSystem;
usingSystem.Collections.Generic;
usingSystem.ComponentModel;
usingSystem.Data;
usingSystem.Drawing;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Windows.Forms;
usingSystem.Reflection;
namespaceWindowsFormsApplication1
{
publicpartialclassForm1:
Form
{
publicForm1（）
{
InitializeComponent（）;
}
privatevoidForm1_Load（objectsender,EventArgse）
{
}
privatevoidbutton1_Click（objectsender,EventArgse）
{
intdt1=DateTime.Now.Minute*60000+DateTime.Now.Second*1000+DateTime.Now.Millisecond;
CTesteraTest=newCTester（）;
for（inti=0;i<1000;i++）
{
for（intj=0;j<100;j++）
{
aTest.test1（）;
}
}
intdt2=DateTime.Now.Minute*60000+DateTime.Now.Second*1000+DateTime.Now.Millisecond;intspand=dt2-dt1;
label1.Text="用掉时间：
"+spand.ToString（）;
label3.Text="值为：
"+aTest.Geta（）;
//test1（）;
}
privatevoidbutton2_Click（objectsender,EventArgse）
{
intdt1=DateTime.Now.Minute*60000+DateTime.Now.Second*1000+DateTime.Now.Millisecond;
//如果将下面两个句话放入循环中，时间会用的更久
TypetheTest=Type.GetType（"WindowsFormsApplication1.CTester"）;
objecttheobj=theTest.InvokeMember（null,BindingFlags.CreateInstance,null,null,null）;
for（inti=0;i<1000;i++）
{
for（intj=0;j<100;j++）
{
theTest.InvokeMember（"test1",BindingFlags.InvokeMethod,null,theobj,newobject[0]）;}
}
CTesterthewar=theobjasCTester;
intdt2=DateTime.Now.Minute*60000+DateTime.Now.Second*1000+DateTime.Now.Millisecond;intspand=dt2-dt1;
label2.Text="用掉时间：
"+spand.ToString（）;
label4.Text="值为：
"+thewar.Geta（）;
//test2（）;
}
//首先我们对于对象的构造进行测试
//测试代码如下
privatevoidtest1（）
{
label1.Text="";
label3.Text="";
intdt1=DateTime.Now.Minute*60000+DateTime.Now.Second*1000+DateTime.Now.Millisecond;
for（inti=0;i<1000;i++）
{
for（intj=0;j<100;j++）
{
CTesteraTest=newCTester（）;
}
}
intdt2=DateTime.Now.Minute*60000+DateTime.Now.Second*1000+DateTime.Now.Millisecond;intspand=dt2-dt1;
label1.Text="用掉时间：
"+spand.ToString（）;
}
privatevoidtest2（）
{
label2.Text="";
label4.Text="";
intdt1=DateTime.Now.Minute*600
升级会员 