一、Java反射机制：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
二、反射机制常用类
- java.lang.Class;
- java.lang.reflect.Constructor;
- java.lang.reflect.Field;
- java.lang.reflect.Method;
- java.lang.reflect.Modifier;
三、Class类的使用
- 任何一个类都是java.lang.class的实例化对象，称为该类的类类型
- 1）三种表示方式
class foo{};
foo foo1=new foo();
A、 Class c1=foo.class;//任何一个类都有隐含的静态成员变量class
B、 Class c2=foo1.getClass();//可以通过对象的getClass方法获得
实例化
C、 Class c3=null; c3=Class.forName("com.lt.Foo")；
注：c1=c2 表明一个类只可能是class类的一个实例对象
2、创建类类型的实例化对象
Foo foo=(foo)c1.newInstance()；
四、通过反射获取类的名称和方法信息
- Class类的基本API操作
1、c.getName();//获取类的名称
2、c.getSimpleName();//不包含包名的类的名称
3、c.getMethods();//获取类的【所有方法】集合,【所有方法都是Method类的对象】
4、c.getDeclaredMethods();//获取的是所有该类【自己声明】的方法，【不问访问权限】
- Method类API操作
1、.getReturnType();//得到该方法的返回值类型的类类型（class），如int.class String.class
2、.getName();//得到方法的名称
3、.getParameterTypes();//获得参数列表类型的类类型，如参数为(int,int)则得到(int.class ,int class)
/***
* 打印类的信息,包括类的成员函数，成员变量
* @param obj 该对象所属的类的信息
*/
public static void printMethodMessage(Object obj) {
//获取类的信息，首先获取类的类类型
Class c = obj.getClass(); //传递的是哪个子类的对象, c就是该子类的类类型
System.out.println("类的名称是："+c.getName());
Method[] methods = c.getMethods();
for(Method m : methods) {
System.out.println("方法名："+m.getName());
System.out.println("返回值: " + m.getReturnType());
Class[] parameterTypes = m.getParameterTypes();
System.out.print("参数类型： ");
for(Class cc : parameterTypes){
System.out.print(cc.getName());
}
System.out.println();
System.out.println("--------------------------------");
}
}
- 调用： ClassUtil.printMethodMessage("hello");
五、获取成员变量信息
- 成员变量是java.lang.reflect.Field的对象
1、Field类封装了关于成员变量的操作
2、Field[] fs = c.getFields()方法获取所有public的成员变量Field[]信息
3、c.getDeclaredFields()获取的是该类自己声明的成员变量信息
4、field.getType()获得成员类型的类类型
5、field.getName()获得成员的名称
/***
* 打印成员变量信息
* @param obj
*/
public static void printFiledMessage(Object obj) {
//获取类的信息，首先获取类的类类型
Class c = obj.getClass(); //传递的是哪个子类的对象, c就是该子类的类类型
//获取public成员变量信息
// Field[] fields = c.getFields();
// 这个是获取自定义的所有成员变量信息 建议用这个
Field[] fields = c.getDeclaredFields();
for(Field f : fields){
System.out.println("变量类型: "+ f.getType()+"变量名："+f.getName());
}
}
调用：ClassUtil.printFiledMessage("hello");
六、获取类的构造方法信息
- 构造函数是java.lang.Constructor类的对象
1、通过Class.getConstructor()获得Constructor[]所有公有构造方法信息
2、建议getDeclaredConstructors()获取自己声明的构造方法
3、Constructor.getName()获取构造方法名称
4、Constructor.getParameterTypes()获取构造方法参数
/***
* 获取构造方法
* @param obj
*/
public static void printConstructMessage(Object obj) {
//获取类的信息，首先获取类的类类型
Class c = obj.getClass(); //传递的是哪个子类的对象, c就是该子类的类类型
//获取所有public构造方法
// Constructor[] cons = c.getConstructors();
//获取所有构造方法
Constructor[] cons = c.getDeclaredConstructors();
for (Constructor con : cons) {
System.out.print(con.getName()+"( ");
Parameter[] parameters = con.getParameters();
for (Parameter parameter : parameters) {
System.out.print(parameter.getParameterizedType()+ " ");
System.out.print(parameter.getName());
}
System.out.println( ")");
}
}
调用：ClassUtil.printConstructMessage("hello");
七、方法反射的基本操做
- 方法的反射：
1.获取A类中的print(int,int)方法：
①要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
A a1=new A();
Class c= a1.getClass();
②获取方法 由名称和参数列表来决定,getMethod获取的是public方法，getDelcaredMethod获取自己声明的方法
Method m =c.getMethod(methodName,paramtypes);//paramtypes可以用数组的形式表示new Class[]{int.class,int.class}，也可以直接列举类类型
2.方法的反射操作：是用m对象来进行方法调用，和a1.print(10,20)调用的方法相同m.invoke（a1，new Object[]｛10,20｝）
Object o=m.invoke(对象名,参数);//方法如果没有返回值返回null，如果有返回值返回具体值，参数可用数组的方式表示，也可以直接列举，没有参数就不写
package com.lt;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/***
* 通过反射的方式来调用 A 的方法
* @author liaot
*
*/
public class MethodReflect {
public static void main(String[] args) {
//创建A类的对象
A a1 = new A();
//获取a1的类类型
Class c1 = a1.getClass();
//通过反射的方式获取方法 第一个参数为方法名， 第二为参数列表
try {
//调用方法1
Method m1 = c1.getMethod("print", int.class);
m1.invoke(a1, 520);
//调用方法2
Method m2 = c1.getMethod("print", int.class, int.class);
m2.invoke(a1, 520, 1314);
} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
e.printStackTrace();
}
}
}
class A {
public void print(int a){
System.out.println("我有一个参数: "+ a);
}
public void print(int a, int b){
System.out.println("我有两个参数： " + a + " 和 "+ b);
}
}
八、通过反射了解集合泛型的本质
1：反射的操作都是编译之后的操作，即运行阶段
2：java中集合的泛型是防止输入错误；只在编译阶段有效，绕过编译则无效，集合的在编译之后是去泛型的
eg：
ArrayList list1=new ArrayList();
ArrayList list2=new ArrayList();
Class c1=list1.getClass();
Class c2=list2.getClass();
System.out.print(c1==c2);//true
Method m=c2.getMethod("add",Object.class);
m.invoke(list1, 20);//绕过编译操作就绕过了泛型
System.out.println(list1);//不能直接foreach list2集合的，会报类型转换错误