Java反射实践

在讲Java的反射机制之前必须先了解Java的Class类和Class对象：

一、Java中的Class类是一个什么样的类

Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是Class类。Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建。
Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象。
虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类（型）都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。
基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也都对应一个 Class 对象。
每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
一般某个类的Class对象被载入内存，它就用来创建这个类的所有对象。

二、Java中的Class对象和实例对象

java中把生成Class对象和实例对象弄混了，更何况生成Class对象和生成instance都有多种方式。所以只有弄清其中的原理，才可以深入理解。首先要生成Class对象，然后再生成Instance。那Class对象的生成方式有哪些呢，以及其中是如何秘密生成的呢？

Class对象的生成方式如下：

1. Class.forName(“类名字符串”) （注意：类名字符串必须是全称，包名+类名）
2. 类名.class
3. 实例对象.getClass()

通过一段小程序，来观察一下Class对象的生成的原理。

public class TestClass {    public static void main(String[] args) {        try {            //测试Class.forName()            Class testTypeForName = Class.forName("TestClassType");            System.out.println("testForName---" + testTypeForName);            //测试类名.class            Class testTypeClass = TestClassType.class;            System.out.println("testTypeClass---" + testTypeClass);            //测试Object.getClass()            TestClassType testGetClass = new TestClassType();            System.out.println("testGetClass---" + testGetClass.getClass());        } catch (ClassNotFoundException e) {            e.printStackTrace();        }    }}   class TestClassType {    //构造函数    public TestClassType() {        System.out.println("----构造函数---");    }    //静态的参数初始化    static {        System.out.println("---静态的参数初始化---");    }    //非静态的参数初始化    {        System.out.println("----非静态的参数初始化---");    }}

测试的结果如下：

—静态的参数初始化—
testForName—class TestClassType
testTypeClass—class TestClassType
—-非静态的参数初始化—
—-构造函数—
testGetClass—class TestClassType

根据结果可以发现，三种生成的Class对象一样的。并且三种生成Class对象只打印一次“静态的参数初始化”。
我们知道，静态的方法属性初始化，是在加载类的时候初始化。而非静态方法属性初始化，是new类实例对象的时候加载。
因此，这段程序说明，三种方式生成Class对象，其实只有一个Class对象。在生成Class对象的时候，首先判断内存中是否已经加载。
所以，生成Class对象的过程其实是如此的：
当我们编写一个新的Java类时,JVM就会帮我们编译成class对象,存放在同名的.class文件中。在运行时，当需要生成这个类的对象，JVM就会检查此类是否已经装载内存中。若是没有装载，则把.class文件装入到内存中。若是装载，则根据class文件生成实例对象。

三、认识Java的Class类

Java反射机制原理：

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。这种反射机制在Java当中给我们带来了极大的方便，被大量地应用于JavaBean中

Java反射机制在我的理解当中就是下面几点

1. 对一个给定的类名（以字符串形式提供）能动态构建一个对象实例
2. 对于任意一个类，都能够知道这个类的所有属性和方法
3. 对于任意一个对象，都能够调用它的任意一个方法和属性；

在Java的反射中我们主要用到以下几个类，下面将逐个说明

1. java.lang.Class类：用于保存每个对象所属类的相关信息，在Java中，Object类中的getClass()方法将会返回一个Class类型的实例，（注意：记住这是一个类，和关键字class完全是两码事）
2. java.lang.reflect.Constructor:提供关于类的单个构造方法的信息以及对它的访问权限。
3. java.lang.reflect.Field:提供有关类或接口的单个字段的信息，以及对它的动态访问权限
4. java.lang.reflect.Method:提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。
5. java.lang.reflect.Modifier:提供了类、类的成员、static方法、常量的修饰符。

理论看上去非常简单，下面我们用代码来展示下如何正确使用它们，在此之前，我们先创建两个类，后面需要用到

public class Person {    // Field    private String person_name;    protected int person_age;    public boolean person_sex;    // Construct    public Person() {        super();    }    public Person(String name, int age, boolean sex) {        super();        this.setPerson_name(name);        this.person_age = age;        this.person_sex = sex;    }    // Method    public void AddAge(int year) {        this.person_age += this.person_age + year;    }    public String getPerson_name() {        return person_name;    }    public void setPerson_name(String person_name) {        this.person_name = person_name;    }}public class Employee extends Person{    private double saray;    protected String gangwei;    public Employee() {        super();    }    public Employee(double saray, String gangwei) {        super();        this.saray = saray;        this.gangwei = gangwei;    }    public double getSaray() {        return saray;    }    public void setSaray(double saray) {        this.saray = saray;    }    public String getGangwei() {        return gangwei;    }    public void setGangwei(String gangwei) {        this.gangwei = gangwei;    }    public void addSaray(double money){        this.saray+=money;    }}

1. 根据类名构造一个实例

