类加载器的组成
- Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载
比如System,String等。在JDK中JRE的lib目录下rt.jar文件中 - Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载。
在JDK中JRE的lib目录下ext目录 - System ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。
反射
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。
先创建Person.class
package Models;
public class Person {
//成员变量
public String name;
public int age;
private String address;
//构造方法
public Person() {
System.out.println("空参数构造方法");
}
public Person(String name) {
this.name = name;
System.out.println("带有String的构造方法");
}
//私有的构造方法
public Person(String name, int age){
this.name = name;
this.age = age;
System.out.println("带有String，int的构造方法");
}
private Person(String name, int age, String address){
this.name = name;
this.age = age;
this.address = address;
System.out.println("带有String, int, String的构造方法");
}
//成员方法
//没有返回值没有参数的方法
public void method1(){
System.out.println("没有返回值没有参数的方法");
}
//没有返回值，有参数的方法
public void method2(String name){
System.out.println("没有返回值，有参数的方法 name= "+ name);
}
//有返回值，没有参数
public int method3(){
System.out.println("有返回值，没有参数的方法");
return 123;
}
//有返回值，有参数的方法
public String method4(String name){
System.out.println("有返回值，有参数的方法");
return "哈哈" + name;
}
//私有方法
private void method5(){
System.out.println("私有方法");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";
}
}
Class类
public static void main(String[] args) throws ClassNotFoundException {
//方式一: 通过Object类中的getObject()方法
Person p = new Person();
Class c1 = p.getClass();
//方式二: 通过 类名.class 获取到字节码文件对象
// （任意数据类型都具备一个class静态属性,看上去要比第一种方式简单）。
Class c2 = Person.class;
System.out.println("c2:" + c2);
System.out.println("c1==c2:" + (c1 == c2));
System.out.println("c1.equals(c2):" + c1.equals(c2));
//方式三: 通过Class类中的静态方法（将类名作为字符串传递给Class类中的静态方法forName即可）。
//包名.类名
Class c3 = Class.forName("Models.Person");
System.out.println("c3:" + c3);
/*
c2:class Models.Person
c1==c2:true
c1.equals(c2):true
c3:class Models.Person
*/
}
通过反射获取构造方法并使用
在反射机制中，把类中的成员（构造方法、成员方法、成员变量）都封装成了对应的类进行表示。其中，构造方法使用类Constructor表示。可通过Class类中提供的方法获取构造方法：
- 返回一个构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)获取public修饰, 指定参数类型所对应的构造方法public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)获取指定参数类型所对应的构造方法(包含私有的)
- 返回多个构造方法
public Constructor<?>[] getConstructors()获取所有的public 修饰的构造方法public Constructor<?>[] getDeclaredConstructors()获取所有的构造方法(包含私有的)
获取所有构造方法
public static void main(String[] args) throws ClassNotFoundException {
//通过反射获取构造方法并使用
Class c1 = Class.forName("Models.Person");
//getConstructors返回包含一个类的所有公共构造 类对象。
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
/*
结果：
public Models.Person(java.lang.String,int)
public Models.Person(java.lang.String)
public Models.Person()
注意：没有 private Person(String name, int age, String address)
*/
}
获取无参构造方法
public static void GetNoParameters() throws Exception{
//通过反射获取构造方法并使用
Class c1 = Class.forName("Models.Person");
//2.1.获取空参构造方法
Constructor constructor = c1.getConstructor();
//2.2 运行 Constructor.newInstance()
Object object = constructor.newInstance();
System.out.println(object);
/*
结果：
空参数构造方法
Person [name=null, age=0, address=null]
*/
}
获取有参构造方法
public static void GetHasParameters() throws Exception{
//1.通过反射获取构造方法并使用
Class c1 = Class.forName("Models.Person");
//2.1.获取有参构造方法
//getConstructor(Class<?>... parameterTypes)
Constructor constructor = c1.getConstructor(String.class,int.class);
//2.2 运行 Constructor.newInstance(Object... initargs)
Object object = constructor.newInstance("张三",20);
System.out.println(object);
/*
结果：
带有String，int的构造方法
Person [name=张三, age=20, address=null]
*/
}
快速使用无参构造方法的快速方法
/*
前提：1.被反射的类，必须有空参构造方法
2.构造方法必须为public
*/
public static void GetFastParameters() throws Exception{
//1.通过反射获取构造方法并使用
Class c1 = Class.forName("Models.Person");
//2.2 直接运行 Class.newInstance()
Object object = c1.newInstance();
System.out.println(object);
}
反射获取私有方法
不推荐，破坏程序的封装型，安全性
/**
* 返回所有构造方法，包括private
*/
public static void GetDeclaredConstructors() throws ClassNotFoundException{
//通过反射获取构造方法并使用
Class c1 = Class.forName("Models.Person");
Constructor[] constructors = c1.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
/*
private Models.Person(java.lang.String,int,java.lang.String)
public Models.Person(java.lang.String,int)
public Models.Person(java.lang.String)
public Models.Person()
*/
}
调用私有构造方法（暴力反射）
/**
* 1.返回所有构造方法，包括private
* 2.调用私有构造方法
*/
public static void GetDeclaredConstructors() throws Exception{
//通过反射获取构造方法并使用
Class c1 = Class.forName("Models.Person");
Constructor[] constructors = c1.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
System.out.println("==========");
/*
private Models.Person(java.lang.String,int,java.lang.String)
public Models.Person(java.lang.String,int)
public Models.Person(java.lang.String)
public Models.Person()
*/
//getDeclaredConstructor(Class<?>... parameterTypes) 可以获取私有构造方法
Constructor constructor = c1.getDeclaredConstructor(String.class,int.class,String.class);
System.out.println(constructor);
//Constructor的父类：AccessibleObject
//setAccessible(boolean flag) 在反射对象中设置accessible = true 取消权限检查,
constructor.setAccessible(true);
Object object = constructor.newInstance("李四",30,"老街");
System.out.println(object);
/*
private Models.Person(java.lang.String,int,java.lang.String)
带有String, int, String的构造方法
Person [name=李四, age=30, address=老街]
*/
}
获取成员变量
通过方法，给指定对象的指定成员变量赋值或者获取值
- public void set(Object obj, Object value)
在指定对象obj中，将此 Field 对象表示的成员变量设置为指定的新值 - public Object get(Object obj)
返回指定对象obj中，此 Field 对象表示的成员变量的值
/*
反射成员变量，并修改
*/
public static void SetMembers() throws Exception{
Class c1 = Class.forName("Models.Person");
//获取公有
Field[] filses = c1.getFields();
for (Field fils : filses) {
System.out.println(fils);
}
System.out.println("====");
//获取公有+私有
Field[] fields = c1.getDeclaredFields();
for (Field fils : fields) {
System.out.println(fils);
}
System.out.println("====");
//获取成员变量
Field name = c1.getField("name");
//set(Object obj, Object value) 将指定对象参数上的此 Field对象表示的字段设置为指定的新值。
//obj - 其字段应被修改的对象
//value - 修改了 obj的新值
Object obj = c1.newInstance();
name.set(obj,"王五");
System.out.println(obj);
/*
结果：
public java.lang.String Models.Person.name
public int Models.Person.age
====
public java.lang.String Models.Person.name
public int Models.Person.age
private java.lang.String Models.Person.address
====
空参数构造方法
Person [name=王五, age=0, address=null]
*/
}
方法
public Object invoke(Object obj, Object... args)
执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。
/*
方法运行
*/
public static void InvokeMethod() throws Exception {
Class c1 = Class.forName("Models.Person");
System.out.println("1.空参方法,没有返回值======");
Object obj = c1.newInstance();
Method m1 = c1.getMethod("method1");
//invoke(Object obj, Object... args)
//在具有指定参数的 方法对象上调用此 方法对象表示的底层方法。
//obj - 从底层方法被调用的对象
//args - 用于方法调用的参数
m1.invoke(obj);
System.out.println("2.有参方法，没有返回值======");
Method m2 = c1.getMethod("method2", String.class);
m2.invoke(obj, "唐三三");
System.out.println("3.无参方法，有返回值======");
Method m3 = c1.getMethod("method3");
Object returnResult = m3.invoke(obj);
System.out.println(returnResult);
System.out.println("4.有参方法，有返回值======");
Method m4 = c1.getMethod("method4", String.class);
Object returnResult1 = m4.invoke(obj, "李白");
System.out.println(returnResult1);
/*
1.空参方法,没有返回值======
空参数构造方法
没有返回值没有参数的方法
2.有参方法，没有返回值======
没有返回值，有参数的方法 name= 唐三三
3.无参方法，有返回值======
有返回值，没有参数的方法
123
4.有参方法，有返回值======
有返回值，有参数的方法
哈哈李白
*/
}
泛型擦除
思考，将已存在的ArrayList<Integer>集合中添加一个字符串数据，如何实现呢？
其实程序编译后产生的.class文件中是没有泛型约束的，这种现象我们称为泛型的擦除。那么，我们可以通过反射技术，来完成向有泛型约束的集合中，添加任意类型的元素。
/**
* 泛型擦除
* ArrayList<String> 添加 int
*
* @throws Exception
*/
public static void GenerictypeClear() throws Exception{
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("a");
//arrayList.add(1); 失败
Class c = arrayList.getClass();
Method method = c.getMethod("add",Object.class);
method.invoke(arrayList,150);
method.invoke(arrayList,50);
System.out.println(arrayList); //[a, 150, 50]
}
读取配置文件 Properties
- . 反射通过配置文件来决定运行的步骤
- a. 操作依据
通过配置文件得到类名和要运行的方法名,用反射的操作类名得到对象和调用方法
- b. 实现步骤:
* 1. 准备配置文件,键值对
* 2. IO流读取配置文件 Reader
* 3. 文件中的键值对存储到集合中 Properties
集合保存的键值对,就是类名和方法名
* 4. 反射获取指定类的class文件对象
* 5. class文件对象,获取指定的方法
* 6. 运行方法
- a. 操作依据
/**
* 读取配置文件Properties
*/
public static void ReadProperties() throws Exception {
//2. IO流读取配置文件 Reader
FileReader reader = new FileReader("src\config.properties");
//3. 文件中的键值对存储到集合中 Properties
Properties properties = new Properties();
properties.load(reader);
//集合保存的键值对,就是类名和方法名
String className = properties.getProperty("className");
String method1 = properties.getProperty("method1");
//4. 反射获取指定类的class文件对象
Class c = Class.forName(className);
Object obj = c.newInstance();
//5. class文件对象,获取指定的方法
Method method = c.getMethod(method1);
//6. 运行方法
method.invoke(obj);
}