Reflection（反射）是Java被视为动态语言（动态语言：程序在运行时可以改变其结构：新的函数可以引进，已有的函数可以被删除等结构上的变化）的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的內部信息，并能直接操作任意对象的内部属性及方法。
一句话概括：反射就是把Java类中的各种成分映射成一个个的Java对象
简单画了个图，凑合看吧，自己的理解，如有大神希望多多指教
首先创建一个Student类，为了后面操作方便，在类里面分别创建了四种不同访问权限的构造函数，成员变量以及成员方法
package com.example.testdemo.classforname;
public class Student {
//构造方法
public Student() {
System.out.println("（公有）的构造器被执行了---------");
}
public Student(String name, int age) {
this.age = age;
this.name = name;
System.out.println("（公有带参）的构造器被执行了---------");
}
Student(String name) {
this.name = name;
System.out.println("（默认）的构造器被执行了---------");
}
private Student(int age) {
this.age = age;
System.out.println("（私有）的构造器被执行了---------");
}
protected Student(double grade) {
this.grade = grade;
System.out.println("（受保护）的构造器被执行了---------");
}
//成员变量
String name;
private int age;
public double grade;
public int classNumber;
protected String sex;
//成员函数
void method1(String name) {
System.out.println("（默认）的方法被执行了---------");
}
public void method2() {
System.out.println("（公有）的方法被执行了---------");
}
private void method3(double grade) {
System.out.println("（私有）的方法被执行了---------");
}
protected void method4(String sex) {
System.out.println("（受保护）的方法被执行了---------");
}
@Override
public String toString() {
return "[name:" + name + ",age:" + age + ",grade:" + grade + ",sex:" + sex + ",classNumber:" + classNumber + "]";
}
public static void main(String[] args) {
System.out.println("main方法被执行" + args.toString());
}
}
反射的使用在这里大致分为四个部分：
获取class对象
获取class对象有三种方式
package com.example.testdemo.classforname;
/**
* 获取class对象
*/
public class Test {
public static void main(String[] args) throws Exception {
//获取class文件的三种方法：
//1,根据对象获取class（无意义）已经有对象
Student student = new Student();
Class clazz = student.getClass();
//2,根据对象.class（无意义）一般需要导入类的相关包
clazz = Student.class;
//3，根据类名获取class（推荐使用）
clazz = Class.forName("com.example.testdemo.classforname.Student");
System.out.println(clazz);
//class对象获取实例对象
Object object= clazz.newInstance();
System.out.println(object);
}
}
获取构造函数
package com.example.testdemo.classforname;
import java.lang.reflect.Constructor;
/**
* 获取class对象的构造函数
*/
public class Test1 {
public static void main(String[] args) throws Exception {
//获取class对象
Class clazz = Class.forName("com.example.testdemo.classforname.Student");
//分为两组
//第一组：1,获取单个（公有）构造函数
System.out.println("获取单个（公有）构造函数---------");
Constructor constructor = clazz.getConstructor();
System.out.println(constructor);
constructor = clazz.getConstructor(String.class, int.class);//获取有参构造需要传入参数类型
System.out.println(constructor);
//第一组：2,获取单个（所有包括公有的，私有的，默认的，受保护的）构造函数
System.out.println("获取单个（所有包括公有的，私有的，默认的，受保护的）构造函数---------");
constructor = clazz.getDeclaredConstructor(String.class);//获取有参构造需要传入参数类型
System.out.println(constructor);
//根据不同构造器创建实例对象
Object obj = constructor.newInstance("张三");
System.out.println(obj);
//第二组：1，获取多个（公有）构造函数
System.out.println("获取多个（公有）构造函数---------");
Constructor[] constructors = clazz.getConstructors();
for (Constructor c : constructors) {
System.out.println(c);
}
//第二组：2,获取多个（所有包括公有的，私有的，默认的，受保护的）构造函数
System.out.println("获取多个（所有包括公有的，私有的，默认的，受保护的）构造函数---------");
constructors = clazz.getDeclaredConstructors();
for (Constructor c : constructors) {
System.out.println(c);
}
}
}
获取成员变量
package com.example.testdemo.classforname;
import java.lang.reflect.Field;
/**
* 获取class对象的成员变量
*/
public class Test2 {
public static void main(String[] args) throws Exception {
//获取class对象
Class clazz = Class.forName("com.example.testdemo.classforname.Student");
//分为两组
//第一组：1,获取单个（公有）成员变量
System.out.println("获取单个（公有）成员变量---------");
Field field = clazz.getField("grade");//需要传入成员变量名称
System.out.println(field);
//第一组：2,获取单个（所有包括公有的，私有的，默认的，受保护的）成员变量
System.out.println("获取单个（所有包括公有的，私有的，默认的，受保护的）成员变量---------");
field = clazz.getDeclaredField("age");//需要传入成员变量名称
System.out.println(field);
//获取私有属性并赋值
Object obj = clazz.newInstance();
//age是私有属性，需要暴力设置
field.setAccessible(true);
field.set(obj,15);
System.out.println(obj);
//第二组：1，获取多个（公有）成员变量
System.out.println("获取多个（公有）成员变量---------");
Field[] fields = clazz.getFields();
for (Field f : fields) {
System.out.println(f);
}
//第二组：2,获取多个（所有包括公有的，私有的，默认的，受保护的）成员变量
System.out.println("获取多个（所有包括公有的，私有的，默认的，受保护的）成员变量---------");
fields = clazz.getDeclaredFields();
for (Field f : fields) {
System.out.println(f);
}
}
}
获取成员方法
package com.example.testdemo.classforname;
import java.lang.reflect.Method;
/**
* 获取成员方法
*/
public class Test3 {
public static void main(String[] args) throws Exception {
//获取class对象
Class clazz = Class.forName("com.example.testdemo.classforname.Student");
//分为两组
//第一组：1,获取单个（公有）成员方法
System.out.println("获取单个（公有）成员方法---------");
Method m = clazz.getMethod("method2");//需要传入成员方法名称,有参数需要传入参数
System.out.println(m);
//第一组：2,获取单个（所有包括公有的，私有的，默认的，受保护的）成员方法
System.out.println("获取单个（所有包括公有的，私有的，默认的，受保护的）成员变量---------");
m = clazz.getDeclaredMethod("method3",double.class);//需要传入成员方法名称
System.out.println(m);
//获取方法后执行
Object obj = clazz.newInstance();
//method3是私有方法需要暴力设置
m.setAccessible(true);
m.invoke(obj,89.50);//传入方法需要的参数
//第二组：1，获取多个（公有）成员方法
System.out.println("获取多个（公有）成员方法--------");
Method[] methods = clazz.getMethods();
for (Method m1 : methods) {
System.out.println(m1);
}
//第二组：2,获取多个（所有包括公有的，私有的，默认的，受保护的）成员方法
System.out.println("获取多个（所有包括公有的，私有的，默认的，受保护的）成员方法---------");
methods = clazz.getDeclaredMethods();
for (Method m1 : methods) {
System.out.println(m1);
}
}
}
突发奇想能不能获取类中的main方法？不说了，直接上代码测试
package com.example.testdemo.classforname;
import java.lang.reflect.Method;
/**
* 获取class中的main方法
*/
public class Test4 {
public static void main(String[] args) throws Exception {
//获取class对象
Class clazz = Class.forName("com.example.testdemo.classforname.Student");
//main方法是公有方法
Method method = clazz.getMethod("main",String[].class);
//main方法没有对象（静态方法）,需要注意invoke传入的参数是object类型必须强转，不然出现异常
method.invoke(null,(Object) new String[]{"aaaaa"});
}
}
依然是可以拿到的，以前觉得反射没有什么用，除了在jdbc的时候使用，最近看了一些框架，基本都是反射，编程的路漫漫，我们一起走吧
