JAVA反射机制

最新推荐文章于 2023-06-27 17:22:25 发布

liuyu1942

最新推荐文章于 2023-06-27 17:22:25 发布

阅读量304

点赞数

分类专栏： C++与JAVA基础文章标签： java class

C++与JAVA基础专栏收录该内容

34 篇文章 0 订阅

订阅专栏

http://blog.csdn.net/cnham/article/details/3086038

反射：也就是说,在编译时,你获取了一个指向某个并不存在你的程序空间中的对象的引用;事实上在编译时你的程序无法获知这个对象所属的类.

Java附带的库java.lang.reflect包含了:

FIeld,Method,Constructor类.

这些类型的对象是由jvm在运行时创建的,用以表示未知类里对应的成员.你就可以使用Constructor创建新的对象,

用get()和set()方法读取和修改与Field对象关联的字段,用invoke()方法调用与Method对象关联的方法.

^_^其他的去翻一下jdk文档吧!

一
Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，
Constructor[] getConstructors() -- 获得类的所有公共构造函数
Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)
Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)
二.
Field getField(String name) -- 获得命名的公共字段
Field[] getFields() -- 获得类的所有公共字段
Field getDeclaredField(String name) -- 获得类声明的命名的字段
Field[] getDeclaredFields() -- 获得类声明的所有字段
三.
Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法
Method[] getMethods() -- 获得类的所有公共方法
Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

反射（背景）：
什么是反射？有什么用？
先了解一些基本的概念：运行时，编译时，编译型，解释型，类加载器，动态加载类
什么是编译？将原程序翻译成计算机语言，就是二进制代码，在java中是将.java文件也就是源程序翻译成.class的字节码
什么是编译时？将原程序翻译成计算机语言的过程中，将.java翻译为.class文件的过程
什么是运行时？就是在启动这个程序的时候，在java中是,类加载器加载.class文件，并交给jvm处理
什么是编译型语言？将原程序一次性全部转换为二进制代码，然后执行程序
什么是解释型语言？转换一句，执行一句，java是既编译又解释的语言
编译型语言和解释型语言的区别：编译型语言效率高，依赖于编译器，但是跨平台差，解释型的效率低，依赖于解释器，但跨平台强
什么是类加载器？类加载器就是JVM中的类装载器，作用就是将编译好的.class字节码运到检查器进行安全检查的，检查通过后开始解释执行
什么是运行时动态加载类？
反射就是可以将一个程序（类）在运行的时候获得该程序（类）的信息的机制，也就是获得在编译期不可能获得的类的信息，因为这些信息是保存在Class对象中的，而这个Class对象是在程序运行时动态加载的
它就是可以在程序运行的时候动态装载类，查看类的信息，生成对象，或操作生成对象。类在运行的时候，可以得到该类的信息，并且可以动态的修改这些信息，自己能看到自己，跟照镜子一样，class对象是在运行的时候产生的，通过class对象操作类的信息是在运行时进行的，当运行程序的时候，类加载器会加载真正需要的类，什么是真正需要的呢？就是该类真正起作用，如：有该类的对象实例，或该类调用了静态方法属性等
反射的作用第一，远程方法调用，第二，通过容器得到组件的对象

如何实现反射呢？
得到Class对象
三种方式得到Class对象：
1．调用对象的getClass方法，返回该对象的Class对象
2．Class.forName(“类的名字”);有个受查异常
3．Class c=类名.class
/**
* 知识点：
* Class类
* 知道一个类的对象的名字，就能得到该对象所在类的信息
* 对象.getClass();   getClass()方法是在Object类中定义的
* 程序目标：
* 创建一个对象，得到它的类的信息，如：类名，父类是谁等等
*/

----------------------Java反射理论知识和例题-----------------------------------------------------------
Java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。灵活掌握Java反射机制，对大家以后学习框架技术有很大的帮助。

那么什么是Java的反射呢？
       大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。
Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。

那么Java反射有什么作用呢？
假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。

Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用过Jcreator和eclipse。当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审。

Class类
       要正确使用Java反射机制就得使用java.lang.Class这个类。它是Java反射机制的起源。当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。

反射API

       u反射API用于反应在当前Java虚拟机中的类、接口或者对象信息
