目录
一、什么是反射：
1）Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。
2）Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。
二、反射的原理：
下图是类的正常加载过程、反射原理与class对象：
Class对象的由来是将.class文件读入内存，并为之创建一个Class对象。
三、反射的优缺点
优点：
在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。
缺点：
（1）反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；
（2）反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。
四、反射的用途：
1、反编译：.class-->.java
2、通过反射机制访问java对象的属性，方法，构造方法等
3、当我们在使用IDE,比如Ecplise时，当我们输入一个对象或者类，并想调用他的属性和方法是，一按点号，编译器就会自动列出他的属性或者方法，这里就是用到反射。
4、反射最重要的用途就是开发各种通用框架。比如很多框架（Spring）都是配置化的（比如通过XML文件配置Bean），为了保证框架的通用性，他们可能需要根据配置文件加载不同的类或者对象，调用不同的方法，这个时候就必须使用到反射了，运行时动态加载需要的加载的对象。
5、例如，在使用Strut2框架的开发过程中，我们一般会在struts.xml里去配置Action，比如
<action name="login" class="org.ScZyhSoft.test.action.SimpleLoginAction" method="execute">
<result>/shop/shop-index.jsp</result>
<result name="error">login.jsp</result>
</action>
比如我们请求login.action时，那么StrutsPrepareAndExecuteFilter就会去解析struts.xml文件，从action中查找出name为login的Action，并根据class属性创建SimpleLoginAction实例，并用Invoke方法来调用execute方法，这个过程离不开反射。配置文件与Action建立了一种映射关系，当View层发出请求时，请求会被StrutsPrepareAndExecuteFilter拦截，然后StrutsPrepareAndExecuteFilter会去动态地创建Action实例。
比如，加载数据库驱动的，用到的也是反射。
Class.forName("com.mysql.jdbc.Driver"); // 动态加载mysql驱动五、反射机制常用的类：
Java.lang.Class;
Java.lang.reflect.Constructor;
Java.lang.reflect.Field;
Java.lang.reflect.Method;
Java.lang.reflect.Modifier;
六、反射的基本使用：
1.获得Class：主要有三种方法：
（1） 对象名.getClass()
（2） 类名.class
（3）Class.forName(类的完整路径字符串);
public static void main(String[] args) {
//第一种方式获取Class对象
Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
Class stuClass = stu1.getClass();//获取Class对象
System.out.println(stuClass.getName());
//第二种方式获取Class对象
Class stuClass2 = Student.class;
System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
//第三种方式获取Class对象
try {
Class stuClass3 = Class.forName("Demo.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}注意，在运行期间，一个类，只有一个Class对象产生，所以打印结果都是true；
三种方式中，常用第三种，第一种对象都有了还要反射干什么，第二种需要导入类包，依赖太强，不导包就抛编译错误。一般都使用第三种，一个字符串可以传入也可以写在配置文件中等多种方法。
Class类常用的方法：
getConstrutors()—— 获得类的public类型的构造方法
getConstrutor(Class[] args)—— 获得类的特定构造方法
newInstance()—— 通过类的无参构造方法创建对象
getFields()—— 获得类的public类型的属性。
getDeclaredFields()—— 获得类的所有属性
getField(String name)—— 获得类的指定属性
getMethods()—— 获得类的public类型的方法
getMethod (String name,Class [] args)—— 获得类的指定方法
getName()—— 获得类的完整名字
getPackage()—— 获取此类所属的包
getSuperclass()—— 获得此类的父类对应的Class对象
2.创建实例：通过反射来生成对象主要有两种方法：
1）通过Class的newInstance()方法
- 该方法要求该Class对象的对应类有无参构造方法
- 执行newInstance()实际上就是执行无参构造方法来创建该类的实例
Class cls = String.class;
Object str = cls.newInstance();2）通过Constructor的newInstance()方法
- 先使用Class对象获取指定的Constructor对象
- 再调用Constructor对象的newInstance()创建Class对象对应类的对象
- 通过该方法可选择使用指定构造方法来创建对象
//获取String的Class对象
Class cls= String.class;
//通过Class对象获取指定的Constructor构造器对象
Constructor constructor=cls.getConstructor(String.class);
//根据构造器创建实例：
Object obj = constructor.newInstance(“空”);3.通过反射获取构造方法并使用：
1）批量获取的方法：
public Constructor[] getConstructors()：所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
2）单个获取的方法，并调用：
public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
3） 调用构造方法：
Constructor-->newInstance(Object... initargs)
newInstance是 Constructor类的方法（管理构造函数的类）
api的解释为：newInstance(Object... initargs) ，使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象，并为之调用。
例如：
Example1类：
public class Example1{
// 无参构造方法
public Example1() {}
// 有一个参数的构造方法
public Example1(int a) {
System.out.println(a);
}
// 有多个参数的构造方法
public Example1(int a,double b) {
System.out.println(a+b);
}
// 私有构造方法
private Example1(String s) {
System.out.printf( "Example类的有参构造:s=%s \n", s);
}
// 受保护的构造方法
protected Example1(float f) {
System.out.printf("Example类的有参构造:f=%f\n", f);
}
}测试类：
public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Class cls = Example1.class;
System.out.println("所有构造方法:");
// 获取所有public公有的构造方法
Constructor[] construct = cls.getConstructors();
for (Constructor constructor : construct) {
System.out.println(constructor);
}
System.out.println();
System.out.println();
System.out.println();
System.out.println("所有定义构造方法:");
// 获取所有定义的构造方法
Constructor[] constructors = cls.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
System.out.println();
System.out.println();
System.out.println();
// 获取一个私有的构造方法
Constructor constr = cls.getDeclaredConstructor(String.class);
// 调用私有的构造方法
constr.setAccessible(true);
Example1 example = (Example1)constr.newInstance("空");
System.out.println(example);
}控制台打印：
所有共有构造方法:
public com.apesource.demo.Example1(int,double)
public com.apesource.demo.Example1(int)
public com.apesource.demo.Example1()
所有定义构造方法:
protected com.apesource.demo.Example1(float)
private com.apesource.demo.Example1(java.lang.String)
public com.apesource.demo.Example1(int,double)
public com.apesource.demo.Example1(int)
public com.apesource.demo.Example1()
调用了私有构造方法:
Example类的有参构造:s=空
com.apesource.demo.Example1@232204a14.获取成员变量并调用：
1）批量获取的方法：
public field[] getfield()：所有"公有的"构造方法
public field[] getDeclaredfields()：获取所有的构造方法(包括私有、受保护、默认、公有)
2）单个获取的方法，并调用：
public field getfield (Class... parameterTypes):获取单个的"公有的"构造方法：
public field getDeclaredfield r(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
例如：
Book类：
class Book{
public String bookName;
public int stock;
private double sale;
private boolean isShelf;
}测试类：
public static void main(String[] args) throws InstantiationException, NoSuchFieldException, IllegalAccessException{
Class<Book> cls = Book.class;
// 所有的public的成员变量(包含父类)
System.out.println("---------所有公共---------");
Field[] pufields = cls.getFields();
for (Field field : pufields) {
System.out.println("成员变量类型"+field.getName());
System.out.println("成员变量名称"+field.getType());
System.out.println("成员变量访问修饰符"+field.getModifiers());
System.out.println("成员变量访问修饰符"+Modifier.toString(field.getModifiers()));
System.out.println();
}
System.out.println("-------------子类自定义-------------");
// 所有的定义过的的成员变量(仅包含子类自己)
Field[] allfields = cls.getDeclaredFields();
for (Field field : allfields) {
System.out.println("成员变量类型"+field.getName());
System.out.println("成员变量名称"+field.getType());
System.out.println("成员变量访问修饰符"+field.getModifiers());
System.out.println("成员变量访问修饰符"+Modifier.toString(field.getModifiers()));
System.out.println();
}
System.out.println("-------------根据名称查找-------------");
System.out.println("自定义得到public：bookname");
cls.getField("bookName");
System.out.println("自定义得到private：bookname");
cls.getDeclaredField("sale");
}控制台打印
---------所有公共---------
成员变量类型bookName
成员变量名称class java.lang.String
成员变量访问修饰符1
成员变量访问修饰符public
成员变量类型stock
成员变量名称int
成员变量访问修饰符1
成员变量访问修饰符public
-------------子类自定义-------------
成员变量类型bookName
成员变量名称class java.lang.String
成员变量访问修饰符1
成员变量访问修饰符public
成员变量类型stock
成员变量名称int
成员变量访问修饰符1
成员变量访问修饰符public
成员变量类型sale
成员变量名称double
成员变量访问修饰符2
成员变量访问修饰符private
成员变量类型isShelf
成员变量名称boolean
成员变量访问修饰符2
成员变量访问修饰符private
-------------根据名称查找-------------
自定义得到public：bookname
自定义得到private：bookname
3）设置成员变量值
public void set(Object obj, Object value):
参数说明：
-
obj:要设置的字段所在的对象；
-
value:要为字段设置的值
测试类：
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {
// 完成成员变量保存值
// 使用反射的方式，完成成员变量保存值
Class cls = Book.class;
Object obj = cls.newInstance();
// 按照字段名称，获得指定字段
Field fie = cls.getDeclaredField("bookName");
// 参数1：目标对象
// 参数2：存入目标变量中的值
fie.set(obj, "葫芦娃大战七仙女");
System.out.println(obj);
}
控制台：
图书： [bookName=葫芦娃大战七仙女, stock=0, sale=0.0, isShelf=false]
4）得到成员变量值
public Object get(Object obj)：
参数说明：
-
obj:要设置的字段所在的对象；
测试类：
public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
Book book = new Book();
book.setBookName("七个小矮人大战白雪公主");
book.setSale(0.1);
book.setShelf(true);;
book.setStock(99);;
printInfo(book);
}
public static void printInfo(Object obj) throws IllegalArgumentException, IllegalAccessException {
// 输出参数对象的所有成员变量和值
Class cls = obj.getClass();
Field[] fields = cls.getDeclaredFields();
for (Field field : fields) {
// 判断是否可以访问
if (!field.isAccessible()) {
field.setAccessible(true);// 设置私有成员变量允许访问
}
System.out.println(field.getName()+":"+field.get(obj));
}
}控制台：
bookName:七个小矮人大战白雪公主
stock:99
sale:0.1
isShelf:true
4.获取成员方法并调用：
1）批量的：
public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）
public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)
2）获取单个的：
public Method getMethod(String name,Class<?>... parameterTypes):
public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
参数：
name : 方法名；
Class ... : 形参的Class类型对象
3）调用方法：
Method --> public Object invoke(Object obj,Object... args):
参数说明：
obj : 要调用方法的对象；
args:调用方式时所传递的实参；
调用静态方法，参数obj的类型为：null
例如：
Book类：
class Book{
public String bookName;
public int stock;
private double sale;
private boolean isShelf;
public Book() {
}
@Override
public String toString() {
return "图书： [bookName=" + bookName + ", stock=" + stock + ", sale=" + sale + ", isShelf=" + isShelf + "]";
}
public void dosth(int a,double b,char c) {
System.out.printf("a:%d b:%f c:%s ",a,b,c);
}
public int create() {
return 1;
}
private int create(int a) {
return a;
}
protected String create(String str,int a) {
String S = "";
for (int i = 0; i < a; i++) {
S += str;
}
return S;
}
public static void create(String s) {
System.out.println("这是一个静态方法"+s);
}
}测试类：
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
// 1.获取Class对象
Class cls = Book.class;
// 2.获取所有公有方法
System.out.println("***************获取所有的”公有“方法*******************");
cls.getMethods();
Method[] methodArray = cls.getMethods();
for(Method m : methodArray){
System.out.println(m);
System.out.println();
}
System.out.println("***************获取所有的方法，包括私有的*******************");
methodArray = cls.getDeclaredMethods();
for(Method m : methodArray){
System.out.println(m);
System.out.println();
}
System.out.println("***************获取公有的create()方法 *************** ");
Method mpu = cls.getMethod("create");
System.out.println(mpu);
// 实例化一个Student对象
Object obj = cls.getConstructor().newInstance();
int r = (int) mpu.invoke(obj);
System.out.println(r);
System.out.println("***************获取私有的create()方法******************");
Method mpri = cls.getDeclaredMethod("create", int.class);
System.out.println(mpri);
mpri.setAccessible(true);// 解除私有限定
Object result = mpri.invoke(obj, 20);// 需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result);
System.out.println("***************获取受保护的create()方法******************");
Method mpro = cls.getDeclaredMethod("create", String.class, int.class);
System.out.println(mpro);
mpro.setAccessible(true);// 解除私有限定
Object ret = mpro.invoke(obj, "HA" ,20);// 需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + ret);
System.out.println("***************获取静态的create()方法******************");
Method msta = cls.getDeclaredMethod("create", String.class);
System.out.println(msta);
Object ret1 = msta.invoke(null, "hahahahhaha");
}控制台：
***************获取所有的”公有“方法*******************
public java.lang.String com.apesource.demo.reflect.Book.toString()
public static void com.apesource.demo.reflect.Book.create(java.lang.String)
public int com.apesource.demo.reflect.Book.create()
public void com.apesource.demo.reflect.Book.dosth(int,double,char)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
***************获取所有的方法，包括私有的*******************
public java.lang.String com.apesource.demo.reflect.Book.toString()
protected java.lang.String com.apesource.demo.reflect.Book.create(java.lang.String,int)
private int com.apesource.demo.reflect.Book.create(int)
public static void com.apesource.demo.reflect.Book.create(java.lang.String)
public int com.apesource.demo.reflect.Book.create()
public void com.apesource.demo.reflect.Book.dosth(int,double,char)
***************获取公有的create()方法 ***************
public int com.apesource.demo.reflect.Book.create()
调用方法并输出：
1
***************获取私有的create()方法******************
private int com.apesource.demo.reflect.Book.create(int)
调用方法并输出：
返回值：20
***************获取受保护的create()方法******************
protected java.lang.String com.apesource.demo.reflect.Book.create(java.lang.String,int)
调用方法并输出：
返回值：HAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHA
***************获取静态的create()方法******************
public static void com.apesource.demo.reflect.Book.create(java.lang.String)
调用方法并输出：
这是一个静态方法hahahahhaha
关于方法调用有一个比较有趣的：
创建的是父类的方法，调用的是子类的对象，此时结果是子类的方法，所以说产生的结果只和调用的对象有关，与谁的方法无关。
public class Demo11 {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Method m = Person.class.getMethod("hello");
m.invoke(new Student());
// Student p = new Student();
// p.hello();
}
}
class Person {
public void hello() {
System.out.println("Person:hello");
}
}
class Student extends Person {
public void hello() {
System.out.println("Student:hello");
}
}结语：
大致上反射的内容就是这些，有遗漏的话，欢迎大佬补充。
关于反射的应用——动态代理后续会写在另一篇博客。
190
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
