反射的历史由来 反射这一概念最早由编程开发人员Smith在1982年提出，主要指应用程序访问、检测、修改自身状态与行为的能力。这一概念的提出立刻吸引了编程界的极大关注，各种研究工作随之展开，随之而来引发编程革命，出现了多种支持反射机制的面向对象语言。
什么是反射？ Java 反射(Reflection任意任意任意一个方法和属性（包括私有的方法和属性 ）。这种 动态获取的信息以及动态调用对象的方法的功能**就称为 Java 语言的反射机制。
通俗点讲，通过反射，该类对我们来说是完全透明的，想要获取任何东西都可以。
Java 程序中对象的类型都是在编译期就确定下来的。但通过 Java 反射机制动态创建的对象，这个对象的类型在编译期是未知的。
反射的核心是 JVM 在 运行时java.lang.Class 类来实现的，在 Java 中，Object 类是所有类的根类，而 Class 类就是描述 Java 类的类。
注 ：Class 本身就是一个类，Class 就是这个类的名称，所以 Object 也包括 Class 类。
反射的主要功能
在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用 private 方法 ）；
在运行时调用任意一个对象的方法；
修改构造函数、方法、属性的可见性。
反射的主要用途 反射最重要的用途就是开发各种通用框架 。很多框架（比如 Spring）都是配置化的（比如通过 XML 文件配置 JavaBean、Action 之类的），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类（运行时动态加载），调用不同的方法，这个时候就必须用到反射。对与框架开发人员来说，反射虽小但作用非常大，它是各种容器实现的核心。
反射的优势
提高灵活性和扩展性，降低耦合性，提高自适应能力
允许程序创建和控制任何类的对象，无需硬编码目标类
反射的使用 反射机制中会用到一些类，在了解反射是如何使用之前，先介绍一下这些类。
类
说明
Object
Java 中所有类的超类
Class
在反射中表示内存中的一个 Java 类，Class 可以代表的实例类型包括，类和接口、基本数据类型、数组
Constructor
封装了类的构造函数的属性信息，包括访问权限和动态调用信息
Field
提供类或接口的成员变量属性信息，包括访问权限和动态修改
Method
提供类或接口的方法属性信息，包括访问权限和动态调用信息
Modifier
封装了修饰属性，public、protected、static、final、synchronized、abstract 等
声明一个接口和一个简单的具体类作为示例代码：
声明一个接口：
1 2 3 public interface IAddress { void address () ; }
具体的类，请关注各个方法的修饰属性:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 public class Person implements IAddress { private int age; public String name; public Person () {} public Person (int age, String name) { this .age = age; this .name = name; } public int getAge () {return age;} public void setAge (int age) {this .age = age;} public String getName () {return name;} public void setName (String name) {this .name = name;} public Person setData (int age, String name) { this .age = age; this .name = name; return this ; } @Override public void address () {System.out.println("I am from China." );} @Override public String toString () {return "Person [age=" + age + ", name=" + name + "]" ;} }
获取Class对象 想要使用反射机制，就必须要先获取到该类的字节码文件对象（.class 文件对象），通过字节码文件对象，能够获取想要的所有信息（方法，属性，类名，父类名，实现的所有接口等等）。每一个类对应一个字节码文件，也就对应着一个 Class 类型的对象，也就是字节码文件对象。
反射的各种功能都需要通过 Class 对象来实现，因此，需要知道如何获取 Class对象，主要有以下几种方式：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class Test { public static void main (String[] args) throws ClassNotFoundException { Person person = new Person (); Class<? extends Person > clazz1 = person.getClass(); Class<Person> clazz2 = Person.class; Class<?> clazz3 = Class.forName("com.zhaolq.mars.demo.a.Person" ); System.out.println(clazz1.equals(clazz2)); System.out.println(clazz2.equals(clazz3)); System.out.println(clazz1.equals(clazz3)); } }
判断是否为某个类的实例 一般地，可以使用 instanceof 关键字来判断是否为某个类的实例。同时也可以借助反射中 Class 对象的 isInstance() 方法来判断是否为某个类的实例，它是一个 Native 方法：
1 2 3 4 5 6 7 8 9 10 11 public class Test { public static void main (String[] args) { Person person = new Person (); if (person instanceof Person) { System.out.println("111111" ); } if (Person.class.isInstance(person)) { System.out.println("222222" ); } } }
获取父类和接口列表 1 2 3 4 5 6 7 8 9 10 11 12 13 public class Test { public static void main (String[] args) throws ClassNotFoundException { Class clazz = Person.class; Class superClazz = clazz.getSuperclass(); System.out.println(superClazz.getName()); Class[] interfaces = clazz.getInterfaces(); for (Class clz : interfaces) { System.out.println(clz.getName()); } } }
创建实例 通过反射来生成对象主要有两种方式：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class Test { public static void main (String[] args) throws Exception { Class<?> clazz1 = Person.class; Object obj1 = clazz1.newInstance(); ((Person) obj1).setData(16 , "Shelly" ); System.out.println(obj1); Class<?> clazz2 = Person.class; Constructor<?> constructor = clazz2.getConstructor(int .class, String.class); Object obj2 = constructor.newInstance(18 , "Shirley" ); System.out.println(obj2); } }
获取方法 获取某个 Class 对象的方法集合，主要有以下几个方法：
Method getMethod(String name, Class<?>... parameterTypes)：Method[] getMethods()：Method getDeclaredMethod(String name, Class<?>... parameterTypes)：Method[] getDeclaredMethods()：Method getEnclosingMethod()：
代码示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 public class Test { public static void main (String[] args) throws Exception { Class<?> clazz = Person.class; System.out.println("指定的public方法：" ); Method method = clazz.getMethod("toString" ); System.out.println(Modifier.toString(method.getModifiers()) + " " + method.getReturnType() + " " + method.getName()); System.out.println(); System.out.println("全部的public方法：" ); Method[] methods = clazz.getMethods(); for (Method method2 : methods) { System.out.println(Modifier.toString(method2.getModifiers()) + " " + method2.getReturnType() + " " + method2.getName()); } System.out.println(); System.out.println("指定自身声明的方法，包括private：" ); Method declaredMethod = clazz.getDeclaredMethod("address" ); System.out.println(Modifier.toString(declaredMethod.getModifiers()) + " " + declaredMethod.getReturnType() + " " + declaredMethod.getName()); System.out.println(); System.out.println("类自身声明的全部的方法，包括private：" ); Method[] declaredMethods = clazz.getDeclaredMethods(); for (Method declaredMethod2 : declaredMethods) { System.out.println(Modifier.toString(declaredMethod2.getModifiers()) + " " + declaredMethod2.getReturnType() + " " + declaredMethod2.getName()); } } }
输出：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 指定的public方法： public class java.lang.String toString 全部的public方法： public class java.lang.String toString public class java.lang.String getName public void setName public void address public int getAge public void setAge public class com.zhaolq.mars.demo.a.Person setData public final native void wait public final void wait public final void wait public boolean equals public native int hashCode public final native class java.lang.Class getClass public final native void notify public final native void notifyAll 指定自身声明的方法，包括private： public void address 类自身声明的全部的方法，包括private： public class java.lang.String toString public class java.lang.String getName public void setName public void address public int getAge public void setAge public class com.zhaolq.mars.demo.a.Person setData
获取构造方法 获取某个 Class 对象的构造方法，主要有以下几个方法：
Constructor<T> getConstructor(Class<?>... parameterTypes)：参数是parameterTypes 的public的构造函数。 parameterTypes 参数是一个Class对象数组，这些对象按声明的顺序标识构造函数的形参类型。Constructor<?>[] getConstructors()：Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：参数是parameterTypes 的，并且是类自身声明的构造函数，包含public、protected和private。Constructor<?>[] getDeclaredConstructors()：Constructor<?> getEnclosingConstructor()：getEnclosingConstructor() 就是这个类所在的构造函数，若不存在，返回null。没懂…
代码示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 public class Test { public static void main (String[] args) throws Exception { Class<?> cls1 = Test.class; System.out.println("指定的public构造函数：" ); Class[] classArr = {String.class, Integer.class}; Constructor constructor1 = cls1.getConstructor(classArr); System.out.println(constructor1); System.out.println(); System.out.println("全部的public构造函数：" ); Constructor[] constructor2 = cls1.getConstructors(); for (int i = 0 ; i < constructor2.length; i++) { System.out.println(constructor2[i].toGenericString()); } System.out.println(); System.out.println("指定的自身声明的构造函数，包括private：" ); Constructor constructor3 = cls1.getDeclaredConstructor(String.class, Integer.class); System.out.println(constructor3); System.out.println(); System.out.println("类自身声明的全部的构造函数，包括private：" ); Constructor[] constructor4 = cls1.getDeclaredConstructors(); for (int i = 0 ; i < constructor4.length; i++) { System.out.println(constructor4[i].toGenericString()); } System.out.println(); System.out.println("获取一个内部类的构造函数" ); Constructor constructor5 = String.class.getEnclosingConstructor(); System.out.println(constructor5); } public Test () {} public Test (String str, Integer i) {} protected Test (String str, String i) {} private Test (String str, Boolean i) {} }
输出：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 指定的public构造函数： public com.zhaolq.mars.demo.a.Test(java.lang.String,java.lang.Integer) 全部的public构造函数： public com.zhaolq.mars.demo.a.Test() public com.zhaolq.mars.demo.a.Test(java.lang.String,java.lang.Integer) 指定的自身声明的构造函数，包括private： public com.zhaolq.mars.demo.a.Test(java.lang.String,java.lang.Integer) 类自身声明的全部的构造函数，包括private： protected com.zhaolq.mars.demo.a.Test(java.lang.String,java.lang.String) private com.zhaolq.mars.demo.a.Test(java.lang.String,java.lang.Boolean) public com.zhaolq.mars.demo.a.Test() public com.zhaolq.mars.demo.a.Test(java.lang.String,java.lang.Integer) 获取一个内部类的构造函数 null
获取成员变量 获取某个 Class 对象的成员变量，主要有以下几个方法：
Field getField(String name)：名称是name 的public的成员变量(包括从基类继承的, 从接口实现的所有public成员变量)。Field[] getFields()：Field getDeclaredField(String name)：名称是name，并且是类自身声明的成员变量，包含public、protected和private成员变量。Field[] getDeclaredFields()：
获取其他常用信息 Class 类提供了大量的实例方法来获取该 Class 对象所对应的详细信息，Class 类大致包含如下方法，其中每个方法都包含多个重载版本，因此我们只是做简单的介绍，详细请参考 JDK 文档。
获取类内信息
构造器: Constructor<T> getConstructor(Class<?>... parameterTypes)
包含的方法: Method getMethod(String name, Class<?>... parameterTypes)
包含的属性: Field getField(String name)
包含的Annotation: <A extends Annotation> A getAnnotation(Class<A> annotationClass)
内部类: Class<?>[] getDeclaredClasses()
外部类: Class<?> getDeclaringClass()
所实现的接口: Class<?>[] getInterfaces()
修饰符: int getModifiers()
所在包: Package getPackage()
类名: String getName()
简称: String getSimpleName()
判断类本身信息的方法
是否注解类型: boolean isAnnotation()
是否使用了该Annotation修饰: boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
是否匿名类: boolean isAnonymousClass()
是否数组: boolean isArray()
是否枚举: boolean isEnum()
是否接口: boolean isInterface()
obj 是否是该 Class 的实例: boolean isInstance(Object obj) ，此方法是Java语言 instanceof 运算符的动态等价物
public boolean isLocalClass() // 类是不是本地类。本地类，就是定义在方法内部的类。public boolean isMemberClass() // 当且仅当基础类是成员类时才返回truepublic native boolean isPrimitive() // 类是不是“基本类型”，包括void和8个基本类型public boolean isSynthetic() // 如果此类是合成类，则返回true；否则返回false。
使用反射获取泛型信息 为了通过反射操作泛型以迎合实际开发的需要，Java 新增了 java.lang.reflect.ParameterizedType、java.lang.reflect.GenericArrayType、java.lang.reflect.TypeVariable、java.lang.reflect.WildcardType 几种类型来代表不能归一到 Class 类型但是又和原始类型同样重要的类型。
ParameterizedType: 一种参数化类型，比如CollectionGenericArrayType: 一种元素类型是参数化类型或者类型变量的数组类型TypeVariable: 各种类型变量的公共接口WildcardType: 一种通配符类型表达式，如?、? extends Number、? super Integer
其他 1 2 3 4 5 6 7 8 9 10 11 12 public <A extends Annotation > A getAnnotation (Class<A> annotationClass) {public Annotation[] getAnnotations()public <A extends Annotation > A[] getAnnotationsByType(Class<A> annotationClass)public <A extends Annotation > A getDeclaredAnnotation (Class<A> annotationClass) public Annotation[] getDeclaredAnnotations()public <A extends Annotation > A[] getDeclaredAnnotationsByType(Class<A> annotationClass)Map<Class<? extends Annotation >, Annotation> getDeclaredAnnotationMap()
调用方法 当我们从类中获取了一个方法后，我们就可以用 invoke() 方法来调用这个方法。invoke() 方法的原型为：
1 public Object invoke (Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
代码示例：
1 2 3 4 5 6 7 8 9 10 11 12 public class Test { public static void main (String[] args) throws Exception { Class<?> clazz = Person.class; Object obj = clazz.getDeclaredConstructor().newInstance(); Method method = clazz.getMethod("setDate" , int .class, String.class); Object result = method.invoke(obj, 16 , "Shelly" ); System.out.println(result); } }
创建数组 数组在 Java 里是比较特殊的一种类型，它可以赋值给一个 Object Reference。下面我们看一看利用反射创建数组的例子：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Test { public static void main (String[] args) throws Exception { Class<?> clazz = Class.forName("java.lang.String" ); Object array = Array.newInstance(clazz, 10 ); Array.set(array, 0 , "Hello" ); Array.set(array, 1 , "Java" ); Array.set(array, 2 , "Kotlin" ); Array.set(array, 3 , "Android" ); System.out.println(Array.get(array, 3 )); } }
其中的 Array 类为 java.lang.reflect.Array 类。我们通过 Array.newInstance() 创建数组对象，而 newArray 方法是一个 native 方法，它的原型是：
1 2 3 4 5 6 public static Object newInstance (Class<?> componentType, int length) throws NegativeArraySizeException { return newArray(componentType, length); } private static native Object newArray (Class<?> componentType, int length) throws NegativeArraySizeException;
反射的一些注意事项 由于反射会额外消耗一定的系统资源，因此如果不需要动态地创建一个对象，那么就不需要用反射。
另外，反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。
小结 反射作用：
java反射机制可以获取类名、类的对象、类的属性、方法、继承关系、Annotation注解等信息
优点：
提高Java程序的灵活性和扩展性，降低稠合性，提高自适应能力
允许程序创建和控制任何类的对象，无需硬编码目标类
缺点：
对性能有影响。使用反射是一种解释操作，需要动态访问JVM以满足需求。
一般来说，此类访问操作慢于直接执行java代码。若无必要的情况下，不建议基于反射特性进行编码。
小测 1、 Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描述，哪些是错误的? (多选)
A、Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
B、通过反射可以动态的实现一个接口，形成一个新的类, 并可以用这个类创建对象, 调用对象方法
C、通过反射, 可以突破Java语言提供的对象成员, 类成员的保护机制, 访问一般方式不能访问的成员
D、Java反射机制提供了字节码修改的技术, 可以动态的修剪一个类
解释
1、Class类在java.lang下
2、这是java的动态代理特性
3、反射可以更改类的访问限制；private、protect等关键字是编译期的定义
4、反射可以新增类，但不能修改本身存在的类的字节码
5、通过反射可以调用私有方法
答案：AD
