【Java】反射
1.什么是反射机制?
Java 反射机制是在运行状态中，对于任意一个类，都能够知道这个类中的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为 Java 的反射机制。
2.反射的优点和缺点
- 优点：可以动态的创建和使用对象（也就是框架底层核心），使用灵活，没有反射机制，框架技术就失去底层支撑。
- 缺点：使用发射机制基本是解释执行，对执行速度有影响。
3.静态和动态加载
- 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强。比如：（1）new创建对象时，（2）当子类被加载时，父类也被加载，（3）调用类中的静态成员时
- 动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，则不报错，降低了依赖性。比如（1）通过反射。
4.Class类基本介绍:
1.Class也是类，因此也继承Object类
2.Class类对象不是new出来的，而是系统创建的
3.对于某个类的class类对象，在内存中只有一份，因为类只加载一次
4.每个类的实例都会记得自己是由哪个 Class 实例所生成
5.通过Class可以完整地得到一个类的完整结构,通过一系列API
6.Class对象是存放在堆的
7.类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括 方法代码变量名，方法名，访问权限等等)
Class的方法：
5.获得Class类对象
1.前提:已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName0获取，可能抛出ClassNotFoundException，
实例: Class cls1 =Class.forName( "java.lang.Cat”);
应用场景:多用于配置文件,读取类全路径，加载类.
2.前提: 若已知具体的类，通过类的class 获取，该方式 最为安全可靠，程序性能最高
实例:Class cls2 = Cat.class;
应用场景: 多用于参数传递，比如通过反射得到对应构造器对象
3.前提: 已知某个类的实例，调用该实例的getClass0方法获取Class对象，
实例:Class clazz = 对象.getClass()；
应用场景: 通过创建好的对象，获取Class对象
4.其他方式
ClassLoader cl = 对象.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“类的全类名”);
5.基本数据(int, charboolean,float,double,byte,long,short) 按如下方式得到Class类对象
Class cls = 基本数据类型.class
6.基本数据类型对应的包装类，可以通过 .type 得到Class类对象
Class cls = 包装类.TYPE
//1. Class.forName
String classAllPath = "ref.Car"; //通过读取配置文件获取
Class cls1 = Class.forName(classAllPath);
System.out.println(cls1);
//2. 类名.class , 应用场景: 用于参数传递
Class cls2 = Car.class;
System.out.println(cls2);
//3. 对象.getClass(), 应用场景，有对象实例
Car car = new Car();
Class cls3 = car.getClass();
System.out.println(cls3);
//4. 通过类加载器【4 种】来获取到类的 Class 对象
//(1)先得到类加载器 car
ClassLoader classLoader = car.getClass().getClassLoader();
//(2)通过类加载器得到 Class 对象
Class cls4 = classLoader.loadClass(classAllPath);
System.out.println(cls4);
//cls1 , cls2 , cls3 , cls4 其实是同一个对象
System.out.println(cls1.hashCode());
System.out.println(cls2.hashCode());
System.out.println(cls3.hashCode());
System.out.println(cls4.hashCode());
//5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到 Class 类对象
Class integerClass = int.class;
Class characterClass = char.class;
Class booleanClass = boolean.class;
System.out.println(integerClass);//int
//6. 基本数据类型对应的包装类，可以通过 .TYPE 得到 Class 类对象
Class type1 = Integer.TYPE;
Class type2 = Character.TYPE; //其它包装类 BOOLEAN, DOUBLE, LONG,BYTE 等待
System.out.println(type1);
System.out.println(integerClass.hashCode());//?
System.out.println(type1.hashCode());//? 6.类加载的各阶段
类加载过程图：
加载阶段：
JVM 在该阶段的主要目的是将字节码从不同的数据源（可能是class文件，也可能是jar 包，甚至网络)转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class 对象
连接阶段-验证：
目的是为了确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。包括: 文件格式验证(是否以魔数 oxcafebabe开头)、元数据验证、字节码验证和符号引用验证。
连接阶段-准备：
JVM 会在该阶段对静态变量，分配内存并默认初始化 (对应数据类型的默认初始值，如 0、0L、null、false 等) 。这些变量所使用的内存都将在方法区中进行分配。
连接阶段-解析：
虚拟机将常量池内的符号引用替换为直接引用的过程。
Initialization (初始化)：
1.到初始化阶段，才真正开始执行类中定义的 Java 程序代码，此阶段是执行
7.通过反射获取类的结构信息
第一组: java.lang.Class类
1.getName:获取全类名
2 getSimpleName:获取简单类名
3.getFields:获取所有public修饰的属性，包含本类以及父类的
4.getDeclaredFields:获取本类中所有属性
5.getMethods:获取所有public修饰的方法，包含本类以及父类的
6.getDeclaredMethods:获取本类中所有方法
7.getConstructors: 获取本类所有public修饰的构造器
8.getDeclaredConstructors:获取本类中所有构造器
9.getPackage:以Package形式返回 包信息
10.getSuperClass:以Class形式返回父类信息
11.getlnterfaces:以Class[]形式返回接口信息
12.getAnnotations:以Annotation[] 形式返回注解信息
第二组: java.lang.reflect.Field类
1.getModifiers: 以int形式返回修饰符
[说明: 默认修饰符 是0，public 是1 ，private 是 2protected 是 4 static 是 8 ，final 是 16] , public(1) + static (8)= 9
2.getType:以Class形式返回类型
3.getName:返回属性名
第三组: java.lang.reflect.Method类
1.getModifiers:以int形式返回修饰符
[说明: 默认修饰符 是0，public 是1 ，private 是 2，protected 是 4.static 是8，final 是 16]
2. getReturnType:以Class形式获取 返回类型
3.getName:返回方法名
4. getParameterTypes:以Class[]返回参数类型数组
第四组: java.lang.reflect.Constructor类
1. getModifiers: 以int形式返回修饰符
2. getName:返回构造器名 (全类名)
3.getParameterTypes:以Class[]返回参数类型数组
例子：访问方法
1.根据方法名和参数列表获取Method方法对象 : Method m =clazz.getDeclaredMethod(方法名，XX.class)://得到本类的所有方法
2.获取对象: Object o=clazz.newlnstance()
3.暴破 : m.setAccessible(true);
4.访问 :Object returnValue = m.invoke(o,实参列表)://o 就是对象
5.注意: 如果是静态方法，则invoke的参数o，可以写成null!
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflecAccessMethod {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
//1. 得到 Boss 类对应的 Class 对象
Class bossCls = Class.forName("ref.Boss");
//2. 创建对象
Object o = bossCls.newInstance();
//3. 调用 public 的 hi 方法
//Method hi = bossCls.getMethod("hi", String.class);//OK
//3.1 得到 hi 方法对象
Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
//3.2 调用
hi.invoke(o, "韩顺平教育~");
//4. 调用 private static 方法
//4.1 得到 say 方法对象
Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
//4.2 因为 say 方法是 private, 所以需要暴破，原理和前面讲的构造器和属性一样
say.setAccessible(true);
System.out.println(say.invoke(o, 100, "张三", '男'));
//4.3 因为 say 方法是 static 的，还可以这样调用 ，可以传入 null
System.out.println(say.invoke(null, 200, "李四", '女'));
//5. 在反射中，如果方法有返回值，统一返回 Object , 但是他运行类型和方法定义的返回类型一致
Object reVal = say.invoke(null, 300, "王五", '男');
System.out.println("reVal 的运行类型=" + reVal.getClass());//String
//在演示一个返回的案例
Method m1 = bossCls.getDeclaredMethod("m1");
Object reVal2 = m1.invoke(o);
System.out.println("reVal2 的运行类型=" + reVal2.getClass());//Monster
}
}
class Monster {}
class Boss {//类
public int age;
private static String name;
public Boss() {//构造器
}
public Monster m1() {
return new Monster();
}
private static String say(int n, String s, char c) {//静态方法
return n + " " + s + " " + c;
}
public void hi(String s) {//普通 public 方法
System.out.println("hi " + s);
}
}8.反射机制的应用场景有哪些?
- 1.逆向代码，例如反编译
- 2.应用场景与注解相结合的框架，如 Retrofit
- 3.单纯的反射机制应用框架，例如 EventBus(事件总线)
- 4.动态生成类框架 例如Gson
9.使用反射做一个简易版的框架
需求:
对于任意一个对象，该框架都可以把对象的字段名和对应的值，保存到文件中去。
实现步骤
1.定义一个方法，可以接收任意对象。
2.每收到个对象后，使用反射获取该对象的Class对象，然后获取全部的成员变量。
3.遍历成员变量，然后提取成员变量在该对象中的具体值。
4.把成员变量名、和其值，写出到文件中去即可。
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
public class objectFrame {
public static void saveObject(Object obj) throws Exception {
PrintStream ps=new PrintStream(new FileOutputStream("D:\\text.txt",true));
Class c=obj.getClass();
String cName=c.getSimpleName();
ps.println("----------"+cName+"---------------");
Field[] fields=c.getDeclaredFields();
for(Field field:fields) {
String name=field.getName();
field.setAccessible(true);
String value=field.get(obj)+"";
ps.println(name+"="+value);
}
ps.close();
}
}
public class Test {
public static void main(String[] args) throws Exception {
Student s1=new Student("某人",15,'男');
Teacher t1=new Teacher("张老师",9999);
objectFrame.saveObject(s1);
objectFrame.saveObject(t1);
}
}