JAVA语言中的反射机制:
    在Java 运行时 环境中,对于任意一个类,能否知道这个类有哪些属性和方法?
    对于任意一个对象,能否调用他的方法?这些答案是肯定的,这种动态获取类的信息,以及动态调用类的方法的功能来源于JAVA的反射。从而使java具有动态语言的特性。
  JAVA反射机制主要提供了以下功能:
      1.在运行时判断任意一个对象所属的类
      2.在运行时构造任意一个类的对象
      3.在运行时判断任意一个类所具有的成员变量和方法(通过反射甚至可以调用private方法)
      4.在运行时调用任意一个对象的方法(*****注意:前提都是在运行时,而不是在编译时)
  Java 反射相关的API简介:
      位于java.lang.reflect包中
        --Class类:代表一个类
        --Filed类:代表类的成员变量
        --Method类:代表类的方法
        --Constructor类:代表类的构造方法
java的这种反射机制能让编程人员动态的获取一个对象所属的类以及类的成员函数和变量,也能动态创建类的对象和调用对象的方法。
比如我们可以写一个公共的类模块,每个类都会用到它,但是我不用写死类参数和一些调用的方法,只需要传入一个object对象参数,然后获取所属对象、成员变量和方法,再做一些列的操作。

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

public class ReflectionTest {
public Object copy(Object obj) throws IllegalArgumentException,
SecurityException, InstantiationException, IllegalAccessException,
InvocationTargetException, NoSuchMethodException {
System.out.println("============begin copy ===========");
//获取对象的类型
Class classType = obj.getClass();
System.out.println("classType is :" + classType.getName());
//通过默认构造方法去创建一个新的对象,getConstructor的视其参数决定调用哪个构造方法   
Object objCopy = 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();
System.out.println("field name is:" + fieldName);
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(objCopy, new Object[]{value});
}
System.out.println("============end copy ===========");
return objCopy;
}

public static void main(String[] args) {
try {
Person person = new Person();
person.setAge(19);
person.setName("hello");
System.out.println("person==> "+person.getName() + " " + person.getAge());
Person person1 = null;
person1 = (Person) new ReflectionTest().copy(person);
System.out.println("person1==> "+person1.getName()+" :"+person1.getAge());
/*
* 用另外一个类测试反射类
* 不用修改反射类,只需修改传入的参数,就能达到想要的效果
*/
Car car = new Car();
car.setName("BMW");
car.setWheel(4);
System.out.println("car==>"+car.getName()+" :"+car.getWheel());
Car car1 = null;
car1 = (Car) new ReflectionTest().copy(car);
System.out.println("car1==>"+car1.getName()+" :"+car1.getWheel());
} catch (Exception e) {
e.printStackTrace();
}
}
}

class Person {
private String name;
private int age;
public Person(){
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the age
*/
public int getAge() {
return age;
}
/**
* @param age the age to set
*/
public void setAge(int age) {
this.age = age;
}
}

class Car{
private String name;
private int wheel;
public Car(){
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the wheel
*/
public int getWheel() {
return wheel;
}
/**
* @param wheel the wheel to set
*/
public void setWheel(int wheel) {
this.wheel = wheel;
}
}