u功能
—获取一个对象的类信息.
       —获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息.
       —检获属于一个接口的常量和方法声明.
       —创建一个直到程序运行期间才知道名字的类的实例.
       —获取并设置一个对象的成员，甚至这个成员的名字是
   在程序运行期间才知道.
       —检测一个在运行期间才知道名字的对象的方法

       利用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信息进行检测。当然这种检测在对运行的性能上会有些减弱，所以什么时候使用反射，就要靠业务的需求、大小，以及经验的积累来决定。

       那么如何利用反射API在运行的时候知道一个类的信息呢？

代码示例：

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import javax.swing.JOptionPane;

public class MyTest {


    public MyTest(){

       String classInfo=JOptionPane.showInputDialog(null,"输入类全路径");//要求用户输入类的全路径

       try {
           Class cla=Class.forName(classInfo);//根据类的全路径进行类加载，返回该类的Class对象

           Method[] method=cla.getDeclaredMethods();//利用得到的Class对象的自审，返回方法对象集合

           for(Method me:method){//遍历该类方法的集合
              System.out.println(me.toString());//打印方法信息
           }

           System.out.println("********");

           Field[] field=cla.getDeclaredFields();//利用得到的Class对象的自审，返回属性对象集合
           for(Field me:field){ //遍历该类属性的集合
              System.out.println(me.toString());//打印属性信息
           }
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
    }
    public static void main(String[] args) {
       new MyTest();
    }
}

运行的时候，我们输入javax.swing.JFrame，那么运行结果如下：

public void javax.swing.JFrame.remove(java.awt.Component)
public void javax.swing.JFrame.update(java.awt.Graphics)
…………

********
public static final int javax.swing.JFrame.EXIT_ON_CLOSE
private int javax.swing.JFrame.defaultCloseOperation

…………

    大家可以发现，类的全路径是在程序运行的时候，由用户输入的。所以虚拟机事先并不知道所要加载类的信息，这就是利用反射机制来对用户输入的类全路径来对类自身的一个自审。从而探知该类所拥有的方法和属性。

通过上面代码，大家可以知道编译工具为什么能够一按点就能列出用户当前对象的属性和方法了。它是先获得用户输入对象的字符串，然后利用反射原理来对这样的类进行自审，从而列出该类的方法和属性。

使用反射机制的步骤：
u导入java.lang.relfect 包

u遵循三个步骤
第一步是获得你想操作的类的 java.lang.Class 对象
第二步是调用诸如 getDeclaredMethods 的方法
第三步使用反射API 来操作这些信息

获得Class对象的方法

u如果一个类的实例已经得到，你可以使用
       【Class c = 对象名.getClass(); 】
      例： TextField t = new TextField();
              Class c = t.getClass();
              Class s = c.getSuperclass();

u如果你在编译期知道类的名字，你可以使用如下的方法
Class c = java.awt.Button.class;
或者
         Class c = Integer.TYPE;

u如果类名在编译期不知道, 但是在运行期可以获得, 你可以使用下面的方法
          Class c = Class.forName(strg);
   这样获得Class类对象的方法，其实是利用反射API把指定字符串的类加载到内存中，所以也叫类加载器加载方法。这样的话，它会把该类的静态方法和静态属性，以及静态代码全部加载到内存中。但这时候，对象还没有产生。所以为什么静态方法不能访问非静态属性和方法。因为静态方法和属性产生的时机在非静态属性和方法之前。

代码示例：
package com;

public class MyTest {
    public static void main(String[] args) {
       TestOne one=null;
       try{
       Class cla=Class.forName("com.TestOne");//进行com.TestOne类加载，返回一个Class对象
       System.out.println("********");
       one=(TestOne)cla.newInstance();//产生这个Class类对象的一个实例，调用该类无参的构造方法，作用等同于new TestOne()
       }catch(Exception e){
           e.printStackTrace();
       }
       TestOne two=new TestOne();
System.out.println(one.getClass() == two.getClass());//比较两个TestOne对象的Class对象是否是同一个对象，在这里结果是true。说明如果两个对象的类型相同，那么它们会有相同的Class对象
    }
}

class TestOne{
    static{
       System.out.println("静态代码块运行");
    }
    TestOne(){
       System.out.println("构造方法");
    }
}
以上代码过行的结果是：
静态代码块运行
***********
构造方法
构造方法

代码分析：

在进行Class.forName("com.TestOne")的时候，实际上是对com.TestOne进行类加载，这时候，会把静态属性、方法以及静态代码块都加载到内存中。所以这时候会打印出"静态代码块运行"。但这时候，对象却还没有产生。所以"构造方法"这几个字不会打印。当执行cla.newInstance()的时候，就是利用反射机制将Class对象生成一个该类的一个实例。这时候对象就产生了。所以打印"构造方法"。当执行到TestOne two=new TestOne()语句时，又生成了一个对象。但这时候类已经加载完毕，静态的东西已经加载到内存中，而静态代码块只执行一次，所以不用再去加载类，所以只会打印"构造方法"，而"静态代码块运行"不会打印。

反射机制不但可以例出该类对象所拥有的方法和属性，还可以获得该类的构造方法及通过构造方法获得实例。也可以动态的调用这个实例的成员方法。

代码示例：

package reflect;

import java.lang.reflect.Constructor;

public class ConstructorTest {

