1、概念：反射就是把Java类中的各种成分映射成相应的java类。
2、功能：（1）在运行时判断任意一个对象所属的类。
（2）在运行时构造任意一个类的对象。
（3）在运行时判断任意一个类所具有的成员变量和方法。（4）在运行时调用任意一个对象的方法。通过反射甚至可以调用到private的方
法。
（5）生成动态代理。
3、Java反射所需要的类主要有：java.lang.Class类和java.lang.reflect包中的
Field、Constructor、Method、Array类。
4、Class类：
（1）Class类封装一个对象或接口运行时的状态。
（2）JVM：(Java Virtual Machine)是java 虚拟机，JVM为每种类型管理着一个独
一无二的Class对象。
（3）Java的基本类型（boolean 、byte、char 、short、int、long、float和和
关键字void也都对应一个Class对象。
（4）获取Class对象方式有3种：
<1>调用Object类的gerClass()方法来得到Class对象。MyObject x = new MyObject();
Class c1 = x.getClass();
<2>使用Class类的forName()静态方法获得与字符串对应的Class对象。
Class c2 = Class.forName("java.lang.String");
<3>使用“类型名.class”获取该类型对应的Class对象。
Class cl1 = Manager.class;
Class cl2 = int.class;
Class cl3 = double[].class;
5、获取类信息的代码：
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;import java.lang.reflect.Method;
import java.lang.reflect.Modifier;public class Test2 {
public static void main(String[] args) {
try {
Class clazz = Class.forName("java.util.ArrayList");//获取class对应的对象
System.out.println(clazz.getName());
String packageName = clazz.getPackage().getName();
System.out.println(packageName);
int mod = clazz.getModifiers();
String modifiersName = Modifier.toString(mod);
System.out.println(modifiersName);
String className = clazz.getName();
System.out.println(className);
Class superClazz = clazz.getSuperclass();
System.out.println(superClazz.getName());
Class[] interfaces = clazz.getInterfaces();
for(Class a:interfaces){
System.out.println(a.getName());
}
Field[] fields = clazz.getDeclaredFields();
for(Field field:fields){
String modifier = Modifier.toString(field.getModifiers());
Class type = field.getType();
String name = field.getName();
if(type.isArray()){//isArray判断是不是数组类
String arrType = type.getComponentType().getName()+"[]";
System.out.println(" "+modifier+" "+arrType+" "+";");
}else{
System.out.println(" "+modifier+" "+type.getName()+" "+";");
}
}
Constructor[] constructors = clazz.getDeclaredConstructors();
for(Constructor constructor:constructors){
String name = constructor.getName();
String modifier = Modifier.toString(constructor.getModifiers());
System.out.println(" "+modifier+" "+name+"(");
Class[] paramTypes = constructor.getParameterTypes();
for(int i = 0;i<paramTypes.length;i++){
if(i>0){
System.out.println(",");
}
if(paramTypes[i].isArray()){
System.out.println(paramTypes[i].getComponentType().getName()+"[]");
}else{
System.out.println(paramTypes[i].getName());
}
}
System.out.println(")");
}
System.out.println("****************************************");
Method[] methods = clazz.getDeclaredMethods();
for(Method method:methods){
String modifier = Modifier.toString(method.getModifiers());
Class returnType = method.getReturnType();
if(returnType.isArray()){
String arrType = returnType.getComponentType().getName()+"[]";
System.out.println(" "+modifier+" "+arrType+" "+method.getName()+"(");
}else{
System.out.println(" "+modifier+" "+returnType.getName()+" "+method.getName()+"(");
}
Class[] paramTypes = method.getParameterTypes();
for(int i=0; i<paramTypes.length;i++){
if(i>0){
System.out.println(",");
}
if(paramTypes[i].isArray()){
System.out.println(paramTypes[i].getComponentType().getName()+"[]");
}else{
System.out.println(paramTypes[i].getName());
}
}
System.out.println(");");
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
1、创建对象：
（1）使用无参构造方法：
Class c = Class.forName("java.util.ArrayList");
LIst list = (List)c.newInstance();
（2）使用反射机制调用无参构造方法创建指定名称类的对象：
import java.util.Date;
public class NoArgCITest {
public static void main(String[] args) {
try {
Date currentDate = (Date)newInstance("java.util.Date");//获取Class对象
System.out.println(currentDate);
} catch (Exception e) {
e.printStackTrace();
}
}
private static Date newInstance(String string) {
Object obj = null;
try {
obj = Class.forName(string).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
（3）使用带参数的构造方法：3个步骤：
<1>获取指定类对应的Class对象
<2>通过Class对象获取满足指定参数类型要求的Constructor对象
<3>调用指定Constructor对象的newInstance方法，传入对应的参数值，创建对象。
（4）通过java.util.Data类的带参构造方法来创建对象。import java.lang.reflect.Constructor;
import java.util.Date;public class ArgCITest {
public static void main(String[] args) {
Class clazz;
try {
clazz = Class.forName("java.util.Date");
Constructor constructor = clazz.getConstructor(long.class);
Date d = (Date) constructor.newInstance(1234L);
System.out.println(d);
} catch (Exception e) {
e.printStackTrace();
}
}
}
2、<1>调用方法：使用反射可以获取指定类的指定方法的对象代表即java.lang.reflect.Method类的实
例。invoke方法动态调用该方法。
public Object invoke(Object obj,Object ...args);
<2>第一个参数是一个对象，表示要在该对象上调用这个方法；第二个参数是一个可变参数，用来给这个方法传递参数值。
<3>要调用某个私有方法可以在这个私有对应的Method对象上先调用setAccessible(true)来取消Java语言对本方法的访问检查，然后再调用invoke方法来真正执行这个私有方法。
<4>通过反射来动态调用指定的方法：import java.lang.reflect.Method;
public class RIMTest {
public static void main(String[] args) throws Exception{
Class clazz = Class.forName("com.second.Product");//生成Class对象
Product pd = (Product) clazz.newInstance();//创建Product类的对象
Method method1 = clazz.getDeclaredMethod("setName", String.class);//调用public方法，有参数
Object returnValue = method1.invoke(pd, "爪哇");
System.out.println(returnValue);
Method method2 = clazz.getDeclaredMethod("display");//调用private方法，无参数
method2.setAccessible(true);
Object returnValue1 = method2.invoke(pd);
}
}
class Product{
private static long count = 0;//私有类成员变量
private long id ;
private String name ="无名氏";
public Product(){//构造方法
System.out.println("默认的构造方法");
id=++count;
}
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;
System.out.println("调用setName的方法");
System.out.println(name);
}
private void display(){
System.out.println(getClass().getName()+"[id="+id+"name="+name+"]");
}
}
3、访问成员变量的值
import java.lang.reflect.*;
public class RFTest {
public static void main(String[] args) throws Exception{
Class clazz = Class.forName("com.second.Product");
Product pd = (Product) clazz.newInstance();
Field idField = clazz.getDeclaredField("id");
idField.setAccessible(true);
idField.setLong(pd, 100);
System.out.println(idField.getLong(pd));
Field nameField = clazz.getDeclaredField("id");
nameField.setAccessible(true);
nameField.set(pd, "李四");
System.out.println(idField.get(pd));
}
}
4、JavaBean中的setXXX和getXXX方法：
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class IntroSRTest {
public static void main(String[] args) throws Exception{
ReflectPoint pt = new ReflectPoint(3,7);
String propertyName = "x";
PropertyDescriptor pd = getXXX(pt, propertyName);
int a =10;
setXXX(pt, propertyName, a);
}
private static void setXXX(ReflectPoint pt, String propertyName, int a)
throws IntrospectionException, IllegalAccessException,
InvocationTargetException {
PropertyDescriptor pd1 = new PropertyDescriptor(propertyName,pt.getClass());
Method methodSetX = pd1.getWriteMethod();
methodSetX.invoke(pt, a);
}
private static PropertyDescriptor getXXX(ReflectPoint pt,
String propertyName) throws IntrospectionException,
IllegalAccessException, InvocationTargetException {
PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt.getClass());
Method methodGetX = pd.getReadMethod();
Object returnValue = methodGetX.invoke(pt);
System.out.println(returnValue);
return pd;
}
}
