Java Reflect 机制

java语言中的反射机制：

  在"Java运行时"环境中，对于任意一个类，可以知道这个类的属性和方法,对于任意一个对象，可以调用他的方法.
  这种动态获取类的信息，以及动态调用类的方法的功能来源于JAVA的反射,从而使java具有动态语言的特性。

JAVA反射机制主要提供了以下功能：（注意：前提都是在运行时，而不是在编译时）

1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用PRivate方法）
4.在运行时调用任意一个对象的方法

Java 反射相关的API简介：

位于java.lang.reflect包中
--Class类：代表一个类
--Filed类：代表类的成员变量
--Method类：代表类的方法
--Constructor类：代表类的构造方法,通过这个构造函数可以访问到类
--Array类：提供了动态创建数组，以及访问数组的元素的静态方法。该类中的所有方法都是静态方法

----Class类

  在java的Object类中的申明了数个应该在所有的java类中被改写的methods：
hashCode(), equals(),clone(),toString(),getClass()等，getClass()返回一个Class类型的对象。

Class类十分的特殊，它和一般的类一样继承自Object，其实体用以表达java程序运行时的class和interface，也用来表达enum，array，primitive，Java Types以及关键字void.

当加载一个类/当加载器（class loader）的defineClass()被JVM调用，便产生一个Class对象，    Class是Reflection起源，针对任何你想探勘的class（类），唯有现为他产生一个Class的对象，接下来才能经由后者唤起为数十多个的反射API.

Java允许我们从多种途径为一个类class生成对应的Class对象.

--运用 getClass（）：Object类中的方法，每个类都拥有此方法

String str="abc";
Class cl=str.getClass();

--运用Class.getSuperclass（）：Class类中的方法，返回该Class的父类的Class
--运用Class.forName()静态方法：
--运用.Class：类名.class
--运用primitive wrapper classes的TYPE语法： 基本类型包装类的TYPE，如：Integer.TYPE
      注意：TYPE的使用，只适合原生（基本）数据类型

----运行时生成instance

  想生成对象的实体，在反射动态机制中有两种方法:
1.针对无变量的构造方法
2.针对带参数的构造方法

  如果想调用带参数的构造方法，就比较的麻烦，不能直接调用Class类中的newInstance(),而是调用Constructor类中newInstance()方法.
  首先准备一个Class[]作为Constructor的参数类型.
  然后调用该Class对象的getConstructor()方法获得一个专属的Constructor的对象
  最后再准备一个Object[]作为Constructor对象的newInstance()方法的实参。

Note:只有两个类拥有newInstance()方法，分别是Class类和Constructor类.
Class类中的newInstance()方法是不带参数的
Constructro类中的newInstance()方法是带参数的,需要提供必要的参数。

Example:
Class c=Class.forName("DynTest");
Class[] ptype=new Class[]{double.class,int.class}；
Constructor ctor=c.getConstructor(ptypr);
Object[] obj=new Object[]{new Double(3.1415),new Integer(123)};
Object object=ctor.newInstance(obj);
System.out.println(object);

----运行时调用Method

1.准备一个Class[]{}作为getMethod（String name，Class[]）方法的参数类型
2.准备一个Obeject[]放置自变量
3.调用Method对象的invoke（Object obj，Object[]）方法.(在这里调用)

----运行时调用Field内容

    变更Field不需要参数和自变量
1.调用Class的getField()并指定field名称，获得特定的Field对象
2.直接调用Field的get(Object obj)和set(Object obj,Object value)方法