    public static void main(String[] args) {
       try {
           //获得指定字符串类对象
           Class cla=Class.forName("reflect.Tests");
           //设置Class对象数组，用于指定构造方法类型
           Class[] cl=new Class[]{int.class,int.class};

           //获得Constructor构造器对象。并指定构造方法类型
           Constructor con=cla.getConstructor(cl);

           //给传入参数赋初值
           Object[] x={new Integer(33),new Integer(67)};

           //得到实例
           Object obj=con.newInstance(x);
       } catch (Exception e) {
           e.printStackTrace();
       }
    }

}

class Tests{
    public Tests(int x,int y){
       System.out.println(x+"    "+y);
    }
}

运行的结果是” 33    67”。说明我们已经生成了Tests这个类的一个对象。

同样，也可以通过反射模式，来执行Java类的方法

代码示例：
package reflect;

import java.lang.reflect.Method;

public class MethodTest {

    public static void main(String[] args) {
       try {
           //获得窗体类的Class对象
           Class cla=Class.forName("javax.swing.JFrame");

           //生成窗体类的实例
           Object obj=cla.newInstance();

       //获得窗体类的setSize方法对象，并指定该方法参数类型为int,int
           Method methodSize=cla.getMethod("setSize", new Class[]{int.class,int.class});


           methodSize.invoke(obj, new Object[]{new Integer(300),new Integer(300)});

       //获得窗体类的setSize方法对象，并指定该方法参数类型为boolean
           Method methodVisible=cla.getMethod("setVisible", new Class[]{boolean.class});


           methodVisible.invoke(obj, new Object[]{new Boolean(true)});

       } catch (Exception e) {
           e.printStackTrace();
       }
    }
}

反射技术大量用于Java设计模式和框架技术，最常见的设计模式就是工厂模式(Factory)和单例模式(Singleton)。

单例模式(Singleton)

       这个模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录数据库连接都需要这样的单线程操作。这样做就是为了节省内存空间，保证我们所访问到的都是同一个对象。

       单例模式要求保证唯一，那么怎么样才能保证唯一性呢？对了，这就是静态变量。单例模式有以下两种形式：

第一种形式：
package reflect;

public class Singleton {

    private Singleton() {
    }


    private static Singleton instance = new Singleton();

    // 这里提供了一个供外部访问本class的静态方法，可以直接访问
    public static Singleton getInstance() {
           return instance;
    }

}

class SingRun{
    public static void main(String[] args){
       //这样的调用不被允许，因为构造方法是私有的。
       //Singleton x=new Singleton();

       //得到一个Singleton类实例
       Singleton x=Singleton.getInstance();

       //得到另一个Singleton类实例
       Singleton y=Singleton.getInstance();

       //比较x和y的地址，结果为true。说明两次获得的是同一个对象
       System.out.println(x==y);
    }
}

第二种形式：

public class Singleton {

    //先申明该类静态对象
    private static Singleton instance = null;

    //创建一个静态访问器，获得该类实例。加上同步，表示防止两个线程同时进行对象的创建
    public static synchronized Singleton getInstance() {

       //如果为空，则生成一个该类实例
       if (instance == null){
           instance = new Singleton();
       }
       return instance;
    }

}

工厂模式（Factory）

