第十二章 类加载器&反射
12.1、类加载器
12.1.1、类加载
当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载、类的连接、类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化
12.1.2、类初始化过程
- 类的加载
- 就是指将class文件读入内存，并为之创建一个java.lang.Class对象
- 任何类被使用时，系统都会为之建立一个java.lang.Class对象
- 类的连接
- 验证阶段：用于检验被加载的类是否有正确的内部结构并和其它类协调一致
- 准备阶段：负责为类的类变量分配内存并设置默认初始化值
- 解析阶段：将类的二进制数据中的符号引用替换为直接引用
- 类的初始化：在该阶段，主要就是对类变量进行初始化
- 假如类还未被加载和连接，则程序先加载并连接该类
- 假如该类的直接父类还未被初始化，则先初始化其直接父类
- 假如类中有初始化语句，则系统依次执行这些初始化语句
- 注意：在执行第2个步骤的时候，系统对直接父类的初始化步骤也遵循初始化步骤1-3
12.1.3、类初始化时机
- 创建类的实例
- 调用类的方法
- 访问类、接口的变量或者为该类变量赋值
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个主类
12.1.4、类加载器
概述：负责将.class文件加载到内存中并为之生成对应的 java.lang.Class 对象
Bootstrap class loader：它是虚拟机的内置类加载器，通常表示为null 并且没有父加载器
Platform class loader：它是平台类加载器，它可以看到所有平台类 ：包括由平台类加载器或其祖先定义的Java SE平台API，其实现类和JDK特定的运行时类
System class loader：它是系统类加载器也被称为应用程序类加载器 ，与平台类加载器不同。 它通常用于定义应用程序类路径和JDK特定工具上的类
注意：类加载器的继承关系：System的父加载器为Platform，而Platform的父加载器为Bootstrap
12.1.5、类加载机制
全盘负责：当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
父类委托：当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
缓存机制：保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据并将其转换成 Class对象存储到缓存区
12.1.6、ClassLoader类
public class Demo {
public static void main(String[] args) {
ClassLoader c = ClassLoader.getSystemClassLoader();
System.out.println(c); // AppClassLoader
ClassLoader c2 = c.getParent();
System.out.println(c2); // PlatformClassLoader
ClassLoader c3 = c2.getParent();
System.out.println(c3); // null
}
}
12.2、反射
12.2.1、概述
反射是指在运行时去获取一个类的变量和方法信息，然后通过获取到的信息来创建对象，调用方法的一种机制。 由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展
12.2.2、获取Class类对象
class Student {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
public class Main {
public static void main(String[] args) throws ClassNotFoundException {
// 方法1：使用类的class属性来获取该类对应的Class对象
Class<Student> c1 = Student.class;
System.out.println(c1);
// 方法2：调用对象的getClass()方法，返回该对象所属类对应的Class对象
Class<? extends Student> c2 = new Student().getClass();
System.out.println(c2);
// 方法3：使用Class类中的静态方法forName(String className)
Class<?> c3 = Class.forName("Student");
System.out.println(c3);
}
}
12.2.3、反射获取构造方法
方法描述：
| 方法 | 描述 |
|---|---|
| public Constructor<?>[] getConstructors() | 返回一个包含Constructor对象的数组，不包含私有构造 |
| public Constructor getConstructor(Class<?>... parameterTypes) | 返回一个指定的Constructor对象，不包含私有构造 |
| public Constructor<?>[] getDeclaredConstructors() | 返回一个包含Constructor对象的数组，包含私有构造 |
| public Constructor getConstructor(Class<?>... parameterTypes) | 返回一个指定的Constructor对象，包含私有构造 |
方法演示：
import java.lang.reflect.Constructor;
class Student {
// 成员变量：一个私有，一个默认，一个公共
private String name;
int age;
public String address;
// 构造方法：一个私有，一个默认，两个公共
private Student(String name) {
this.name = name;
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
public Student(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
// 成员方法：两个私有，两个默认，两个公共
private String getName() {
System.out.println("getName");
return name;
}
private void setName(String name) {
System.out.println("setName:" + name);
this.name = name;
}
int getAge() {
System.out.println("getAge");
return age;
}
void setAge(int age) {
System.out.println("setAge:" + age);
this.age = age;
}
public String getAddress() {
System.out.println("getAddress");
return address;
}
public void setAddress(String address) {
System.out.println("setAddress:" + address);
this.address = address;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", address=" + address + "]";
}
}
public class Main {
public static void main(String[] args) throws Exception {
Class<Student> c = Student.class;
// 获取所有公开的构造方法
Constructor<?>[] constructors = c.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
System.out.println("--------------------");
// 获取指定参数且公开的构造方法
Constructor<Student> constructor = c.getConstructor(String.class, int.class, String.class);
System.out.println(constructor);
System.out.println("--------------------");
// 获取所有权限的构造方法
Constructor<?>[] declaredConstructors = c.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor);
}
System.out.println("--------------------");
// 获取指定参数且不限的构造方法
Constructor<Student> declaredConstructor = c.getDeclaredConstructor(String.class);
System.out.println(declaredConstructor);
}
}
12.2.4、反射获取成员变量
方法描述：
| 方法 | 描述 |
|---|---|
| public Field[] getFields() | 返回一个包含Field对象的数组，不包含私有变量 |
| public Field getField(String name) | 返回一个指定的Field对象，不包含私有变量 |
| public Field[] getDeclaredFields() | 返回一个包含Field对象的数组，包含私有变量 |
| public Field getDeclaredField(String name) | 返回一个指定的Field对象，包含私有变量 |
方法演示：
import java.lang.reflect.Field;
class Student {
// 成员变量：一个私有，一个默认，一个公共
private String name;
int age;
public String address;
// 构造方法：一个私有，一个默认，两个公共
private Student(String name) {
this.name = name;
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
public Student(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
// 成员方法：两个私有，两个默认，两个公共
private String getName() {
System.out.println("getName");
return name;
}
private void setName(String name) {
System.out.println("setName:" + name);
this.name = name;
}
int getAge() {
System.out.println("getAge");
return age;
}
void setAge(int age) {
System.out.println("setAge:" + age);
this.age = age;
}
public String getAddress() {
System.out.println("getAddress");
return address;
}
public void setAddress(String address) {
System.out.println("setAddress:" + address);
this.address = address;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", address=" + address + "]";
}
}
public class Main {
public static void main(String[] args) throws Exception {
Class<Student> c = Student.class;
// 获取所有公开的成员变量
Field[] fields = c.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("--------------------");
// 获取指定名称且公开的成员变量
Field field = c.getField("address");
System.out.println(field);
System.out.println("--------------------");
// 获取所有权限的成员变量
Field[] declaredFields = c.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
System.out.println("--------------------");
// 获取指定名称且不限的成员变量
Field declaredField = c.getDeclaredField("name");
System.out.println(declaredField);
}
}
12.2.5、反射获取成员方法
方法概述：
| 方法 | 描述 |
|---|---|
| public Method[] getMethods() | 返回一个包含Method对象的数组，不包含私有成员方法 |
| public Method getMethod(String name, Class<?>... parameterTypes) | 返回一个指定的Method对象，不包含私有成员方法 |
| public Method[] getDeclaredMethods() | 返回一个包含Method对象的数组，包含私有成员方法 |
| public Method getDeclaredMethod(String name, Class<?>... parameterTypes) | 返回一个指定的Method对象，包含私有成员方法 |
方法演示：
import java.lang.reflect.Method;
class Student {
// 成员变量：一个私有，一个默认，一个公共
private String name;
int age;
public String address;
// 构造方法：一个私有，一个默认，两个公共
private Student(String name) {
this.name = name;
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
public Student(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
// 成员方法：两个私有，两个默认，两个公共
private String getName() {
System.out.println("getName");
return name;
}
private void setName(String name) {
System.out.println("setName:" + name);
this.name = name;
}
int getAge() {
System.out.println("getAge");
return age;
}
void setAge(int age) {
System.out.println("setAge:" + age);
this.age = age;
}
public String getAddress() {
System.out.println("getAddress");
return address;
}
public void setAddress(String address) {
System.out.println("setAddress:" + address);
this.address = address;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", address=" + address + "]";
}
}
public class Main {
public static void main(String[] args) throws Exception {
Class<Student> c = Student.class;
// 获取所有公开的成员方法，它反映此类或接口或从超类和超级接口继承的类的声明方法
Method[] methods = c.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("--------------------");
// 获取指定参数且公开的成员方法，它反映此类或接口或从超类和超级接口继承的类的声明方法
Method method = c.getMethod("setAddress", String.class);
System.out.println(method);
System.out.println("--------------------");
// 获取所有权限的成员方法，它反映此类或接口的声明方法
Method[] declaredMethods = c.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
System.out.println("--------------------");
// 获取指定参数且不限的成员方法，它反映此类或接口的声明方法
Method declaredMethod = c.getDeclaredMethod("setName", String.class);
System.out.println(declaredMethod);
}
}
12.2.6、综合案例
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
class Student {
// 成员变量：一个私有，一个默认，一个公共
private String name;
int age;
public String address;
// 构造方法：一个私有，一个默认，两个公共
private Student(String name) {
this.name = name;
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
public Student(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
// 成员方法：两个私有，两个默认，两个公共
private String getName() {
System.out.println("getName");
return name;
}
private void setName(String name) {
System.out.println("setName:" + name);
this.name = name;
}
int getAge() {
System.out.println("getAge");
return age;
}
void setAge(int age) {
System.out.println("setAge:" + age);
this.age = age;
}
public String getAddress() {
System.out.println("getAddress");
return address;
}
public void setAddress(String address) {
System.out.println("setAddress:" + address);
this.address = address;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", address=" + address + "]";
}
}
public class Main {
public static void main(String[] args) throws Exception {
// 获取学生类类对象
Class<Student> c = Student.class;
// 通过无参构造创建
Constructor<Student> constructor = c.getConstructor();
Student newStudent = constructor.newInstance();
System.out.println(newStudent);
System.out.println("--------------------");
// 反射设置成员变量
Field name = c.getDeclaredField("name");
name.setAccessible(true);
name.set(newStudent, "张三丰");
Field age = c.getDeclaredField("age");
age.setAccessible(true);
age.set(newStudent, 55);
Field address = c.getDeclaredField("address");
address.setAccessible(true);
address.set(newStudent, "武当山");
System.out.println(newStudent);
System.out.println("--------------------");
// 反射执行成员方法
Method getName = c.getDeclaredMethod("getName");
getName.setAccessible(true);
getName.invoke(newStudent);
Method setAge = c.getDeclaredMethod("setAge", int.class);
setAge.setAccessible(true);
setAge.invoke(newStudent, 60);
System.out.println(newStudent);
}
}
12.2.7、动态代理
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface UserDao {
public abstract void add();
public abstract void delete();
public abstract void update();
public abstract void find();
}
class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("添加功能");
}
@Override
public void delete() {
System.out.println("删除功能");
}
@Override
public void update() {
System.out.println("修改功能");
}
@Override
public void find() {
System.out.println("查找功能");
}
}
class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("权限校验");
Object result = method.invoke(target, args);
System.out.println("日志记录");
System.out.println();
return result;
}
}
public class Main {
public static void main(String[] args) throws Exception {
UserDao ud1 = new UserDaoImpl();
ud1.add();
ud1.delete();
ud1.update();
ud1.find();
System.out.println("----------");
UserDao ud2 = new UserDaoImpl();
MyInvocationHandler handler = new MyInvocationHandler(ud2);
UserDao ud2Proxy = (UserDao) Proxy.newProxyInstance(ud2.getClass().getClassLoader(), ud2.getClass().getInterfaces(), handler);
ud2Proxy.add();
ud2Proxy.delete();
ud2Proxy.update();
ud2Proxy.find();
}
}
第十二章 类加载器&反射的更多相关文章
- 深入了解java虚拟机（JVM） 第十二章 类加载器
一.什么是类加载器 类加载器是一个用来加载类文件的类,Java源代码通过javac编译器编译成类文件,然后JVM来执行类文件中的字节码来执行程序.需要注意的是,只有被同一个类加载器加载的类才可能会相等 ...
- Introduction to 3D Game Programming with DirectX 12 学习笔记之 --- 第十二章：几何着色器（The Geometry Shader）
原文:Introduction to 3D Game Programming with DirectX 12 学习笔记之 --- 第十二章:几何着色器(The Geometry Shader) 代码工 ...
- JVM详解（二）-- 第2章 类加载器子系统
一.JVM内存结构 1.1 内存结构---概略图 1.2 内存结构--详细图 二.类加载器子系统的作用 类加载器子系统负责从文件系统或网络中加载.Class文件,文件需要有特定的标识(cafe bab ...
- 第十二章——SQLServer统计信息（3）——发现过期统计信息并处理
原文:第十二章--SQLServer统计信息(3)--发现过期统计信息并处理 前言: 统计信息是关于谓词中的数据分布的主要信息源,如果不知道具体的数据分布,优化器不能获得预估的数据集,从而不能统计需要 ...
- 第十二章——SQLServer统计信息（1）——创建和更新统计信息
原文:第十二章--SQLServer统计信息(1)--创建和更新统计信息 简介: 查询的统计信息: 目前为止,已经介绍了选择索引.维护索引.如果有合适的索引并实时更新统计信息,那么优化器会选择有用的索 ...
- 第十二章——SQLServer统计信息（2）——非索引键上统计信息的影响
原文:第十二章--SQLServer统计信息(2)--非索引键上统计信息的影响 前言: 索引对性能方面总是扮演着一个重要的角色,实际上,查询优化器首先检查谓词上的统计信息,然后才决定用什么索引.一般情 ...
- 《Django By Example》第十二章 中文 翻译 （个人学习，渣翻）
书籍出处:https://www.packtpub.com/web-development/django-example 原作者:Antonio Melé (译者注:第十二章,全书最后一章,终于到这章 ...
- 第二十二章 Django会话与表单验证
第二十二章 Django会话与表单验证 第一课 模板回顾 1.基本操作 def func(req): return render(req,'index.html',{'val':[1,2,3...]} ...
- Gradle 1.12用户指南翻译——第二十二章. 标准的 Gradle 插件
其他章节的翻译请参见: http://blog.csdn.net/column/details/gradle-translation.html 翻译项目请关注Github上的地址: https://g ...
随机推荐
- js修改函数内部的this指向(bind,call,apply)
js修改函数内部的this指向 在调用函数的时候偶尔在函数内部会使用到this,在使用this的时候发现并不是我们想要指向的对象.可以通过bind,call,apply来修改函数内部的this指向. ...
- 我终于弄懂了Python的装饰器（二）
此系列文档: 1. 我终于弄懂了Python的装饰器(一) 2. 我终于弄懂了Python的装饰器(二) 3. 我终于弄懂了Python的装饰器(三) 4. 我终于弄懂了Python的装饰器(四) 二 ...
- requests接口自动化6-Body里json格式数据形式的post请求：json
Body里json格式数据形式的post请求:用json传参 fiddler里请求响应内容: 传递的json数据 [{"stepId":"0","ca ...
- Flask 基础组件（二）：配置文件
配置参数 flask中的配置文件是一个flask.config.Config对象(继承字典),默认配置为: { 'DEBUG': get_debug_flag(default=False), 是否开启 ...
- python 装饰器（八）：装饰器实例（五）函数装饰器装饰类以及类方法
函数装饰器装饰类 单例模式 from functools import wraps def singleton(cls): instances = {} @wraps(cls) def get_ins ...
- XML解析---利用XStream解析xml数据及反构造Java对象
XStream 是一个轻量级的.简单易用的开放源代码 Java库,用于将 Java 对象序列化为 XML 或者再转换回来.而且XStream还能将java对象转成其它格式,比如JSon. 需要用到的包 ...
- 测试工程师想进BAT必须具备的几项素质
我发现一个奇怪的现象:总是听到身边的程序员朋友谈论BAT(中国大陆互联网的三大巨头:百度.阿里.腾讯)以及如何进入BAT,却鲜少有测试会去谈论或者考虑这些问题. 我不知道这是为什么,或者我就算知道也只 ...
- scratch编程滑雪者游戏教程
首先我们来看一下效果: 我们从演示中能看出4个角色:企鹅.大树.旗子和装饰用的坎,我们通过键盘操控企鹅滑雪躲避树并捡起旗子,现在我们就来看看是怎么编的吧! 首先我们要画 ...
- mysqldump导出表结构及数据
问题描述:有需要mysql某几张表的需求,某个数据库某几张表,导出先检查相应的数据库和表是否存在 数据泵用法:默认导出的是表结构以及表中的数据 mysqldump -uroot -p -S /data ...
- accpet和connect设置超时
三次握手 TCP连接建立的开始是三次握手,通过三次交互确认连接成功,在客户端调用connect时,客户端发送sync消息给服务端,服务端收到sync消息后,返回一个ack+sync,并等待ack,客户 ...