8java反射机制知识点Word文件下载.docx
《8java反射机制知识点Word文件下载.docx》由会员分享，可在线阅读，更多相关《8java反射机制知识点Word文件下载.docx（16页珍藏版）》请在冰豆网上搜索。
—获取并设置一个对象的成员，甚至这个成员的名字是
在程序运行期间才知道.
—检测一个在运行期间才知道名字的对象的方法
利用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信息进行检测。
当然这种检测在对运行的性能上会有些减弱，所以什么时候使用反射，就要靠业务的需求、大小，以及经验的积累来决定。
那么如何利用反射API在运行的时候知道一个类的信息呢？
代码示例：
importjava.lang.reflect.Field;
importjava.lang.reflect.Method;
importjavax.swing.JOptionPane;
/**
*本类用于测试反射API，利用用户输入类的全路径，
*找到该类所有的成员方法和成员属性
*/
publicclassMyTest{
/**
*构造方法
publicMyTest（）{
StringclassInfo=JOptionPane.showInputDialog（null,"
输入类全路径"
）;
//要求用户输入类的全路径
try{
Classcla=Class.forName（classInfo）;
//根据类的全路径进行类加载，返回该类的Class对象
Method[]method=cla.getDeclaredMethods（）;
//利用得到的Class对象的自审，返回方法对象集合
for（Methodme:
method）{//遍历该类方法的集合
System.out.println（me.toString（））;
//打印方法信息
}
System.out.println（"
********"
Field[]field=cla.getDeclaredFields（）;
//利用得到的Class对象的自审，返回属性对象集合
for（Fieldme:
field）{//遍历该类属性的集合
//打印属性信息
}catch（ClassNotFoundExceptione）{
e.printStackTrace（）;
}
}
publicstaticvoidmain（String[]args）{
newMyTest（）;
}
运行的时候，我们输入javax.swing.JFrame，那么运行结果如下：
publicvoidjavax.swing.JFrame.remove（java.awt.Component）
publicvoidjavax.swing.JFrame.update（java.awt.Graphics）
…………
********
publicstaticfinalintjavax.swing.JFrame.EXIT_ON_CLOSE
privateintjavax.swing.JFrame.defaultCloseOperation
大家可以发现，类的全路径是在程序运行的时候，由用户输入的。
所以虚拟机事先并不知道所要加载类的信息，这就是利用反射机制来对用户输入的类全路径来对类自身的一个自审。
从而探知该类所拥有的方法和属性。
通过上面代码，大家可以知道编译工具为什么能够一按点就能列出用户当前对象的属性和方法了。
它是先获得用户输入对象的字符串，然后利用反射原理来对这样的类进行自审，从而列出该类的方法和属性。
使用反射机制的步骤：
◆导入java.lang.relfect包
◆遵循三个步骤
第一步是获得你想操作的类的java.lang.Class对象
第二步是调用诸如getDeclaredMethods的方法
第三步使用反射API来操作这些信息
获得Class对象的方法
◆如果一个类的实例已经得到，你可以使用
【Classc=对象名.getClass（）;
】
例：
TextFieldt=newTextField（）;
Classc=t.getClass（）;
Classs=c.getSuperclass（）;
◆如果你在编译期知道类的名字，你可以使用如下的方法
Classc=java.awt.Button.class;
或者
Classc=Integer.TYPE;
◆如果类名在编译期不知道,但是在运行期可以获得,你可以使用下面的方法
Classc=Class.forName（strg）;
这样获得Class类对象的方法，其实是利用反射API把指定字符串的类加载到内存中，所以也叫类加载器加载方法。
这样的话，它会把该类的静态方法和静态属性，以及静态代码全部加载到内存中。
但这时候，对象还没有产生。
所以为什么静态方法不能访问非静态属性和方法。
因为静态方法和属性产生的时机在非静态属性和方法之前。
packagecom;
TestOneone=null;
try{
Classcla=Class.forName（"
com.TestOne"
//进行com.TestOne类加载，返回一个Class对象
System.out.println（"
one=（TestOne）cla.newInstance（）;
//产生这个Class类对象的一个实例，调用该类无参的构造方法，作用等同于newTestOne（）
}catch（Exceptione）{
TestOnetwo=newTestOne（）;
System.out.println（one.getClass（）==two.getClass（））;
//比较两个TestOne对象的Class对象是否是同一个对象，在这里结果是true。
说明如果两个对象的类型相同，那么它们会有相同的Class对象
classTestOne{
static{
静态代码块运行"
TestOne（）{
构造方法"
以上代码过行的结果是：
静态代码块运行
***********
构造方法
代码分析：
在进行Class.forName（"
）的时候，实际上是对com.TestOne进行类加载，这时候，会把静态属性、方法以及静态代码块都加载到内存中。
所以这时候会打印出"
。
但这时候，对象却还没有产生。
所以"
这几个字不会打印。
当执行cla.newInstance（）的时候，就是利用反射机制将Class对象生成一个该类的一个实例。
这时候对象就产生了。
所以打印"
当执行到TestOnetwo=newTestOne（）语句时，又生成了一个对象。
但这时候类已经加载完毕，静态的东西已经加载到内存中，而静态代码块只执行一次，所以不用再去加载类，所以只会打印"
，而"
不会打印。
反射机制不但可以例出该类对象所拥有的方法和属性，还可以获得该类的构造方法及通过构造方法获得实例。
也可以动态的调用这个实例的成员方法。
packagereflect;
importjava.lang.reflect.Constructor;
*
*本类测试反射获得类的构造器对象，
*并通过类构造器对象生成该类的实例
*
publicclassConstructorTest{
//获得指定字符串类对象
Classcla=Class.forName（"
reflect.Tests"
//设置Class对象数组，用于指定构造方法类型
Class[]cl=newClass[]{int.class,int.class};
//获得Constructor构造器对象。
并指定构造方法类型
Constructorcon=cla.getConstructor（cl）;
//给传入参数赋初值
Object[]x={newInteger（33）,newInteger（67）};
//得到实例
Objectobj=con.newInstance（x）;
}catch（Exceptione）{
classTests{
publicTests（intx,inty）{
System.out.println（x+"
"
+y）;
运行的结果是”3367”。
说明我们已经生成了Tests这个类的一个对象。
同样，也可以通过反射模式，来执行Java类的方法
*本类测试反射获得类的方法对象，
*并通过类对象和类方法对象，运行该方法
publicclassMethodTest{
//获得窗体类的Class对象
javax.swing.JFrame"
//生成窗体类的实例
Objectobj=cla.newInstance（）;
//获得窗体类的setSize方法对象，并指定该方法参数类型为int,int
MethodmethodSize=cla.getMethod（"
setSize"
newClass[]{int.class,int.class}）;
/*
*执行setSize（）方法，并传入一个Object[]数组对象，
*作为该方法参数，等同于窗体对象.setSize（300,300）;
*/
methodSize.invoke（obj,newObject[]{newInteger（300）,newInteger（300）}）;
//获得窗体类的setSize方法对象，并指定该方法参数类型为boolean
MethodmethodVisible=cla.getMethod（"
setVisible"
newClass[]{boolean.class}）;
*执行setVisible（）方法，并传入一个Object[]数组对象，*作为该方法参数。
等同于窗体对象.setVisible（true）;
methodVisible.invoke（obj,newObject[]{newBoolean（true）}）;
反射技术大量用于Java设计模式和框架技术，最常见的设计模式就是工厂模式（Factory）和单例模式（Singleton）。
单例模式（Singleton）
这个模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
在很多操作中，比如建立目录数据库连接都需要这样的单线程操作。
这样做就是为了节省内存空间，保证我们所访问到的都是同一个对象。
单例模式要求保证唯一，那么怎么样才能保证唯一性呢？
对了，这就是静态变量。
单例模式有以下两种形式：
第一种形式：
publicclassSingleton{
/*
*注意这是private私有的构造方法，只供内部调用
*外部不能通过new的方式来生成该类的实例
*/
privateSingleton（）{
*在自己内部定义自己一个实例，是不是很奇怪？
*定义一个静态的实例，保证其唯一性
privatestaticSingletoninstance=newSingleton（）;
//这里提供了一个供外部访问本class的静态方法，可以直接访问
publicstaticSingletongetInstance（）{
returninstance;
*测试单例模式
classSingRun{
publicstaticvoidmain（String[]args）{
//这样的调用不被允许，因为构造方法是私有的。
//Singletonx=newSingleton（）;
//得到一个Singleton类实例
Singletonx=Singleton.getInstance（）;
//得到另一个Singleton类实例
Singletony=Singleton.getInstance（）;
//比较x和y的地址，结果为true。
说明两次获得的是同一个对象
System.out.println（x==y）;
第二种形式：
//先申明该类静态对象
privatestaticSingletoninstance=null;
//创建一个静态访问器，获得该类实例。
加上同步，表示防止两个线程同时进行对象的创建
publicstaticsynchronizedSingletongetInstance（）{
//如果为空，则生成一个该类实例
if（instance==null）{
instance=newSingleton（）;
returninstance;
工厂模式（Factory）
工厂模式是我们最常用的模式了,著名的Jive论坛,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。
为什么工厂模式是如此常用？
是因为工厂模式利用Java反射机制和Java多态的特性可以让我们的程序更加具有灵活性。
用工厂模式进行大型项目的开发，可以很好的进行项目并行开发。
就是一个程序员和另一个程序员可以同时去书写代码，而不是一个程序员等到另一个程序员写完以后再去书写代码。
其中的粘合剂就是接口和配置文件。
之前说利用接口可以将调用和实现相分离。
那么这是怎么样去实现的呢？
工厂模式可以为我们解答。
我们先来回顾一下软件的生命周期，分析、设计、编码、调试与测试。
其中分析就是指需求分析，就是知道这个软件要做成什么样子，要实现什么样的功能。
功能知道了，这时就要设计了。
设计的时候要考虑到怎么样高效的实现这个项目，如果让一个项目团队并行开发。
这时候，通常先设计接口，把接口给实现接口的程序员和调用接口的程序员，在编码的时候，两个程序员可以互不影响的实现相应的功能，最后通过配置文件进行整合。
*定义接口
interfaceInterfaceTest{
publicvoidgetName（）;
//定义获得名字的方法
接口有了，那么得到这个接口，进行实现编码的程序员应该怎么做呢？
对了，实现这个接口，重写其中定义的方法
接口实现方：
*第一个程序员书写的，实现这个接口的类
classTest1implementsInterfaceTest{
*根据业务，重写方法
publicvoidgetName（）{
test1"
*第二个程序员书写的，实现这个接口的类
classTest2implementsInterfaceTest{
test2"
大家可以发现，当接口定义好了以后，不但可以规范代码，而且可以让程序员有条不紊的进行功能的实现。
实现接口的程序员根本不用去管，这个类要被谁去调用。
那么怎么能获得这些程序员定义的对象呢？
在工厂模式里，单独定义一个工厂类来实现对象的生产，注意这里返回的接口对象。
工厂类，生产接口对象：
*本类为工厂类，用于生成接口对象
classFactory{
//创建私有的静态的Properties对象
privatestaticPropertiespro=newProperties（）;
//静态代码块
//加载配置文件
pro.load（newFileInputStream（"
file.txt"
））;
*单例模式，保证该类只有一个对象
privatestaticFactoryfactory=newFactory（）;
privateFactory（）{}
publicstaticFactorygetFactory（）{
returnfactory;
*本方法为公有方法，用于生产接口对象
*@returnInterfaceTest接口对象
publicInterfaceTestgetInterface（）{
InterfaceTestinterfaceTest=null;
//定义接口对象
//根据键，获得值，这里的值是类的全路径
StringclassInfo=pro.getProperty（"
test"
//利用反射，生成Class对象
Classc=Class.forName（classInfo）;
//获得该Class对象的实例
Objectobj=c.newInstance（）;
//将Object对象强转为接口对象
interfaceTest=（InterfaceTest）obj;
//返回接口对象
returninterfaceTest;
配置文件内容：
test=factory.Test2
通过这个类，大家可以发现，在调用的时候，得到的是个接口对象。
而一个接口变量可以指向实现了这个接口的类对象。
在利用反射的时候，我们并没有直接把类的全路径写出来，而是通过键获得值。
这样的话，就有很大的灵活性，只要改变配置文件里的内容，就可以改变我们调用的接口实现类，而代码不需做任何改变。
在调用的时候，我们也是通过接口调用，甚至我们可以连这个接口实现类的名字都不知道。
调用方：
publicclassFactoryTest{
//获得工厂类的实例
Factoryfactory=Factory.getFactory（）;
//调用获得接口对象的方法，获得接口对象
InterfaceTestinter=factory.getInterface（）;
//调用接口定义的方法
inter.getName（）;
上面的代码就是调用方法。
大家可以发现，在调用的时候，我们根本没有管这个接口定义的方法要怎么样去实现它，我们只知道这个接口定义这个方法起什么作用就行了。
上面代码运行结果要根据配置文件来定。
如果配置文件里的内容是test=factory.Test2。
那么表示调用factory.Test2这个类里实现接口的方法，这时候打印“
升级会员 