反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性，这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。一直以来反射技术都是Java中的闪亮点，这也是目前大部分框架(如Spring/Mybatis等)得以实现的支柱。在Java中，Class类与java.lang.reflect类库一起对反射技术进行了全力的支持。在反射包中，我们常用的类主要有：
- Constructor类：表示Class 对象所表示的类的构造方法，利用它可在运行时动态创建对象；
- Field类：表示Class对象所表示的类的成员变量，通过它可以在运行时动态修改成员变量的属性值(包含private)；
- Method类：表示Class对象所表示的类的成员方法，通过它可以动态调用对象的方法(包含private)。
Constructor类及其用法
Constructor类存在于反射包(java.lang.reflect)中，反映的是Class 对象所表示的类的构造方法。获取Constructor对象是通过Class类中的方法获取的，Class类与Constructor相关的主要方法如下：
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| static Class<?> | forName(String className) | 返回与带有给定字符串名的类或接口相关联的 Class 对象 |
| Constructor<T> | getConstructor(Class<?>... parameterTypes) | 返回指定参数类型、具有public访问权限的构造函数对象 |
| Constructor<?>[] | getConstructors() | 返回所有具有public访问权限的构造函数的Constructor对象数组 |
| Constructor<T> | getDeclaredConstructor(Class<?>... parameterTypes) | 返回指定参数类型、所有声明的（包括private）构造函数对象 |
| Constructor<?>[] | getDeclaredConstructor() | 返回所有声明的（包括private）构造函数对象 |
| T | newInstance() | 创建此 Class 对象所表示的类的一个新实例 |
示例：
package reflect;
import java.io.Serializable;
import java.lang.reflect.Constructor;
/**
* Created by zejian on 2017/5/1.
* Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
public class ReflectDemo implements Serializable{
public static void main(String[] args) throws Exception {
Class<?> clazz = null;
//获取Class对象的引用
clazz = Class.forName("reflect.User");
//第一种方法，实例化默认构造方法，User必须无参构造函数,否则将抛异常
User user = (User) clazz.newInstance();
user.setAge(20);
user.setName("Rollen");
System.out.println(user);
System.out.println("--------------------------------------------");
//获取带String参数的public构造函数
Constructor cs1 =clazz.getConstructor(String.class);
//创建User
User user1= (User) cs1.newInstance("xiaolong");
user1.setAge(22);
System.out.println("user1:"+user1.toString());
System.out.println("--------------------------------------------");
//取得指定带int和String参数构造函数,该方法是私有构造private
Constructor cs2=clazz.getDeclaredConstructor(int.class,String.class);
//由于是private必须设置可访问
cs2.setAccessible(true);
//创建user对象
User user2= (User) cs2.newInstance(25,"lidakang");
System.out.println("user2:"+user2.toString());
System.out.println("--------------------------------------------");
//获取所有构造包含private
Constructor<?> cons[] = clazz.getDeclaredConstructors();
// 查看每个构造方法需要的参数
for (int i = 0; i < cons.length; i++) {
//获取构造函数参数类型
Class<?> clazzs[] = cons[i].getParameterTypes();
System.out.println("构造函数["+i+"]:"+cons[i].toString() );
System.out.print("参数类型["+i+"]:(");
for (int j = 0; j < clazzs.length; j++) {
if (j == clazzs.length - 1)
System.out.print(clazzs[j].getName());
else
System.out.print(clazzs[j].getName() + ",");
}
System.out.println(")");
}
}
}
class User {
private int age;
private String name;
public User() {
super();
}
public User(String name) {
super();
this.name = name;
}
/**
* 私有构造
* @param age
* @param name
*/
private User(int age, String name) {
super();
this.age = age;
this.name = name;
}
//..........省略set 和 get方法
}输出：
User [age=20, name=Rollen]
--------------------------------------------
user1:User [age=22, name=xiaolong]
--------------------------------------------
user2:User [age=25, name=lidakang]
--------------------------------------------
构造函数[0]:private reflect.User(int,java.lang.String)
参数类型[0]:(int,java.lang.String)
构造函数[1]:public reflect.User(java.lang.String)
参数类型[1]:(java.lang.String)
构造函数[2]:public reflect.User()
参数类型[2]:()这样就可以实现动态创建对象了。关于Constructor类本身一些常用方法如下(仅部分)：
| 方法返回值 | 方法名称 | 方法说明 |
| Class<T> | getDeclaringClass() | 返回 Class 对象，该对象表示声明由此 Constructor 对象表示的构造方法的类,其实就是返回真实类型（不包含参数） |
| Type[] | getGenericParameterTypes() | 按照声明顺序返回一组 Type 对象，返回的就是 Constructor对象构造函数的形参类型。 |
| String | getName() | 以字符串形式返回此构造方法的名称。 |
| Class<?>[] | getParameterTypes() | 按照声明顺序返回一组 Class 对象，即返回Constructor 对象所表示构造方法的形参类型 |
| T | newInstance(Object... initargs) | 使用此 Constructor对象表示的构造函数来创建新实例 |
| String | toGenericString() | 返回描述此 Constructor 的字符串，其中包括类型参数。 |
示例：
Constructor cs3=clazz.getDeclaredConstructor(int.class,String.class);
System.out.println("-----getDeclaringClass-----");
Class uclazz=cs3.getDeclaringClass();
//Constructor对象表示的构造方法的类
System.out.println("构造方法的类:"+uclazz.getName());
System.out.println("-----getGenericParameterTypes-----");
//对象表示此 Constructor 对象所表示的方法的形参类型
Type[] tps=cs3.getGenericParameterTypes();
for (Type tp:tps) {
System.out.println("参数名称tp:"+tp);
}
System.out.println("-----getParameterTypes-----");
//获取构造函数参数类型
Class<?> clazzs[] = cs3.getParameterTypes();
for (Class claz:clazzs) {
System.out.println("参数名称:"+claz.getName());
}
System.out.println("-----getName-----");
//以字符串形式返回此构造方法的名称
System.out.println("getName:"+cs3.getName());
System.out.println("-----getoGenericString-----");
//返回描述此 Constructor 的字符串，其中包括类型参数。
System.out.println("getoGenericString():"+cs3.toGenericString());
/**
输出结果:
-----getDeclaringClass-----
构造方法的类:reflect.User
-----getGenericParameterTypes-----
参数名称tp:int
参数名称tp:class java.lang.String
-----getParameterTypes-----
参数名称:int
参数名称:java.lang.String
-----getName-----
getName:reflect.User
-----getoGenericString-----
getoGenericString():private reflect.User(int,java.lang.String)
*/其中关于Type类型这里简单说明一下，Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。getGenericParameterTypes 与 getParameterTypes 都是获取构成函数的参数类型，前者返回的是Type类型，后者返回的是Class类型，由于Type顶级接口，Class也实现了该接口，因此Class类是Type的子类，Type 表示的全部类型而每个Class对象表示一个具体类型的实例，如String.class仅代表String类型。由此看来Type与 Class 表示类型几乎是相同的，只不过 Type表示的范围比Class要广得多。当然Type还有其他子类，如：
- TypeVariable：表示类型参数，可以有上界，比如：T extends Number
- ParameterizedType：表示参数化的类型，有原始类型和具体的类型参数，比如：List<String>
- WildcardType：表示通配符类型，比如：?, ? extends Number, ? super Integer
通过以上的分析，对于Constructor类已有比较清晰的理解，利用好Class类和Constructor类，我们可以在运行时动态创建任意对象，从而突破必须在编译期知道确切类型的障碍。
Field类及其用法
Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。同样的道理，我们可以通过Class类的提供的方法来获取代表字段信息的Field对象，Class类与Field对象相关方法如下：
| 方法返回值 | 方法名称 | 方法说明 |
| Field | getDeclaredField(String name) | 获取指定name名称的(包含private修饰的)字段，不包括继承的字段 |
| Field[] | getDeclaredField() | 获取Class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段 |
| Field | getField(String name) | 获取指定name名称、具有public修饰的字段，包含继承字段 |
| Field[] | getField() | 获取修饰符为public的字段，包含继承字段 |
/**
* Created by zejian on 2017/5/1.
* Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
public class ReflectField {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class<?> clazz = Class.forName("reflect.Student");
//获取指定字段名称的Field类,注意字段修饰符必须为public而且存在该字段,
// 否则抛NoSuchFieldException
Field field = clazz.getField("age");
System.out.println("field:"+field);
//获取所有修饰符为public的字段,包含父类字段,注意修饰符为public才会获取
Field fields[] = clazz.getFields();
for (Field f:fields) {
System.out.println("f:"+f.getDeclaringClass());
}
System.out.println("================getDeclaredFields====================");
//获取当前类所字段(包含private字段),注意不包含父类的字段
Field fields2[] = clazz.getDeclaredFields();
for (Field f:fields2) {
System.out.println("f2:"+f.getDeclaringClass());
}
//获取指定字段名称的Field类,可以是任意修饰符的自动,注意不包含父类的字段
Field field2 = clazz.getDeclaredField("desc");
System.out.println("field2:"+field2);
}
/**
输出结果:
field:public int reflect.Person.age
f:public java.lang.String reflect.Student.desc
f:public int reflect.Person.age
f:public java.lang.String reflect.Person.name
================getDeclaredFields====================
f2:public java.lang.String reflect.Student.desc
f2:private int reflect.Student.score
field2:public java.lang.String reflect.Student.desc
*/
}
class Person{
public int age;
public String name;
//省略set和get方法
}
class Student extends Person{
public String desc;
private int score;
//省略set和get方法
}
上述方法需要注意的是，如果我们不期望获取其父类的字段，则需使用Class类的getDeclaredField/getDeclaredFields方法来获取字段即可；倘若需要连带获取到父类的字段，那么请使用Class类的getField/getFields，但是也只能获取到public修饰的的字段，无法获取父类的私有字段。下面将通过Field类本身的方法对指定类属性赋值，代码演示如下：
//获取Class对象引用
Class<?> clazz = Class.forName("reflect.Student");
Student st= (Student) clazz.newInstance();
//获取父类public字段并赋值
Field ageField = clazz.getField("age");
ageField.set(st,18);
Field nameField = clazz.getField("name");
nameField.set(st,"Lily");
//只获取当前类的字段,不获取父类的字段
Field descField = clazz.getDeclaredField("desc");
descField.set(st,"I am student");
Field scoreField = clazz.getDeclaredField("score");
//设置可访问，score是private的
scoreField.setAccessible(true);
scoreField.set(st,88);
System.out.println(st.toString());
//输出结果：Student{age=18, name='Lily ,desc='I am student', score=88}
//获取字段值
System.out.println(scoreField.get(st));
// 88这样就完成动态修改对象属性值。关于Field类还有其他常用的方法如下：
| 方法返回值 | 方法名称 | 方法说明 |
| void | set(Object obj, Object value) | 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。 |
| Object | get(Object obj) | 返回指定对象上此 Field 表示的字段的值 |
| Class<?> | getType() | 返回一个 Class 对象，它标识了此Field 对象所表示字段的声明类型。 |
| boolean | isEnumConstant() | 如果此字段表示枚举类型的元素则返回 true；否则返回 false |
| String | toGenericString() | 返回一个描述此 Field（包括其一般类型）的字符串 |
| String | getName() | 返回此 Field 对象表示的字段的名称 |
| Class<?> | getDeclaringClass() | 返回表示类或接口的 Class 对象，该类或接口声明由此 Field 对象表示的字段 |
| void | setAccessible(boolean flag) | 将此对象的 accessible 标志设置为指示的布尔值,即设置其可访问性 |
上述方法可能是较为常用的，事实上在设置值的方法上，Field类还提供了专门针对基本数据类型的方法，如setInt()/getInt()、setBoolean()/getBoolean、setChar()/getChar()等等方法，这里就不全部列出了，需要时查API文档即可。需要特别注意的是被final关键字修饰的Field字段是安全的，在运行时可以接收任何修改，但最终其实际值是不会发生改变的。
Method类及其用法
Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息，所反映的方法可能是类方法或实例方法（包括抽象方法）。下面是Class类获取Method对象相关的方法：
| 方法返回值 | 方法名称 | 方法说明 |
| Method | getDeclaredMethod(String name, Class<?>... parameterTypes) | 返回一个指定参数的Method对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 |
| Method[] | getDeclaredMethod() | 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。 |
| Method | getMethod(String name, Class<?>... parameterTypes) | 返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。 |
| Method[] | getMethods() | 返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。 |
示例：
import java.lang.reflect.Method;
/**
* Created by zejian on 2017/5/1.
* Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
public class ReflectMethod {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
Class clazz = Class.forName("reflect.Circle");
//根据参数获取public的Method,包含继承自父类的方法
Method method = clazz.getMethod("draw",int.class,String.class);
System.out.println("method:"+method);
//获取所有public的方法:
Method[] methods =clazz.getMethods();
for (Method m:methods){
System.out.println("m::"+m);
}
System.out.println("=========================================");
//获取当前类的方法包含private,该方法无法获取继承自父类的method
Method method1 = clazz.getDeclaredMethod("drawCircle");
System.out.println("method1::"+method1);
//获取当前类的所有方法包含private,该方法无法获取继承自父类的method
Method[] methods1=clazz.getDeclaredMethods();
for (Method m:methods1){
System.out.println("m1::"+m);
}
}
/**
输出结果:
method:public void reflect.Shape.draw(int,java.lang.String)
m::public int reflect.Circle.getAllCount()
m::public void reflect.Shape.draw()
m::public void reflect.Shape.draw(int,java.lang.String)
m::public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
m::public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
m::public final void java.lang.Object.wait() throws java.lang.InterruptedException
m::public boolean java.lang.Object.equals(java.lang.Object)
m::public java.lang.String java.lang.Object.toString()
m::public native int java.lang.Object.hashCode()
m::public final native java.lang.Class java.lang.Object.getClass()
m::public final native void java.lang.Object.notify()
m::public final native void java.lang.Object.notifyAll()
=========================================
method1::private void reflect.Circle.drawCircle()
m1::public int reflect.Circle.getAllCount()
m1::private void reflect.Circle.drawCircle()
*/
}
class Shape {
public void draw(){
System.out.println("draw");
}
public void draw(int count , String name){
System.out.println("draw "+ name +",count="+count);
}
}
class Circle extends Shape{
private void drawCircle(){
System.out.println("drawCircle");
}
public int getAllCount(){
return 100;
}
}同Field类一样，如果我们不期望获取其父类的方法，则需使用Class类的getDeclaredMethod/getDeclaredMethods方法来获取字段即可；倘若需要连带获取到父类的方法，那么请使用Class类的getMethod/getMethods，但是也只能获取到public修饰的的字段，无法获取父类的私有字段。下面将Method对象调用指定类的方法，代码演示如下：
Class clazz = Class.forName("reflect.Circle");
//创建对象
Circle circle = (Circle) clazz.newInstance();
//获取指定参数的方法对象Method
Method method = clazz.getMethod("draw",int.class,String.class);
//通过Method对象的invoke(Object obj,Object... args)方法调用
method.invoke(circle,15,"圈圈");
//对私有无参方法的操作
Method method1 = clazz.getDeclaredMethod("drawCircle");
//修改私有方法的访问标识
method1.setAccessible(true);
method1.invoke(circle);
//对有返回值得方法操作
Method method2 =clazz.getDeclaredMethod("getAllCount");
Integer count = (Integer) method2.invoke(circle);
System.out.println("count:"+count);
/**
输出结果:
draw 圈圈,count=15
drawCircle
count:100
*/这样就完成了类方法的动态调用。关于Method常用方法：
| 方法返回值 | 方法名称 | 方法说明 |
| Object | invoke(Object obj, Object... args) | 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。 |
| Class<?> | getReturnType() | 返回一个 Class 对象，该对象描述了此 Method 对象所表示的方法的正式返回类型,即方法的返回类型 |
| Type | getGenericReturnType() | 返回表示由此 Method 对象所表示方法的正式返回类型的 Type 对象，也是方法的返回类型。 |
| Class<?>[] | getParameterTypes() | 按照声明顺序返回 Class 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型。即返回方法的参数类型组成的数组 |
| Type[] | getGenericParameterTypes() | 按照声明顺序返回 Type 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型的，也是返回方法的参数类型 |
| String | getName() | 以 String 形式返回此 Method 对象表示的方法名称，即返回方法的名称 |
| boolean | isVarArgs() | 判断方法是否带可变参数，如果将此方法声明为带有可变数量的参数，则返回 true；否则，返回 false。 |
| String | toGenericString() | 返回描述此 Method 的字符串，包括类型参数。 |
getReturnType方法/getGenericReturnType方法都是获取Method对象表示的方法的返回类型，只不过前者返回的Class类型后者返回的Type(前面已分析过)，Type就是一个接口而已，在Java8中新增一个默认的方法实现，返回的就参数类型信息。
public interface Type {
//1.8新增
default String getTypeName() {
return toString();
}
}而getParameterTypes/getGenericParameterTypes也是同样的道理，都是获取Method对象所表示的方法的参数类型，其他方法与前面的Field和Constructor是类似的。
反射包中的Array类
在java.lang.reflect包中有着一个可以动态操作数组的类，Array，它提供了动态创建和访问 Java 数组的方法。Array 允许在执行 get 或 set 操作进行取值和赋值。在Class类中与数组关联的方法是：
| 方法返回值 | 方法名称 | 方法说明 |
| Class<?> | getComponentType() | 返回表示数组元素类型的 Class，即数组的类型 |
| boolean | isArray() | 判定此 Class 对象是否表示一个数组类。 |
java.lang.reflect.Array中的常用静态方法如下：
| 方法返回值 | 方法名称 | 方法说明 |
| static Object | set(Object array, int index) | 返回指定数组对象中索引组件的值。 |
| static int | getLength(Object array) | 以 int 形式返回指定数组对象的长度 |
| static object | newInstance(Class<?> componentType, int... dimensions) | 创建一个具有指定类型和维度的新数组。 |
| static Object | newInstance(Class<?> componentType, int length) | 创建一个具有指定的组件类型和长度的新数组。 |
| static void | set(Object array, int index, Object value) | 将指定数组对象中索引组件的值设置为指定的新值。 |
示例：
package reflect;
import java.lang.reflect.Array;
/**
* Created by zejian on 2017/5/1.
* Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
public class ReflectArray {
public static void main(String[] args) throws ClassNotFoundException {
int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//获取数组类型的Class 即int.class
Class<?> clazz = array.getClass().getComponentType();
//创建一个具有指定的组件类型和长度的新数组。
//第一个参数:数组的类型,第二个参数:数组的长度
Object newArr = Array.newInstance(clazz, 15);
//获取原数组的长度
int co = Array.getLength(array);
//赋值原数组到新数组
System.arraycopy(array, 0, newArr, 0, co);
for (int i:(int[]) newArr) {
System.out.print(i+",");
}
//创建了一个长度为10 的字符串数组，
//接着把索引位置为6 的元素设为"hello world!"，然后再读取索引位置为6 的元素的值
Class clazz2 = Class.forName("java.lang.String");
//创建一个长度为10的字符串数组，在Java中数组也可以作为Object对象
Object array2 = Array.newInstance(clazz2, 10);
//把字符串数组对象的索引位置为6的元素设置为"hello"
Array.set(array2, 6, "hello world!");
//获得字符串数组对象的索引位置为5的元素的值
String str = (String)Array.get(array2, 6);
System.out.println();
System.out.println(str);//hello
}
/**
输出结果:
1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,
hello world!
*/
}通过上述代码，我们可以利用Array类和反射相结合动态创建数组，也可以在运行时动态获取和设置数组中元素的值。其实除了上的set/get外Array还专门为8种基本数据类型提供特有的方法，如setInt/getInt...，其他依次类推即可。除了上述动态修改数组长度或者动态创建数组或动态获取值或设置值外，可以利用泛型动态创建泛型数组如下：
/**
* 接收一个泛型数组，然后创建一个长度与接收的数组长度一样的泛型数组，
* 并把接收的数组的元素复制到新创建的数组中，
* 最后找出新数组中的最小元素，并打印出来
* @param a
* @param <T>
*/
public <T extends Comparable<T>> void min(T[] a) {
//通过反射创建相同类型的数组
T[] b = (T[]) Array.newInstance(a.getClass().getComponentType(), a.length);
for (int i = 0; i < a.length; i++) {
b[i] = a[i];
}
T min = null;
boolean flag = true;
for (int i = 0; i < b.length; i++) {
if (flag) {
min = b[i];
flag = false;
}
if (b[i].compareTo(min) < 0) {
min = b[i];
}
}
System.out.println(min);
}毕竟我们无法直接创建泛型数组，有了Array的动态创建数组的方式这个问题也就迎刃而解了。
//无效语句，编译不通
T[] a = new T[];ok~，到这反射中几个重要并且常用的类我们都基本介绍完了，但更重要是，我们应该认识到反射机制并没有什么神奇之处。当通过反射与一个未知类型的对象打交道时，JVM只会简单地检查这个对象，判断该对象属于那种类型；同时也应该知道，在使用反射机制创建对象前，必须确保已加载了这个类的Class对象，当然这点完全不必由我们操作，毕竟只能JVM加载，但必须确保该类的”.class”文件已存在并且JVM能够正确找到。关于Class类的方法在前面我们只是分析了主要的一些方法，其实Class类的API方法挺多的，建议查看一下API文档，浏览一遍，有个印象也是不错的选择，这里仅列出前面没有介绍过又可能用到的API：
/**
* 修饰符、父类、实现的接口、注解相关
*/
//获取修饰符，返回值可通过Modifier类进行解读
public native int getModifiers();
//获取父类，如果为Object，父类为null
public native Class<? super T> getSuperclass();
//对于类，为自己声明实现的所有接口，对于接口，为直接扩展的接口，不包括通过父类间接继承来的
public native Class<?>[] getInterfaces();
//自己声明的注解
public Annotation[] getDeclaredAnnotations();
//所有的注解，包括继承得到的
public Annotation[] getAnnotations();
//获取或检查指定类型的注解，包括继承得到的
public <A extends Annotation> A getAnnotation(Class<A> annotationClass);
public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);
/**
* 内部类相关
*/
//获取所有的public的内部类和接口，包括从父类继承得到的
public Class<?>[] getClasses();
//获取自己声明的所有的内部类和接口
public Class<?>[] getDeclaredClasses();
//如果当前Class为内部类，获取声明该类的最外部的Class对象
public Class<?> getDeclaringClass();
//如果当前Class为内部类，获取直接包含该类的类
public Class<?> getEnclosingClass();
//如果当前Class为本地类或匿名内部类，返回包含它的方法
public Method getEnclosingMethod();
/**
* Class对象类型判断相关
*/
//是否是数组
public native boolean isArray();
//是否是基本类型
public native boolean isPrimitive();
//是否是接口
public native boolean isInterface();
//是否是枚举
public boolean isEnum();
//是否是注解
public boolean isAnnotation();
//是否是匿名内部类
public boolean isAnonymousClass();
//是否是成员类
public boolean isMemberClass();
//是否是本地类
public boolean isLocalClass();
最后，我们在谈一个问题：反射慢的原因？
- 反射的确会导致性能问题；
- 反射导致的性能问题是否严重跟使用的次数有关系，如果控制在100次以内，基本上没什么差别，如果调用次数超过了100次，性能差异会很明显；（主要是getMethod和getDeclaredField方法拖慢的速度）
- 四种访问方式，直接访问实例的方式效率最高；其次是直接调用方法的方式，耗时约为直接调用实例的1.4倍；接着是通过反射访问实例的方式，耗时约为直接访问实例的3.75倍；最慢的是通过反射访问方法的方式，耗时约为直接访问实例的6.2倍；
语言效率的损失不值一提，君不见那么多用PHP做电商的也没有抱怨过语言效率低过，就算是比PHP还慢的Python也照样有人用来写网站。Java牺牲执行效率提高程序员开发效率很正常。与直接使用相比，反射的效率应该是会低一些。但是从代码质量上来看的话，这些效率的差距不值一提。而且性能的瓶颈还不至于出现在这里。
参考：
扫一扫
325
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