Sample1:
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectTester {
    
    public Object copy(Object obj) throws IllegalArgumentException,
            SecurityException, InstantiationException, IllegalAccessException,
            InvocationTargetException, NoSuchMethodException {

        // 获得对象的类型
        Class classType = obj.getClass();
        System.out.println("该对象的类型是：" + classType.toString());

        // 通过默认构造方法去创建一个新的对象，getConstructor的视其参数决定调用哪个构造方法
        Object objectCopy = classType.getConstructor(new Class[] {})
                .newInstance(new Object[] {});

        // 获得对象的所有属性
        Field[] fields = classType.getDeclaredFields();

        for (int i = 0; i < fields.length; i++) {
            // 获取数组中对应的属性
            Field field = fields[i];

            String fieldName = field.getName();
            String stringLetter = fieldName.substring(0, 1).toUpperCase();

            // 获得相应属性的getXXX和setXXX方法名称
            String getName = "get" + stringLetter + fieldName.substring(1);
            String setName = "set" + stringLetter + fieldName.substring(1);

            // 获取相应的方法
            Method getMethod = classType.getMethod(getName, new Class[] {});
            Method setMethod = classType.getMethod(setName, new Class[] { field
                    .getType() });

            // 调用源对象的getXXX（）方法
            Object value = getMethod.invoke(obj, new Object[] {});
            System.out.println(fieldName + " :" + value);

            // 调用拷贝对象的setXXX（）方法
            setMethod.invoke(objectCopy, new Object[] { value });
        }
        return objectCopy;
    }

    public static void main(String[] args) throws IllegalArgumentException,
            SecurityException, InstantiationException, IllegalAccessException,
            InvocationTargetException, NoSuchMethodException {
        Customer customer = new Customer();
        customer.setName("hejianjie");
        customer.setId(new Long(1234));
        customer.setAge(19);

        Customer customer2 = null;
        customer2 = (Customer) new ReflectTester().copy(customer);
        System.out.println(customer.getName() + " " + customer2.getAge() + " "
                + customer2.getId());

        System.out.println(customer);
        System.out.println(customer2);
    }
}

class Customer {
    private Long id;
    private String name;
    private int age;

    public Customer() {
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Sample2:

import java.lang.reflect.Array;

public class ArrayTester1 {
   
    public static void main(String[] args) throws ClassNotFoundException {
        Class classType = Class.forName("java.lang.String");
        Object array = Array.newInstance(classType, 10); // 指定数组的类型和大小

        // 对索引为5的位置进行赋值
        Array.set(array, 5, "hello");
        String s = (String) Array.get(array, 5);
        System.out.println(s);

        // 循环遍历这个动态数组
        for (int i = 0; i < ((String[]) array).length; i++) {
            String str = (String) Array.get(array, i);
            System.out.println(str);
        }
    }
}

Note:
  getMethod只返回用public修饰的方法，包括自定义的、实现的接口的方法、继承的父类的方法按以下顺序查找：class -> superclass -> interface (in the declared order)getDeclaredMethod返回自定义的方法，不包括从父类继承的方法.
  getField与getDeclaredField、getConstructor与getDeclaredConstructor的区别与这个差不多不过getField按以下顺序查找：class -> interface (in the declared order) -> superclass

比如定义如下class
public class ClassA{
    private int field0=100;
}
ClassA应该保存了field0的默认值100，但是无论Class或者Field类的API都未提供如何拿到这个默认值的方法。
为这个变量写一个SET方法通过方法反射进行赋值

public Object setFileMethodInvoke(Object obj,String fieldName,Object value) throws Exception{   
        //获得对象的类型   
        Class classType=obj.getClass();   
        System.out.println("该对象的类型是："+classType.toString());   

        //通过默认构造方法去创建一个新的对象，getConstructor的视其参数决定调用哪个构造方法   
        Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});   

        //获得对象的所有属性   
        Field[] fields=classType.getDeclaredFields();   
        Field field=classType.getDeclaredField(fieldName);  
        String stringLetter=fieldName.substring(0, 1).toUpperCase();   

        //获得相应属性的getXXX和setXXX方法名称   
        String getName="get"+stringLetter+fieldName.substring(1);   
        String setName="set"+stringLetter+fieldName.substring(1); 
        System.out.println("aaaaaaa::::"+setName+"::"+value);

        //获取相应的方法   
        Method getMethod=classType.getMethod(getName, new Class[]{});   
        Method setMethod=classType.getMethod(setName, new Class[]{field.getType()});   
        System.out.println("aaaaaaa::::"+setMethod+":::"+value);

        //调用源对象的getXXX（）方法   
        Object value=getMethod.invoke(obj, new Object[]{});   
        System.out.println(fieldName+" :"+value);   

        //调用拷贝对象的setXXX（）方法  
        setMethod.invoke(obj,new Object[]{value});    
        return obj;   
    }

Class a=ClassA.class;
Object o=a.newInstance(); //不这样如何获得初值
Field f=a.getDeclaredField("field0");
f.setAccessible(true);
System.out.print(f.get(o));