定义
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
用途
在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。当然，也不是所有的都适合反射，之前就遇到一个案例，通过反射得到的结果与预期不符。阅读源码发现，经过层层调用后在最终返回结果的地方对应用的权限进行了校验，对于没有权限的应用返回值是没有意义的缺省值，否则返回实际值起到保护用户的隐私目的。
案例：（重要）
public class Demo1 {
//创建一个自己本身的公共变量
public static demo.knowledgepoints.reflect.Demo1 demo1;
private static final boolean flag = true ;
//将其私有化，保证不能通过New的方式创建。
private Demo1(){}
//创建get方法，用于告知使用者，不能被new，不能被获取。
public static Demo1 getDemo1() throws Exception{
if(flag){
throw new Exception("抱歉,该类不通过new 的方式创建！");
}
return demo1;
}
public void print(){
System.out.println("恭喜成功获取Demo1！");
}
//通过静态代码块创建实体类。
static {
demo1 = new Demo1();
}
}
public class Demo2 {
//创建一个自己本身的私有变量
private static demo.knowledgepoints.reflect.Demo2 demo2;
private static final boolean flag = true ;
//将其私有化，保证不能通过New的方式创建。
private Demo2(){}
//创建get方法，用于告知使用者，不能被new，不能被获取。
public static Demo2 getDemo2() throws Exception{
if(flag){
throw new Exception("抱歉,该类不通过new 的方式创建！");
}
return demo2;
}
public void print(){
System.out.println("恭喜成功获取Demo2！");
}
//通过静态代码块创建实体类。
static {
demo2 = new Demo2();
}
}
public class Reflect {
public static void main(String[] args) {
Demo1 demo1 = null;
Demo2 demo2 = null;
try {
//发现new ,编译报错。
//demo1 = new Demo1();
//demo2 = new Demo2();
//发现get方法也获取不到，执行会报异常。
demo1 = Demo1.getDemo1();
demo2 = Demo2.getDemo2();
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
通过上述代码，我们知道通过普通方法是无法获取到Demo1 和 Demo2。但是看Demo1 和 Demo2的写法，在静态代码块中是new了对象的。说明肯定有办法可以获取到实例。
这里说的方法就是反射。
import java.lang.reflect.Field;
public class Reflect {
public static void main(String[] args) {
Demo1 demo1 = null;
Demo2 demo2 = null;
try {
//首先通过Field，获取需要的类，Field包在jdk的反射包中：java.lang.reflect
Field field1 = Demo1.class.getDeclaredField("demo1");
//获取之后，强制转换成Demo1。
demo1 = (Demo1)field1.get(null);
demo1.print();
//然后我们再来创建一个Demo2.
Field field2 = Demo2.class.getDeclaredField("demo2");
//私有方法需要将：field2.setAccessible(true) ，才能获取到实例类
field2.setAccessible(true);
demo2 = (Demo2)field2.get(null);
demo2.print();
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
通过上述代码，我们通过反射，获取到Demo1和Demo2的公共属性和私有属性，成功获取到对象。
讲讲反射原理：
通过到class所在目录下，执行javap -c Book.class，可以查看字节码。可以看到一些公共的方法，私有的看不到，不过不影响JVN获取。
下面介绍一下反射的基础类和方法
| 类名 | 用途 |
| Class类 | 代表类的实体，在运行的Java应用程序中表示类和接口 |
| Field类 | 代表类的成员变量（成员变量也称为类的属性） |
| Method类 | 代表类的方法 |
| Constructor类 | 代表类的构造方法 |
方法见JDK-API文档。
以下是常见方法的使用案例：
package demo.knowledgepoints.reflect;
public class Book {
private final static String TAG = "BookTag";
private String name;
private String author;
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
'}';
}
public Book() {
}
private Book(String name, String author) {
this.name = name;
this.author = author;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
private String declaredMethod(int index) {
String string = null;
switch (index) {
case 0:
string = "I am declaredMethod 1 !";
break;
case 1:
string = "I am declaredMethod 2 !";
break;
default:
string = "I am declaredMethod 1 !";
}
return string;
}
}
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method; public class Reflect {
public static void main(String[] args) {
reflectNewInstance();
reflectPrivateConstructor();
reflectPrivateField();
reflectPrivateMethod();
} /**
* 通过反射获取对象
*/
public static void reflectNewInstance() {
try {
Class<?> classBook = Class.forName("demo.knowledgepoints.reflect.Book");
Object objectBook = classBook.newInstance();
Book book = (Book) objectBook;
book.setName("Java进阶之光");
book.setAuthor("蕾蕾");
System.out.println("reflectNewInstance book = " + book.toString());
} catch (Exception ex) {
ex.printStackTrace();
}
} // 反射私有的构造方法
public static void reflectPrivateConstructor() {
try {
Class<?> classBook = Class.forName("demo.knowledgepoints.reflect.Book");
Constructor<?> declaredConstructorBook = classBook.getDeclaredConstructor(String.class,String.class);
declaredConstructorBook.setAccessible(true);
Object objectBook = declaredConstructorBook.newInstance("Java开发艺术探索","磊磊");
Book book = (Book) objectBook;
System.out.println("reflectPrivateConstructor book = " + book.toString());
} catch (Exception ex) {
ex.printStackTrace();
}
} // 反射私有属性
public static void reflectPrivateField() {
try {
Class<?> classBook = Class.forName("demo.knowledgepoints.reflect.Book");
Object objectBook = classBook.newInstance();
Field fieldTag = classBook.getDeclaredField("TAG");
fieldTag.setAccessible(true);
String tag = (String) fieldTag.get(objectBook);
System.out.println("reflectPrivateField tag = " + tag);
} catch (Exception ex) {
ex.printStackTrace();
}
} // 反射私有方法
public static void reflectPrivateMethod() {
try {
Class<?> classBook = Class.forName("demo.knowledgepoints.reflect.Book");
Method methodBook = classBook.getDeclaredMethod("declaredMethod",int.class);
methodBook.setAccessible(true);
Object objectBook = classBook.newInstance();
String string = (String) methodBook.invoke(objectBook,1); System.out.println("reflectPrivateMethod string = " + string);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
运行结果：