1. 反射的基本概念
Java的反射（reflection）机制是在运行状态中对于任意一个类，都能够知道这个类的所有属性和方法，反射允许对成员变量、成员方法、构造方法的信息进行编程式访问。这种动态获取信 息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。
反射允许对成员变量，成员方法和构造方法的信息进心编程式访问。
可以获取的信息具体包括：
- 成员变量：修饰符、名称、类型，获取值/赋值
- 构造方法：修饰符、名称、形参，创建对象
- 成员方法：修饰符、名称、形参、返回值、抛出的异常、注解，运行方法
1.1 如何理解反射？
举个例子：
把一个类看作一个密封的盒子，这个盒子里面有成员变量、构造方法、成员方法这几样东西，把反射看作是一个人，这个人可以把这几样东西拿取出来给程序猿用。
1.2 反射的基本信息
Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new Student()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实 信息。而通过使用反射程序就能判断出该对象和类属于哪些类。
1.3 反射机制的起源
Class代表类的实体，在运行的Java应用程序中表示类和接口 。Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为 一个对象，这个对象就是java.lang.Class 。这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类 。
- Class类中的相关方法：
- 获取类相关的方法：
- 获取类中属性的相关方法：
- 获取类中注解的相关方法：
- 获取类中构造方法的相关方法：
- 获取类中成员方法的相关方法：
2. 获取Class对象的三种方法
- Class.forName(“全类名”)
- 类名.class
- 对象.getClass()
创建一个Student类
public class Student {
private int age;
private String name;
public Student(){
}
public Student(int age) {
this.age = age;
}
private Student(int age,String name) {
this.age = age;
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
private String eat (String food) {
System.out.println("正在吃" + food);
return "吃完" + food+"好开心";
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
2.1 Class.forName(“全类名”)
public class Reflection {
public static void main(String[] args) throws ClassNotFoundException {
// 获取指定类的Class文件对象
Class test1 = Class.forName("Student");
System.out.println("test1:"+test1);
}
}
运行结果：
2.2 类名.class
public class Reflection {
public static void main(String[] args) throws ClassNotFoundException {
// 或者直接使用类的class属性获取Class对象
Class test2 = Student.class;
System.out.println("test2:"+test2);
}
}
运行结果：
2.3 对象.getClass()
public class Reflection {
public static void main(String[] args) throws ClassNotFoundException {
// 获取当前对象的Class对象
Student student = new Student();
Class test3 = student.getClass();
System.out.println("test3:"+test3);
}
}
运行结果：
3. 获取构造方法
获取构造方法主要用到Constructor类，
- 获取public构造方法
- 获取所有构造方法
- 获取单个public构造方法
- 获取单个非public修饰的构造方法
Constructor类中用于创建对象的方法newInstance()：根据指定的构造方法创建对象
setAccessible()：设置为true取消非public构造方法的访问检查，否则无法创建对象。
3.1 获取所有public构造方法
public class Reflection2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//使用反射获取类的Class对象
Class test = Class.forName("Student");
// 获取反射对象的所有public构造方法
Constructor cons[] = test.getConstructors();
for (Constructor coni: cons) {
System.out.println(coni);
}
}
}
运行结果：
3.2 获取所有构造方法
import java.lang.reflect.Constructor;
public class Reflection5 {
public static void main(String[] args) throws ClassNotFoundException {
Class test = Class.forName("Student");
Constructor cons[] = test.getDeclaredConstructors();
for (Constructor con :cons) {
System.out.println(con);
}
}
}
运行结果：
3.3 获取单个public修饰的构造方法
import java.lang.reflect.Constructor;
public class Reflection6 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
Class test = Class.forName("Student");
Constructor con = test.getConstructor();
System.out.println(con);
}
}
运行结果：
3.3.1 获取方法的权限修饰符
这里用一个固定的整型数字表示权限修饰符
import java.lang.reflect.Constructor;
public class Reflection6 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
Class test = Class.forName("Student");
Constructor con = test.getConstructor();
int num = con.getModifiers();
System.out.println(num);
}
}
3.4 获取单个非public修饰的构造方法
import java.lang.reflect.Constructor;
public class Reflection8 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException {
Class test = Class.forName("Student");
Constructor con = test.getDeclaredConstructor(int.class,String.class);
System.out.println(con);
}
}
运行结果：
3.4.1 获取方法的权限修饰符
这里用一个固定的整型数字表示权限修饰符
import java.lang.reflect.Constructor;
public class Reflection6 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
Class test = Class.forName("Student");
Constructor con = test.getConstructor();
int num = con.getModifiers();
System.out.println(num);
}
}
运行结果：
3.4.2 获取方法的所有参数
import java.lang.reflect.Constructor;
import java.lang.reflect.Parameter;
public class Reflection6 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
Class test = Class.forName("Student");
Constructor con = test.getDeclaredConstructor(int.class, String.class);
Parameter p[] = con.getParameters();
for (Parameter pa : p) {
System.out.println(pa);
}
}
}
运行结果：
3.5 根据指定的构造方法创建对象
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Reflection9 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException, InvocationTargetException,
InstantiationException, IllegalAccessException {
Class test = Class.forName("Student");
Constructor con = test.getDeclaredConstructor(int.class, String.class);
con.setAccessible(true);//设置访问权限
Student stu = (Student) con.newInstance(20, "张三");
System.out.println(stu);
}
}
运行结果：
4. 获取成员变量
获取成员变量主要是通过Field类：
- 获取所有public修饰的成员变量
- 获取所有成员变量
- 获取单个public修饰的成员变量
- 获取单个非public修饰的成员变量
Field类中用于创建对象的方法：
- set()：赋值
- get()：获取值
新建一个Student2类
public class Student2 {
private int age;
private String name;
public int id;
public int getAge() {
return age;
}
public Student2(int age,String name, int id){
this.age = age;
this.name = name;
this.id = id;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String sleep(int hours) {
return "sleeping for"+hours+"hours";
}
private String eat(String food) {
return "eating " + food;
}
@Override
public String toString() {
return "Student2{" +
"age=" + age +
", name='" + name + '\'' +
", id=" + id +
'}';
}
}
4.1 获取所有public修饰的成员变量
import java.lang.reflect.Field;
public class Reflection10 {
public static void main(String[] args) throws ClassNotFoundException {
Class test = Class.forName("Student2");
Field f[] = test.getFields();
for (Field field : f) {
System.out.println(field);
}
}
}
运行结果：
4.2 获取所有成员变量
import java.lang.reflect.Field;
public class Reflection10 {
public static void main(String[] args) throws ClassNotFoundException {
Class test = Class.forName("Student2");
Field f[] = test.getDeclaredFields();
for (Field field : f) {
System.out.println(field);
}
}
}
运行结果：
4.3 获取单个public修饰的成员变量
import java.lang.reflect.Field;
public class Reflection10 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchFieldException {
Class test = Class.forName("Student2");
Field f = test.getField("id");
System.out.println(f);
}
}
运行结果：
4.4 获取单个非public修饰的成员变量
import java.lang.reflect.Field;
public class Reflection10 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchFieldException {
Class test = Class.forName("Student2");
Field f = test.getDeclaredField("age");
System.out.println(f);
}
}
运行结果：
4.4.1 获取成员变量的修饰符
import java.lang.reflect.Field;
public class Reflection10 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchFieldException {
Class test = Class.forName("Student2");
Field f = test.getDeclaredField("age");
int modifiers = f.getModifiers();
System.out.println(modifiers);
}
}
运行结果：
4.4.2 获取成员变量的名字
import java.lang.reflect.Field;
public class Reflection10 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchFieldException {
Class test = Class.forName("Student2");
Field f = test.getDeclaredField("age");
String n = f.getName();
System.out.println(n);
}
}
运行结果：
4.4.3 获取成员变量的数据类型
import java.lang.reflect.Field;
public class Reflection10 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchFieldException {
Class test = Class.forName("Student2");
Field f = test.getDeclaredField("age");
Object o = f.getType();
System.out.println(o);
}
}
运行结果：
4.4.4 获取成员变量记录的值
import java.lang.reflect.Field;
public class Reflection10 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchFieldException, IllegalAccessException {
Class test = Class.forName("Student2");
Field f = test.getDeclaredField("age");
Student2 s = new Student2(20,"张三",001);
f.setAccessible(true);
Object value = f.get(s);
System.out.println(value);
}
}
运行结果：
4.4.4 修改成员变量记录的值
import java.lang.reflect.Field;
public class Reflection10 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchFieldException, IllegalAccessException {
Class test = Class.forName("Student2");
Field f = test.getDeclaredField("age");
Student2 s = new Student2(20,"张三",001);
f.setAccessible(true);
f.set(s,108);
Object value = f.get(s);
System.out.println(value);
}
}
修改之后的结果：
5. 获取成员方法
通过Method类获取成员方法
- 获取所有public修饰的成员方法，包括继承的
- 获取所有成员方法，不包括继承的
- 获取单个public修饰的成员方法
- 获取单个非public修饰的方法
Method类中用于运行成员方法的方法：
invoke()：运行成员方法
5.1 获取所有public修饰的成员方法，包括继承的
import java.lang.reflect.Method;
public class Reflection11 {
public static void main(String[] args) throws ClassNotFoundException {
Class test = Class.forName("Student2");
Method m[] = test.getMethods();
for (Method method:m) {
System.out.println(method);
}
}
}
运行结果：
5.2 获取所有成员方法，不包括继承的
import java.lang.reflect.Method;
public class Reflection11 {
public static void main(String[] args) throws ClassNotFoundException {
Class test = Class.forName("Student2");
Method m[] = test.getDeclaredMethods();
for (Method method:m) {
System.out.println(method);
}
}
}
运行结果：
5.3 获取单个public修饰的成员方法
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;
public class Reflection11 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException {
Class test = Class.forName("Student2");
//通过 方法名+参数类型 获取指定成员方法
Method m = test.getMethod("sleep",int.class);
System.out.println(m);
}
}
运行结果：
5.4 获取单个非public修饰的成员方法
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;
public class Reflection11 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException {
Class test = Class.forName("Student2");
//通过 方法名+参数类型 获取指定成员方法
Method m = test.getDeclaredMethod("eat",String.class);
System.out.println(m);
}
}
运行结果：
5.4.1 获取成员方法的修饰符
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;
public class Reflection11 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException {
Class test = Class.forName("Student2");
//通过 方法名+参数类型 获取指定成员方法
Method m = test.getDeclaredMethod("eat",String.class);
int n = m.getModifiers();
System.out.println(n);
}
}
运行结果：
5.4.2 获取成员方法的名字
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;
public class Reflection11 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException {
Class test = Class.forName("Student2");
//通过 方法名+参数类型 获取指定成员方法
Method m = test.getDeclaredMethod("eat",String.class);
String n = m.getName();
System.out.println(n);
}
}
运行结果：
5.4.3 获取成员方法的参数
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
public class Reflection11 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException {
Class test = Class.forName("Student2");
//通过 方法名+参数类型 获取指定成员方法
Method m = test.getDeclaredMethod("eat",String.class);
Parameter p[] = m.getParameters();
for (Parameter par:p) {
System.out.println(par);
}
}
}
运行结果：
5.4.4 获取成员方法抛出的异常
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
public class Reflection11 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException {
Class test = Class.forName("Student2");
//通过 方法名+参数类型 获取指定成员方法
Method m = test.getDeclaredMethod("eat",String.class);
Class exception[] = m.getExceptionTypes();
for (Class exc:exception) {
System.out.println(exc);
}
}
}
运行方法：
5.5 运行成员方法
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
public class Reflection11 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Class test = Class.forName("Student2");
//通过 方法名+参数类型 获取指定成员方法
Method m = test.getDeclaredMethod("eat",String.class);
Student2 s = new Student2(20,"zhangsan",100);
m.setAccessible(true);
// s:方法的调用者，apple：向被调用方法传入的参数
Object o = m.invoke(s,"apple");
System.out.println(o);
}
}
运行结果：
6. 反射的用途
- 在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统 应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。
- 反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无 论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的
就是类的信息，spring根据这些信息，需要创建哪些Bean，spring就动态的创建这些类。
7. 反射的优点和缺点
- 优点：
- 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法
- 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
- 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。
- 缺点：
- 使用反射会有效率问题。会导致程序性能降低。
- 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。
23万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