        // 根据类名获取Class对象        Class c = Class.forName("Employee");        System.out.println(c.getName()); // 此处打印：Employee        // 获取父类Class对象        Class cp = c.getSuperclass();        System.out.println(cp.getName());// 此处打印：Person        // 获取类的访问修饰符        String modifiers = Modifier.toString(c.getModifiers());        System.out.println(modifiers); // 此处打印：public        // 实例化        Object obj = c.newInstance(); //通过无参的构造函数进行实例化

2. 获取类的Field,主要有以下四个方法

Class c = Class.forName(“Employee”);

• c.getField(name) ;
• c.getFields()
• c.getDeclaredFields()
• c.getDeclaredField(name)

**注意：getField()方法返回这个类或其超类的公有字段（不包括private和protect修饰的字段）
getDeclaredField方法返回这个类的全部字段（包括private和protect修饰的字段）**

        /*         * 获取类Employee的所有Field         *          * c.getField(name) c.getFields() c.getDeclaredFields()         * c.getDeclaredField(name)         */        Field[] fields = c.getDeclaredFields();        for (Field f : fields) {            // 获取该Field的类型            Class type = f.getType();            // 获取该Field的名称            String name = f.getName();            // 获取该Field的访问修饰符            String sFieldModifiers = Modifier.toString(f.getModifiers());            System.out.println(sFieldModifiers + " " + type.getName() + " " + name + ";");        }

3. 获取类的构造函数

同Field一样，获取构造函数也有4个方法

• c.getDeclaredConstructors()
• c.getConstructors()
• c.getDeclaredConstructor(parameterTypes)
• c.getDeclaredConstructor(parameterTypes)

        /*         * 获取类的构造函数          * c.getDeclaredConstructors()          * c.getConstructors()         * c.getDeclaredConstructor(parameterTypes)         * c.getDeclaredConstructor(parameterTypes)         */        Constructor[] constructors = c.getDeclaredConstructors();        for (Constructor cr : constructors) {            // 构造函数名称            String name = cr.getName();            // 构造函数修饰符            String sConstructorModifiers = Modifier.toString(cr.getModifiers());            // 构造函数参数            Class[] paramTypes = cr.getParameterTypes();            String sParam = "";            for (int j = 0; j < paramTypes.length; j++) {                if (j > 0)                    sParam += ", ";                sParam += paramTypes[j].getName();            }            System.out.println(sConstructorModifiers + " " + name + "(" + sParam + ");");        }

4. 获取类的Method

同Field一样，有4个获取方法的方法，另外多了一个方法，用于获取返回类型

• c.getMethods();
• c.getMethod(name, parameterTypes)
• c.getDeclaredMethods();
• c.getDeclaredMethod(name, parameterTypes)

Method[] methods = c.getDeclaredMethods();        for (Method m : methods) {            // 方法返回类型            Class returnType = m.getReturnType();            String sReturnType = returnType.toString();            // 方法名称            String name = m.getName();            // 方法修饰符            String sMethodModifiers = Modifier.toString(m.getModifiers());            // 方法参数            Class[] paramTypes = m.getParameterTypes();            String sParam = "";            for (int j = 0; j < paramTypes.length; j++) {                if (j > 0)                    sParam += ", ";                sParam += paramTypes[j].getName();            }            System.out.println(sMethodModifiers + " " + sReturnType + " " + name + "(" + sParam + ");");        }  

5. 利用反射动态给对象属性赋值，比如我们需要从配置文件中读取某个员工的信息，并赋值给某个对象，我们可以这样写：

        Class c2 = Class.forName("Employee");        Object e = c2.newInstance();        Field f = c2.getDeclaredField("saray");        // 因为属性saray是private的，所有需要调用setAccessible方法才能给该属性赋值，否则报错        f.setAccessible(true);        f.set(e, 10000);        Field f2 = c2.getDeclaredField("gangwei");        f2.set(e, "高级软件工程师");        System.out.println(((Employee) e).getGangwei() + " " + ((Employee) e).getSaray());        // 取值        Field f3 = c2.getDeclaredField("saray");        Field f4 = c2.getDeclaredField("gangwei");        f3.setAccessible(true);        System.out.println(f3.get(e));        System.out.println(f4.get(e)); 

输出结果如下：
高级软件工程师 10000.0
10000.0
高级软件工程师

6. 利用反射动态地调用对象的方法，比如Employee类中有个addsaray的方法，我们看下要怎么调用：

Class c3 = Class.forName("Employee");        Object e3 = c3.newInstance();        Field fSaray = c3.getDeclaredField("saray");        fSaray.setAccessible(true);        fSaray.set(e3, 10000);        System.out.println(fSaray.get(e3)); //输出10000        // 获取Method        Method m = c3.getDeclaredMethod("addSaray", double.class);        /*         * Method m = c3.getDeclaredMethod("addSaray"); Method m2 =         * c3.getDeclaredMethod("addSaray", double.class);         * 如果有多个重名的方法，要添加参数让编译器知道应该调用哪个方法，这里只有一个参数，所以上面两种写法都可以         */        // 调用方法        m.invoke(e3, 5000);        System.out.println(fSaray.get(e3)); //输出15000，因此证明方法调用成功 

输出结果如下：
10000.0
15000.0