Java学习笔记-反射

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

http://blog.csdn.net/ouyangmeile/article/details/3889797

一、定义

程序可以访问、检测和修改它本身状态或行为的一种能力。

在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

二、与Java

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性和方法。它是 Java 被视为动态（或准动态）语言的关键，允许程序于执行期 Reflection APIs 取得任何已知名称之 class 的內部信息，包括 package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers，並可于执行期生成instances、变更 fields 內容或唤起 methods。

三、演示

反射类：

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

class A extends Object implements ActionListener {
    private int a = 3;
    public Integer b = new Integer(4);

    public A() {
    }

    public A(int id, String name) {
    }

    public int abc(int id, String name) {
        return 0;
    }

    public void actionPerformed(ActionEvent e) {
    }
}

测试类：

import java.lang.reflect.*;

class B {
    public static void main(String args[]) {
        A r = new A();
        Class temp = r.getClass();
        try {
            System.out.println("反射类中所有公有的属性");
            Field[] fb = temp.getFields();
            for (int j = 0; j < fb.length; j++) {
                Class cl = fb[j].getType();
                System.out.println("fb:" + cl);
            }

            System.out.println("反射类中所有的属性");
            Field[] fa = temp.getDeclaredFields();
            for (int j = 0; j < fa.length; j++) {
                Class cl = fa[j].getType();
                System.out.println("fa:" + cl);
            }
            System.out.println("反射类中私有属性的值");
            Field f = temp.getDeclaredField("a");
            f.setAccessible(true);
            Integer i = (Integer) f.get(r);
            System.out.println(i);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

注意：getField方法只能取到反射类中公有的属性，而getDeclaredField方法都能取到。这里还用到了Field 类的setAccessible方法，它是用来设置是否有权限访问反射类中的私有属性的，只有设置为true时才可以访问，默认为false。另外 Field类还有set(Object AttributeName,Object value)方法，可以改变指定属性的值。

四、应用

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class LoadMethod {
    public Object Load(String cName, String MethodName, String[] type, String[] param) {
        Object retobj = null;
        try {
            // 加载指定的Java类
            Class cls = Class.forName(cName);
//java里面任何class都要装载在虚拟机上才能运行，
A a = (A)Class.forName("pacage.A").newInstance(); 和A a = new A()； 是一样的效果。 
jvm会执行静态代码段，静态代码是和class绑定的，class装载成功就表示执行了你的静态代码了。而且以后不会再走这段静态代码了。

Class.forName(xxx.xx.xx);的作用是要求JVM查找并加载指定的类，也就是说JVM会执行该类的静态代码段动态加载和创建Class 对象

从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：1、这个类已经加载；2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载java API的那个加载器。
            // 获取指定对象的实例
            Constructor ct = cls.getConstructor(null);
            Object obj = ct.newInstance(null);

            // 构建方法参数的数据类型
            Class partypes[] = this.getMethodClass(type);

            // 在指定类中获取指定的方法
            Method meth = cls.getMethod(MethodName, partypes);

            // 构建方法的参数值
            Object arglist[] = this.getMethodObject(type, param);

            // 调用指定的方法并获取返回值为Object类型
            retobj = meth.invoke(obj, arglist);

        } catch (Throwable e) {
            System.err.println(e);
        }
        return retobj;
    }

    // 获取参数类型Class[]的方法
    public Class[] getMethodClass(String[] type) {
        Class[] cs = new Class[type.length];
        for (int i = 0; i < cs.length; i++) {
            if (!type[i].trim().equals("") || type[i] != null) {
                if (type[i].equals("int") || type[i].equals("Integer")) {
                    cs[i] = Integer.TYPE;
                } else if (type[i].equals("float") || type[i].equals("Float")) {
                    cs[i] = Float.TYPE;
                } else if (type[i].equals("double") || type[i].equals("Double")) {
                    cs[i] = Double.TYPE;
                } else if (type[i].equals("boolean") || type[i].equals("Boolean")) {
                    cs[i] = Boolean.TYPE;
                } else {
                    cs[i] = String.class;
                }
            }
        }
        return cs;
    }

    // 获取参数Object[]的方法
    public Object[] getMethodObject(String[] type, String[] param) {
        Object[] obj = new Object[param.length];
        for (int i = 0; i < obj.length; i++) {
            if (!param[i].trim().equals("") || param[i] != null) {
                if (type[i].equals("int") || type[i].equals("Integer")) {
                    obj[i] = new Integer(param[i]);
                } else if (type[i].equals("float") || type[i].equals("Float")) {
                    obj[i] = new Float(param[i]);
                } else if (type[i].equals("double") || type[i].equals("Double")) {
                    obj[i] = new Double(param[i]);
                } else if (type[i].equals("boolean") || type[i].equals("Boolean")) {
                    obj[i] = new Boolean(param[i]);
                } else {
                    obj[i] = param[i];
                }
            }
        }
        return obj;
    }
}

Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

优点：解耦，看看框架，都在用这个

缺点：性能，还木有在项目里遇到过这个引起的性能问题，不过掉了其他的api来实现new，确实有问题

参考【http://blog.csdn.net/kubete/article/details/4493977】