【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<Integer> integerClass = int.class;
    	Class<Character> characterClass = char.class;
    	Class<Boolean> booleanClass = boolean.class;
    	System.out.println(integerClass);//int
    	//6. 基本数据类型对应的包装类，可以通过 .TYPE 得到 Class 类对象
    	Class<Integer> type1 = Integer.TYPE;
    	Class<Character> 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 程序代码，此阶段是执行<clinit>()方法的过程。 2.<clinit>()方法是由编译器按语句在源文件中出现的顺序,依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。3虚拟机会保证一个类的 <clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的 <clinit>() 方法，其他线程都需要阻塞等待，直到活动线程执行 <clinit>() 方法完毕。

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);
	}

}