23.类加载器
类加载器
类加载
当程序需要使用某个类, 如果该类还未被加载到内存中, 则系统会通过类的加载, 类的连接, 类的初始化这三个步骤来对类进行初始化. 这三个步骤统称为类加载或者类初始化
类的加载:
- 将class文件读入内存, 并为之创建一个java.lang.class对象
- 任何类被使用时, 系统都会为之创建一个java.lang.Class对象
类的连接:
- 验证阶段: 用于检验被加载的类是否有正确的内部结构, 并和其他类协调一致
- 准备阶段: 负责为类的类变量分配内存, 并设置默认初始化值
- 解析阶段: 将类的二进制数据中的符号引用替换为直接引用
类的初始化:
- 主要是对类变量进行初始化
- 假如该类未被加载和连接, 程序会先加载并连接该类
- 假如该类的直接父类还未被初始化, 则先初始化其直接父类
- 假如类中有初始化语句, 则系统依次执行这些初始化语句
注意: 在执行第2个步骤的时候, 系统对直接父类的初始化步骤也遵循初始化步骤1-3
类初始化的时机:
- 创建类的实例
- 调用类的类方法
- 访问类或者接口的类变量, 或者为该类变量赋值
- 使用反射方式来强制创建某个类或接口的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个类
类加载器
负责将.class文件加载到内存中, 并为之生成对应的java.lang.class对象
我们不需要过分关心类加载机制, 但是了解机制能更好的理解程序的运行
JVM类加载机制
-
全盘负责: 当一个类加载器负责加载某个Class时, 该Class所依赖的和引用的其他Class也有改类加载器负载再入, 除非显示使用另外一个类加载器载入
-
父类委托: 当一个类加载器负责加载某个Class时, 先让父类加载器视图加载改Class, 只有在父类加载器无法加载该类时,才尝试从自己的类路径中加载该类.
-
缓存机制: 保证所有加载过的类都会被缓存, 当需要使用某个Class对象时, 类加载器先从缓存中搜索该Class, 只有当缓存中不存在时, 系统才会读取该类对应的二进制数据, 并将其转换为Class对象, 存储到缓存区
classLoder: 负责加载类的对象
java运行时具有以下内置类加载器
- Bootstrap class loader: 虚拟机内置加载器, 通常表示为null, 并且没有null
- Platform class loader: 平台类加载器可以看到所有平台类, 平台类包括有平台类加载器或其祖先定义的java SE平台api, 其实现类和JDK特定的运行时类
- System class loader: 应用程序类加载器, 与平台类加载器不同. 通常用于定义应用程序类路径, 模块路径和JDK特定工具上的类.
注意: System的父类加载器为Platform, 而Platform的父类加载器为Bootstrap
ClassLoader中的两个方法:
- static ClassLoader getSystemClassLoader(): 返回用于委派的系统类加载器
- ClassLoader getParent(): 返回父类加载器进行委派
package reflect.classLoader;
public class ClassLoaderDemo {
public static void main(String[] args) {
// static ClassLoader getSystemClassLoader(): 返回用于委派的系统类加载器
ClassLoader c = ClassLoader.getSystemClassLoader();
System.out.println(c); // AppClassLoader@512ddf17
// ClassLoader getParent(): 返回父类加载器进行委派
ClassLoader c2 = c.getParent();
System.out.println(c2); // PlatformClassLoader@4c203ea1
ClassLoader c3 = c2.getParent();
System.out.println(c3); // null
}
}
反射
反射概述
反射机制: 运行时去获取一个类的变量和方法信息. 然后通过获取到的信息来创建对象, 调用方法的一种机制.
这种动态性, 可以极大的增强程序的灵活性, 程序不同在编译期就完成确定, 在运行期仍可以扩展
获取Class类对象
通过反射使用一个类, 需要获取到该类的字节码文件对象, 也就是Class类型的对象
获取Class对象的方式
- 使用类的class属性获取该类对应的Class对象: Student.class
- 调用对象的getClass()方法, 返回改对象所属类对应的Class对象(该方法是Object类的方法,所有对象都可以调用)
- 使用Class类中的静态方法forName(String className), 该方法需要传入字符串参数, 该字符串参数的值是某个类的全路径, 也就是完整包名的路径
package reflect.reflect;
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 使用类的class属性获取
Class<Student> c1 = Student.class;
System.out.println(c1);
Class<Student> c2 = Student.class;
System.out.println(c1 == c2);
System.out.println("-------");
// 调用对象的getClass()方法, 返回该对象所属类对应的class对象
Student s = new Student();
Class<? extends Student> c3 = s.getClass();
System.out.println(c1 == c3);
System.out.println("-------");
// 使用Class类中的静态方法forName(String className)
Class<?> c4 = Class.forName("reflect.reflect.Student");
System.out.println(c1 == c4);
}
}
反射获取构造方法并使用
Class类中用于获取构造方法的方法
- Constructor<?>[] getConstructors (): 返回所有公共构造方法对象的数组
- Constructor<?>[] getDeclaredConstructors (): 返回所有构造方法对象的数组
- Constructor
getConstructor(Class<?>... parameterTypes): 返回单个公共构造方法对象 - Constructor
getDeclaredConstructor(Class<?>... parameterTypes): 返回单个构造方法对象
package reflect.reflect;
import file.IOStream.SystemOutDemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ReflectDemo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// 获取Class对象
Class<?> c = Class.forName("reflect.reflect.Student");
// Constructor<?>[] getConstructors (): 返回一个包含Constructor对象的数组, Constructor对象反映了由该class对象表示的类的所有公共构造函数
Constructor<?>[] cons = c.getConstructors();
for(Constructor con: cons) {
System.out.println(con);
}
// public reflect.reflect.Student()
// public reflect.reflect.Student(java.lang.String,int,java.lang.String)
// Constructor<?>[] getDeclaredConstructors (): 返回反应由该class对象表示的类的所有构造函数的Constructor对象的数组
Constructor<?>[] cons1 = c.getDeclaredConstructors();
for(Constructor con: cons1){
System.out.println(con);
}
System.out.println("-------");
// Constructor<T> getConstructor(Class<?>... parameterTypes): 返回一个 构造器对象，该对象反映此 类对象所表示的类的指定公共构造函数
// Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes): 返回一个 构造器对象，该对象反映此 类对象所表示的类或接口的指定构造函数。
// 参数: 你要获取的构造方法的参数的个数, 和 数据类型对应的字节码文件对象
Constructor<?> con = c.getConstructor();
System.out.println(con);
// Constructor: 提供有关类的单个构造函数的信息和访问权限
// T newInstance(Object... initargs): 使用此Constructor对象表示的构造方法，使用指定的初始化参数创建和初始化构造函数声明类的新实例
Object obj = con.newInstance();
System.out.println(obj);
// 练习: 通过反射获取构造方法, 创建对象
Class<?> cl = Class.forName("reflect.reflect.Student");
// public Student(String name, int age, String address)
// Constructor<T> getConstructor (Class<?> ... parameterTypes)
Constructor<?> constructor = c.getConstructor(String.class, int.class, String.class);
// J基本数据类型也可以通过.class获取对应的Class类型
Object stu = constructor.newInstance("林青霞", 30, "西安");
System.out.println(stu);
// 私有构造方法
Constructor<?> constructor1 = c.getDeclaredConstructor(String.class);
// 暴力反射
// public void setAccessible(boolean flag): 值为true, 取消访问检查
constructor1.setAccessible(true);
Object obj2 = constructor1.newInstance("林青霞");
System.out.println(obj2);
}
}
注意:
- 基本数据类型也可以用.class获取对应的Class类型
- public void setAccessible(boolean flag): 值为true, 取消访问检查, 私有构造方法可以来创建对象
反射获取成员变量使用
Class中用于获取成员变量的方法
- Field[] getFields(): 返回一个数组, 包含该Class对象表示类或接口中的所有公共成员变量
- Field[] getDeclaredFields(): 返回一个数组, 包含该Class对象表示类或接口中的所有成员变量
- Field getField(String name): 返回一个Field对象, 反应该Class对象表示类或接口中的指定公共成员字段
- Field getDeclaredField(String name): 返回一个Field对象, 反应该Class对象表示类或接口中的指定成员字段
Field类中用于给成员变量赋值的方法
- void set(Object obj, Object value): 给obj对象的成员变量赋值为value
package reflect.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class ReflectDemo3 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// 获取Class对象
Class<?> c = Class.forName("reflect.reflect.Student");
// Field[] getFields(): 返回一个数组, 包含该Class对象表示类或接口中的所有公共成员变量
// Field[] getDeclaredFields(): 返回一个数组, 包含该Class对象表示类或接口中的所有成员变量
// Field[] fields = c.getFields();
Field[] fields = c.getDeclaredFields();
for(Field field: fields) {
System.out.println(field);
}
System.out.println("--------");
// Field getField(String name): 返回一个Field对象, 反应该Class对象表示类或接口中的指定公共成员字段
// Field getDeclaredField(String name): 返回一个Field对象, 反应该Class对象表示类或接口中的指定成员字段
Field address = c.getField("address");
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
address.set(obj, "西安"); // 给obj的成员变量address赋值为西安
/*
Student s = new Student();
s.address = "西安";
System.out.println(s.address);
*/
}
}
练习
package reflect.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class ReflectDemo4 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
// 获取class对象
Class<?> c = Class.forName("reflect.reflect.Student");
// Student s = new Student();
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
System.out.println(obj);
// s.name = "林青霞"
// Field nameField = c.getField("name"); // NoSuchFieldException: name
Field nameField = c.getDeclaredField("name"); // IllegalAccessException
nameField.setAccessible(true);
nameField.set(obj, "林青霞");
System.out.println(obj);
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj, 30);
System.out.println(obj);
Field addressField = c.getDeclaredField("address");
addressField.setAccessible(true);
addressField.set(obj, "西安");
System.out.println(obj);
}
}
反射获取成员方法使用
Class类中用于获取成员方法的方法
-
Method[] getMethods(): 返回数组, 包含由该Class对象表示的类或接口的所有公共方法(包括继承父类的)
-
Method[] getDeclaredMethods(): 返回数组, 包含由该Class对象表示的类或接口的所有方法(不包含继承的)
-
Method getMethod(String name, class<?>... parameterTypes): 返回由该Class对象表示的类或接口指定的公共方法
-
Method getDeclaredMethod(String name, class<?>... parameterTypes): 返回由该Class对象表示的类或接口指定的任意方法
Method类中用于调用成员方法的方法
- Object invoke(Object obj, Object ... args): 调用obj对象的成员方法, 参数是args, 返回值是object类型
package reflect.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectDemo5 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// 获取Class对象
Class<?> c = Class.forName("reflect.reflect.Student");
// Method[] getMethods(): 返回数组, 包含由该Class对象表示的类或接口的所有公共方法(包括继承父类的)
// Method[] getDeclaredMethods(): 返回数组, 包含由该Class对象表示的类或接口的所有方法(不包含继承的)
// Method[] methods = c.getMethods();
Method[] methods = c.getDeclaredMethods();
for(Method method: methods) {
System.out.println(method);
}
System.out.println("-------");
// Method getMethod(String name, class<?>... parameterTypes): 返回由该Class对象表示的类或接口指定的公共方法
// Method getDeclaredMethod(String name, class<?>... parameterTypes): 返回由该Class对象表示的类或接口指定的任意方法
Method method = c.getMethod("method1");
// 获取无参构造方法
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
// obj.m(); 无法调用
// 类或接口上提供有关单一方法的信息和访问权限
// Object invoke(Object obj, Object ... args): 在具有指定参数的指定对象上调用此方法表示的基础方法
// Object: 返回值类型
// obj: 调用方法的对象
// args: 方法需要的参数
method.invoke(obj); // 调用该对象的方法
/*
Student s = new Student();
s.method1();
*/
}
}
方法
package reflect.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectDemo6 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// 创建Class对象
Class<?> c = Class.forName("reflect.reflect.Student");
// 获取无参构造方法
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
// s.method1
Method m1 = c.getMethod("method1");
m1.invoke(obj);
// s.method2("林青霞")
Method m2 = c.getMethod("method2", String.class);
m2.invoke(obj, "林青霞");
// s.method3("林青霞", 30)
Method m3 = c.getMethod("method3", String.class, int.class);
Object o = m3.invoke(obj, "林青霞", 30);
System.out.println(o);
// s.function()
// Method m4 = c.getMethod("function");
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}
练习1: 实现往ArrayList
package reflect.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
往ArrayList<Integer>集合中添加字符串数据
*/
public class ReflectDemo7 {
public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
// 创建集合
ArrayList<Integer> array = new ArrayList<Integer>();
/*
array.add(10);
array.add(20);
array.add("hello"); // 不可行
*/
Class<? extends ArrayList> c = array.getClass();
Method m = c.getMethod("add", Object.class);
m.invoke(array,"hello");
m.invoke(array,"java");
m.invoke(array,"world");
// 通过反射调用方法可以跳过泛型检查
System.out.println(array);
}
}
练习2: 通过配置文件运行类中的方法
class.txt
className=reflect.reflect.fileReflect.Student
methodName=study
Student
package reflect.reflect.fileReflect;
public class Student {
public void study() {
System.out.println("好好学习");
}
}
ReflectDemo
package reflect.reflect.fileReflect;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
/*
通过配置文件运行类中的方法
*/
public class ReflectDemo8 {
public static void main(String[] args) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, InstantiationException {
/*
Student s = new Student();
s.study();
Teacher t = new Teacher();
t.teach();
// 如果我们要切换两个类方法调用, 需要来回修改代码, 很不方便
*/
// 通过配置文件调用类方法
/*
class.txt
className=xxx
methodName=xxx
*/
// 加载数据
Properties prop = new Properties();
FileReader fr = new FileReader("learn_java/src/reflect/reflect/fileReflect/class.txt");
prop.load(fr);
fr.close();
// 获取方法名和类名
String className = prop.getProperty("className");
String methodName = prop.getProperty("methodName");
// 通过反射使用
Class<?> c = Class.forName(className);
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
// 调用study方法
Method m = c.getMethod("study");
m.invoke(obj);
}
}
衣带渐宽终不悔，为伊消得人憔悴！
