反射
当一个字节码文件加载到内存的时候，jvm会对该字节码进行解剖，然后会创建一个对象的Class对象，把字节码文件的信息全部都存储到该Class对象中，只要获取到Class对象，就可以使用字节码对象设置对象的属性或者调用对象的方法等操作
类字节码文件是在硬盘上存储的，是一个个的.class文件。在new一个对象时，JVM会先把字节码文件的信息读出来放到内存中，第二次用时，就不用在加载了，而是直接使用之前缓存的这个字节码信息。
字节码的信息包括：类名、声明的方法、声明的字段等信息。在Java中“万物皆对象”，这些信息当然也需要封装一个对象，这就是Class类、Method类、Field类。
通过Class类、Method类、Field类等等类可以得到这个类型的一些信息，甚至可以不用new关键字就创建一个实例，可以执行一个对象中的方法，设置或获取字段的值，这就是反射技术。
注意： 在反射技术中一个类的任何成员都有对应的类进行描述。 比如： 成员变量（Field） 方法----> Method类
一、Class类
1.获取Class对象的三种方式
Java中有一个Class类用于代表某一个类的字节码。
Java提供了三种方式获取类的字节码：
- 通过ClassLoader对象的loadClass()方法
- Class.forName()：forName方法用于加载某个类的字节码到内存中，并使用class对象进行封装
- 类名.class
- 对象.getClass()
Demo1:
public class Demo1 {
public static void main(String[] args) throws ClassNotFoundException {
//Person p = new Person(123,"hcx");
//推荐使用： 获取Class对象的方式一
Class clazz1 = Class.forName("com.hcx.reflect.Person");
System.out.println("clazz1:"+ clazz1);
//获取Class对象的方式二： 通过类名获取
Class clazz2 = Person.class;
System.out.println("clazz1==clazz2?"+ (clazz1==clazz2));//true
//获取Class对象的方式三 ：通过对象获取
Class clazz3 = new Person(123,"hcx").getClass();
System.out.println("clazz2==clazz3?"+ (clazz2==clazz3));//true
}
}
Person:
public class Person {
private int id;
String name;
public Person(int id,String name){
this.id = id;
this.name = name;
}
public Person(){}
public void eat(int num){
System.out.println(name+"吃"+num+"碗饭");
}
private static void sleep(int num){
System.out.println("每天睡"+num+"小时");
}
public static void sum(int[] arr){
System.out.println("长度是："+ arr.length);
}
@Override
public String toString() {
return " 编号："+ this.id +" 姓名："+ this.name;
}
}
2.通过Class类获取类型的一些信息
- getName()类的名称（全名，全限定名）
- getSimpleName()类的的简单名称（不带包名）
- getModifiers(); 类的的修饰符
- 创建对象
无参数构造创建对象
newInstance() - 获取指定参数的构造器对象，并可以使用Constructor对象创建一个实例
Constructor<T> getConstructor(Class<?>... parameterTypes)
通过Class对象获取构造方法:
public class Demo2 {
public static void main(String[] args) throws Exception {
//获取到对应的Class对象
Class clazz = Class.forName("cn.itcast.reflect.Person");
//通过Class对象获取对应的构造方法
/*Constructor[] constructors = clazz.getConstructors(); // getConstructors()获取一个类的所有公共的构造方法
for(Constructor constructor : constructors){
System.out.println(constructor);
}
Constructor[] constructors = clazz.getDeclaredConstructors(); //获取到一个类的所有构造方法，包括私有的在内 。
for(Constructor constructor : constructors){
System.out.println(constructor);
}
*/
/*Constructor constructor = clazz.getConstructor(int.class,String.class); // getConstructor 获取单个指定的构造方法。
Person p = (Person) constructor.newInstance(123,"小红"); // newInstance()创建一个对象
System.out.println(p);*/
//获取私有的构造函数
Constructor constructor = clazz.getDeclaredConstructor(null);
//暴力反射
constructor.setAccessible(true);
Person p = (Person) constructor.newInstance(null);
System.out.println(p);
}
}
3.通过Class类获取类型中的方法的信息
在反射技术中使用Method类描述方法。
1.获取公共方法包括继承的父类的方法
getMethods()返回一个数组,元素类型是Method
2.获取指定参数的公共方法
getMethod("setName", String.class);
3.获得所有的方法,包括私有
Method[] getDeclaredMethods()
4.获得指定参数的方法,包括私有
Method getDeclaredMethod(String name, Class<?>... parameterTypes)
通过Class对象获取到对应的方法:
public class Demo3 {
public static void main(String[] args) throws Exception {
//获取到对应的Class对象
Class clazz = Class.forName("com.hcx.reflect.Person");
//获取到所有公共的方法
/*Method[] methods = clazz.getMethods(); // getMethods() 获取所有 的公共方法而已。
Method[] methods = clazz.getDeclaredMethods(); //获取到所有的方法，但是不包含父类的方法。
for(Method method : methods){
System.out.println(method);
}*/
Person p = new Person(123,"hcx");
/*
Method m = clazz.getMethod("eat", int.class);
m.invoke(p, 3); //invoke 执行一个方法。 第一个参数：方法的调用对象。 第二参数： 方法所需要的参数。
//执行私有的方法
Method m =clazz.getDeclaredMethod("sleep",int.class);
//设置访问权限允许访问
m.setAccessible(true);
m.invoke(null, 6);*/
Method m = clazz.getMethod("sum", int[].class);
m.invoke(p,new int[]{1,2,3});
}
}
4.通过Class类获取类型中的字段的信息
在反射技术中使用Field类描述成员变量。
1.获取公共字段
Field[] getFields()
2.获取指定参数的公共字段
Field getField(String name)
3.获取所有的字段
Field[] getDeclaredFields()
4.获取指定参数的字段,包括私用
Field getDeclaredField(String name)
通过反射获取对应的成员变量:
public class Demo4 {
public static void main(String[] args) throws Exception {
//获取到对应的Class对象
Class clazz = Class.forName("com.hcx.reflect.Person");
//获取 到所有的成员变量
/*Field[] fields = clazz.getDeclaredFields();
for(Field field : fields){
System.out.println(field);
}*/
Person p = new Person();
Field field = clazz.getDeclaredField("id");
//设置访问权限可以访问
field.setAccessible(true);
field.set(p, 110); //第一个参数： 设置该数据的成员变量，第二个参数：属性值。
System.out.println(p);
}
}
二、优缺点
优点：
- 增加程序的灵活性，避免将固有的逻辑程序写死到代码里
- 代码简洁,可读性强，可提高代码的复用率
缺点
- 相较直接调用在创建对象比较多的情景下反射性能下降
- 内部暴露和安全隐患（破坏单例）
反射性能慢原因
- 寻找类Class字节码的过程，比如通过ClassName找到对应的字节码Class，然后进行加载、解析，也会比较慢，而new的方式则无需寻找，因为在Linking的解析阶段已经将符号引用转为了直接引用
- 安全管理机制的权限验证等等
- 若需要调用native方法调用时JNI接口的使用
- 入参校验
破坏单例：
public class SingleDemo {
private static SingleDemo instance; //
private SingleDemo(){
if (instance!=null){
throw new RuntimeException("这是一个单例，不允许重复创建");
}
}
public static SingleDemo getInstance(){
if(instance == null){
instance = new SingleDemo();
}
return instance;
}
}
public class SingleMain {
public static void main(String[] args) throws Exception {
SingleDemo instance = SingleDemo.getInstance();
SingleDemo instance1 = SingleDemo.getInstance();
System.out.println(instance == instance1); //true
//通过反射获取
Class<? extends SingleDemo> clazz = instance.getClass();
Constructor<? extends SingleDemo> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true);//破会访问限制
SingleDemo instance2 = constructor.newInstance(); //private
SingleDemo instance3 = clazz.newInstance(); //constructor.newInstance()
System.out.println(instance==instance2);//false
}
}
