Java反射机制：反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动
Java反射机制：反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能。
获取类信息：
获取内容
方法签名
构造器
Constructor getConstructor(Class… parameterTypes)
包含的方法
Method getMethod(String name, Class… parameterTypes)
包含的属性
Field getField(String name)
包含的
Annotation A getAnnotation(Class annotationClass)
内部类
Class[] getDeclaredClasses()
外部类
Class getDeclaringClass()
所实现的接口
Class[] getInterfaces()
修饰符
int getModifiers()
所在包
Package getPackage()
类名
String getName()
简称
String getSimpleName()
判断类信息：
判断内容
方法签名
注解类型?
boolean isAnnotation()
使用了该Annotation修饰?
boolean isAnnotationPresent(Class annotationClass)
匿名类?
boolean isAnonymousClass()
数组?
boolean isArray()
枚举?
boolean isEnum()
原始类型?
boolean isPrimitive()
接口?
boolean isInterface()
obj是否是该Class的实例
boolean isInstance(Object obj)
1 获取该类对象对应类的修饰符、所在包、类名等基本信息
int getModifiers():返回此类或接口的所有修饰符，修饰符由public、protected、private、final、static、abstract等对应的常量组成，返回的整数应使用Modifier工具类的方法来解码，才可以获取真是的修饰符PUBLIC: 1,PRIVATE: 2,PROTECTED: 4,STATIC: 8,FINAL: 16,SYNCHRONIZED: 32,VOLATILE: 64,TRANSIENT: 128,NATIVE: 256,INTERFACE: 512,ABSTRACT: 1024,STRICT: 2048
Package getPackage():获取该类的包
String getName():以字符串形式返回此CLass对象所表示的类的简称
示例代码：
/** 获取类名
*/
public static String getClassAllName(Person person){
return person.getClass().getName();
}
/*
* 获取包名
*/
public static String getPackageName(Person person){
//System.out.println(person.getClass().getPackage().getName());
return person.getClass().getPackage().getName() ;
}
/*
* 获取修饰符
*/
public static String getModifiersName(Person person){
String str=null;
int modifier = person.getClass().getModifiers();
return
2 类成员方法的反射
Method getMethod(String name,Class<?>...parameterTypes):返回此class对象对应类的带指定形参的public方法Method[] getMethods():返回此class对象所表示的类的所有public方法
Method getDeclaredMethod(string name,Class<?>...parameterTypes):返回此class对象对应类的带指定形参的方法，与方法访问权限无关
Method[] getDeclaredMethods():返回此class对象对应类的全部方法，与方法的访问权限无关
示例代码：
/** 获取类的成员方法
* 一个成员方法就是一个method对象
* getMethod()所有的 public方法，包括父类继承的 public
* getDeclaredMethods()获取该类所有的方法，包括private ,但不包括继承的方法。
*/
public static ArrayList<String> getMethodInfo(Person person){
Class<? extends Person> p=person.getClass();
//System.out.println("类的名称："+p.getName());
Method[] methods=p.getMethods();//获取所有的 public方法，包括父类继承的 public
//Method[] methods=p.getDeclaredMethods();//获取该类所有的方法，包括private ,但不包括继承的方法。
ArrayList<String> methodList = new ArrayList<String>();
for(int i=0;i<methods.length;i++){
String str = "";
Class returnType = methods[i].getReturnType();
str+= returnType+" ";
//得到方法名：
str+=methods[i].getName()+"(";
Class[] parameterTypes=methods[i].getParameterTypes();
for(Class c:parameterTypes){
str+=c.getName()+",";
}
if(str.endsWith(",")){
str=str.substring(0,str.length()-1);
}
str+=")";
methodList.add(str);
}
return
3 成员变量的反射
Field getField(String name):返回此class对象对应类的指定名称的public成员变量Field[] getFields():返回此class对象对应类的所有public成员变量
Field getDeclaredField(String name):返回此class对象对应类的指定名称的成员变量，与成员变量访问权限无关
Field[] getDeclaredFields():返回此class对象对应类的全部成员变量，与成员变量的访问权限无关
示例代码：
/*** 获取类的成员变量
* getFileds()获取public
* getDeclaredFields()获取所有
* @return
public static ArrayList<String> getFiledInfo(Person person){
ArrayList<String> filedList = new ArrayList<String>();
Class c=person.getClass();
//Field[] fileds=c.getFields(); //getFileds()获取public
Field[] fileds=c.getDeclaredFields(); //getDeclaredFields()获取所有
for(Field field:fileds){
//获取成员变量的类型
Class filedType=field.getType();
String str = filedType.getName()+" "+field.getName();
filedList.add(str);
}
return
4 构造函数的反射
Connstructor<T> getConstructor(Class<?>...parameterTypes):返回此Class对象对应类的带指定形参的public构造器Constructor<?>[] getConstructors():返回此Class对象对应类的所有public构造器
Constructor<T>[] getDeclaredConstructor(Class<?>...parameterTypes):返回此class对象对应类的带指定参数的构造器，与构造器的访问权限无关
Constructor<?>[] getDeclaredConstructors():返回此class对象对应类的所有构造器，与构造器的访问权限无关
示例代码：
/** 获取类的构造方法
*/
public static ArrayList<String> getConstructorInfo(Person person){
ArrayList<String> constructorList = new ArrayList<String>();
Class c=person.getClass();
//Constructor[] constructors = c.getConstructors();
Constructor[] constructors = c.getDeclaredConstructors();
for(Constructor cons:constructors){
String str = cons.getName()+"(";
Class[] parameterType = cons.getParameterTypes();
for(Class para:parameterType){
str += para.getName()+",";
}
if(str.endsWith(",")){
str=str.substring(0,str.length()-1);
}
str+=")";
constructorList.add(str);
}
return
5 获取类的注解
<A extends Annotation>A getAnnotation(Class<A>annotationClass):尝试获取该class对象对应类上村子的指定类型的Annotation，如果该类型注解不存在，则返回null<A extends Annotation>A getDeclaredAnnotation(Class<A>annotationClass):这是Java 8中新增的，该方法获取直接修饰该class对象对应类的指定类型的Annotation，如果不存在，则返回null
Annotation[] getAnnotations():返回修饰该class对象对应类上存在的所有Annotation
Annotation[] getDeclaredAnnotations():返回修饰该Class对象对应类上存在的所有Annotation
<A extends Annotation>A[] getAnnotationByType(Class<A>annotationClass):该方法的功能与前面介绍的getAnnotation()方法基本相似，但由于Java8增加了重复注解功能，因此需要使用该方法获取修饰该类的指定类型的多个Annotation
<A extends Annotation>A[] getDeclaredAnnotationByType(Class<A>annotationClass):该方法发功能与前面介绍的getDeclaredAnnotations()方法相似，也是因为Java8的重复注解的功能，需要使用该方法获取直接修饰该类的指定类型的多个Annotation
示例代码：
/** 获取类的注解
*/
public static ArrayList<String> getAnnotationInfo(Person person){
ArrayList<String> annotationList = new ArrayList<String>();
Method[] methods = person.getClass().getMethods();
for(Method m:methods){
for (Annotation annotation:m.getAnnotations()) {
System.out.println(annotation + " in method:"+ m);
String str= annotation + " in method:"+ m;
annotationList.add(str);
}
}
return
6 获取类的内部类
Class<?>[] getDeclaredClasses():返回该class队形对应类里包含的全部内部类示例代码：
/*** 获取类的内部类
*/
public static ArrayList<String> getDeclaredClassInfo(Person person){
ArrayList<String> declaredList = new ArrayList<String>();
Class c=person.getClass();
Class[] declaredClass= c.getDeclaredClasses();
for(Class cl:declaredClass){
String declaredType=cl.getTypeName();
declaredList.add(declaredType);
}
return
7 获取类对象所在的外部类
Class<?> getDeclaringClass():返回该Class对象对应类所在的外部类示例代码：
/*** 获取类的外部类
*/
public static String getDeclaringClassInfo(Person person){
Class c=person.getClass();
Class declaringClass= c.getDeclaringClass();
if(declaringClass!=null){
return declaringClass.getName();
}
return null;
}
8 获取类对象对应类所实现的接口
Class<?>[] getInterfaces():返回该Class对象对应类所实现的全部接口示例代码：
/*** 获取类的实现接口
*/
public static ArrayList<String> getInterfacesInfo(Person person){
ArrayList<String> interfaceList = new ArrayList<String>();
Class c=person.getClass();
Class[] interClass= c.getInterfaces();
//Type[] genInterType = c.getGenericInterfaces();
//AnnotatedType[] annoInterType = c.getAnnotatedInterfaces();
for(Class cl:interClass){
String interType=cl.getTypeName();
interfaceList.add(interType);
}
return
9 获取该类对象对应类所继承的父类
Class<? super T> getSuperclass():返回该Class对象对应类的超类的Class对象示例代码：
/** 获取类的继承类
*/
public static String getSuperclassInfo(Person person){
Class c = person.getClass();
Class superClass = c.getSuperclass();
return
10 判断该类是否为接口、枚举、注解类型
boolean isAnnotation():返回此class对象是否表示一个注解类型boolean isAnnotationPresent(Class<? extends Annotation>annotationClass):判断此Class对象是否使用类Annotation修饰
boolean isAnonymousClass():返回此class对象是否是一个匿名类
boolean isArray():返回此class对象是否表示一个数组类
boolean isEnum():返回此class对象是否表示一个枚举
boolean isInterface():返回此class对象是否表示一个接口
boolean isInstance(Object obj):判断obj是否是此class对象的实例，该方法可以完全代替instanceof操作符
11 方法反射的操作
Person.java
public class Person{private static int testID;
private static String testName;
private boolean testSex;
//省略getter和setter方法
public int sumOfAge(int num1,int num2){
return
调用
public static void main(String[] args) throws ClassNotFoundException {Person person = new Person();
Class cl = person.getClass();
Method method = null;
try {
method = cl.getMethod("sumOfAge", new Class[]{int.class,int.class});
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
}
int sum = 0;
try {
sum =(int) method.invoke(person, 12,17);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
System.out.println(sum);
}