       工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。

为什么工厂模式是如此常用？是因为工厂模式利用Java反射机制和Java多态的特性可以让我们的程序更加具有灵活性。用工厂模式进行大型项目的开发，可以很好的进行项目并行开发。就是一个程序员和另一个程序员可以同时去书写代码，而不是一个程序员等到另一个程序员写完以后再去书写代码。其中的粘合剂就是接口和配置文件。
之前说利用接口可以将调用和实现相分离。
那么这是怎么样去实现的呢？工厂模式可以为我们解答。

我们先来回顾一下软件的生命周期，分析、设计、编码、调试与测试。其中分析就是指需求分析，就是知道这个软件要做成什么样子，要实现什么样的功能。功能知道了，这时就要设计了。设计的时候要考虑到怎么样高效的实现这个项目，如果让一个项目团队并行开发。这时候，通常先设计接口，把接口给实现接口的程序员和调用接口的程序员，在编码的时候，两个程序员可以互不影响的实现相应的功能，最后通过配置文件进行整合。

代码示例：

interface InterfaceTest{
    public void getName();//定义获得名字的方法
}

接口有了，那么得到这个接口，进行实现编码的程序员应该怎么做呢？对了，实现这个接口，重写其中定义的方法

接口实现方：

class Test1 implements InterfaceTest{


    public void getName() {
       System.out.println("test1");
    }

}

class Test2 implements InterfaceTest{


    public void getName() {
       System.out.println("test2");
    }

}

大家可以发现，当接口定义好了以后，不但可以规范代码，而且可以让程序员有条不紊的进行功能的实现。实现接口的程序员根本不用去管，这个类要被谁去调用。

那么怎么能获得这些程序员定义的对象呢？在工厂模式里，单独定义一个工厂类来实现对象的生产，注意这里返回的接口对象。

工厂类，生产接口对象：

class Factory{
    //创建私有的静态的Properties对象
    private static Properties pro=new Properties();

    //静态代码块
    static{
       try {

           //加载配置文件
           pro.load(new FileInputStream("file.txt"));
       } catch (Exception e) {
           e.printStackTrace();
       }
    }


    private static Factory factory=new Factory();
    private Factory(){}

    public static Factory getFactory(){
       return factory;
    }


    public InterfaceTest getInterface(){
       InterfaceTest interfaceTest=null;//定义接口对象

       try {
           //根据键，获得值，这里的值是类的全路径
           String classInfo=pro.getProperty("test");

           //利用反射，生成Class对象
           Class c=Class.forName(classInfo);

           //获得该Class对象的实例
           Object obj=c.newInstance();

           //将Object对象强转为接口对象
           interfaceTest=(InterfaceTest)obj;
       } catch (Exception e) {
           e.printStackTrace();
       }

       //返回接口对象
       return interfaceTest;
    }
}

配置文件内容：
test=factory.Test2

通过这个类，大家可以发现，在调用的时候，得到的是个接口对象。而一个接口变量可以指向实现了这个接口的类对象。在利用反射的时候，我们并没有直接把类的全路径写出来，而是通过键获得值。这样的话，就有很大的灵活性，只要改变配置文件里的内容，就可以改变我们调用的接口实现类，而代码不需做任何改变。在调用的时候，我们也是通过接口调用，甚至我们可以连这个接口实现类的名字都不知道。

调用方：

public class FactoryTest {

    public static void main(String[] args) {
       //获得工厂类的实例
       Factory factory=Factory.getFactory();
       //调用获得接口对象的方法，获得接口对象
       InterfaceTest inter=factory.getInterface();
       //调用接口定义的方法
       inter.getName();
    }
}

上面的代码就是调用方法。大家可以发现，在调用的时候，我们根本没有管这个接口定义的方法要怎么样去实现它，我们只知道这个接口定义这个方法起什么作用就行了。上面代码运行结果要根据配置文件来定。如果配置文件里的内容是test=factory.Test2。那么表示调用factory.Test2这个类里实现接口的方法，这时候打印“test2”。如果配置文件里的内容是test=factory.Test1。那么表示调用factory.Test1 这个类里实现接口的方法，这时候打印“test1”。

反射机制是框架技术的原理和核心部分。通过反射机制我们可以动态的通过改变配置文件(以后是XML文件)的方式来加载类、调用类方法，以及使用类属性。这样的话，对于编码和维护带来相当大的便利。在程序进行改动的时候，也只会改动相应的功能就行了，调用的方法是不用改的。更不会一改就改全身。