Java反射机制

最新推荐文章于 2024-08-16 14:06:47 发布

Hot Autumn

最新推荐文章于 2024-08-16 14:06:47 发布

阅读量510

点赞数 1

分类专栏： Java学习笔记文章标签： Java 反射

Java学习笔记专栏收录该内容

2 篇文章 0 订阅

订阅专栏

转自：这个地方

Java反射机制

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

那么什么是Java的反射呢？

大家知道，让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。

Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。

那么Java反射有什么作用呢？

例子：假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。如：通过第二个程序员那个类的类名（全路径），用这种方法Class c = Class.forName(strg)得到这个类的Class对象（执行这个语句，就是把第二个程序员那个类加载到Java虚拟机），通过这个Class对象，就可以获得第二个程序员那个类的对应的方法、成员以及构造方法的声明和定义等信息。

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

Class类

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

反射API

反射API用于反应在当前Java虚拟机中的类、接口或者对象信息

功能：

a) 获取一个对象的类信息.

b) 获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息.

c) 检获属于一个接口的常量和方法声明.

d) 创建一个直到程序运行期间才知道名字的类的实例.

e) 获取并设置一个对象的成员，甚至这个成员的名字是在程序运行期间才知道.

f) 检测一个在运行期间才知道名字的对象的方法

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

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

代码示例：

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import javax.swing.JOptionPane;
/*本类用于测试反射API，利用用户输入类的全路径，找到该类所有的成员方法和成员属性*/
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 finalint javax.swing.JFrame.EXIT_ON_CLOSE

private int javax.swing.JFrame.defaultCloseOperation

…………

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

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

使用反射机制的步骤

导入java.lang.relfect包

遵循三个步骤：

a) 第一步是获得你想操作的类的java.lang.Class对象

b) 第二步是调用诸如getDeclaredMethods的方法

c) 第三步使用反射API来操作这些信息

第一步中获得Class对象的方法有三种：

a) 如果一个类的实例已经得到，你可以使用Classc =对象名.getClass();eg：

TextField t = new TextField();

Class c = t.getClass();

Class s = c.getSuperclass();

b) 如果你在编译期知道类的名字，你可以使用如下的方法

Class c = java.awt.Button.class;

或者Class c = Integer.TYPE;

c) 如果类名在编译期不知道，但是在运行期可以获得，你可以使用下面的方法

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进行类加载，这时候，会把静态属性、方法以及静态代码块都加载到内存中。所以这时候会打印出"静态代码块运行"。但这时候，类TestOne的对象却还没有产生（只是产生了TestOne的Class对象）。所以"构造方法"这几个字不会打印。当执行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这个类的一个对象。