08#.Java SE中：JAVA基础中的 类的加载器、反射、暴力反射
反射
知识点–类加载器
目标
- 理解类在什么时候加载,以及如何获取类加载器
路径
- 类的加载
- 类的加载时机
- 类加载器
讲解
类的加载
当我们的程序在运行后，第一次使用某个类的时候，会将此类的class文件读取到内存，并将此类的所有信息存储到一个Class对象中
类的加载时机
-
创建类的实例。
-
类的静态变量，或者为静态变量赋值。
-
类的静态方法。
-
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。
-
初始化某个类的子类。
-
直接使用java.exe命令来运行某个主类。
以上六种情况的任何一种，都可以导致JVM将一个类加载到方法区。
public class Test {
public static void main(String[] args) throws Exception{
// 类的加载时机
// 1. 创建类的实例。
// Student stu = new Student();
// 2. 类的静态变量，或者为静态变量赋值。
// Person.country = "中国";
// 3. 类的静态方法。
// Person.method();
// 4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。
// Class c = Class.forName("com.hyperqi.demo1_类的加载.Student");
// 5. 初始化某个类的子类。
// Zi zi = new Zi();
// 6. 直接使用java.exe命令来运行某个主类。
}
}
类加载器
类加载器：是负责将磁盘上的某个class文件读取到内存并生成Class的对象。
- Java中有三种类加载器，它们分别用于加载不同种类的class：
- 启动类加载器(Bootstrap ClassLoader)：用于加载系统类库
\bin目录下的class，例如：rt.jar。 - 扩展类加载器(Extension ClassLoader)：用于加载扩展类库
\lib\ext目录下的class。 - 应用程序类加载器(Application ClassLoader)：用于加载我们自定义类的加载器。
- 启动类加载器(Bootstrap ClassLoader)：用于加载系统类库
public class Test{
public static void main(String[] args){
// 获取类加载器:
// 获取Student类的类加载器
System.out.println(Student.class.getClassLoader());// AppClassLoader
// 获取String类的类加载器
System.out.println(String.class.getClassLoader());// null
// API中说明：一些实现可能使用null来表示引导类加载器。 如果此类由引导类加载器加载，则此方法将在此类实现中返回null
}
}
小结
略
知识点–反射的概述
目标
- 理解反射的概念
路径
- 反射的引入
- 反射的概念
- 使用反射操作类成员的前提
- 射在实际开发中的应用
讲解
反射的引入
- 问题：IDEA中的对象是怎么知道类有哪些属性，哪些方法的呢？
通过反射技术对象类进行了解剖得到了类的所有成员。
反射的概念
反射是一种机制，利用该机制可以在程序运行过程中对类进行解剖并操作类中的所有成员(成员变量，成员方法，构造方法)
使用反射操作类成员的前提
要获得该类字节码文件对象，就是Class对象
反射在实际开发中的应用
* 开发IDE(集成开发环境)，比如IDEA,Eclipse
* 各种框架的设计和学习 比如Spring，Hibernate，Struct，Mybaits....
小结
- 通过反射技术去获取一个类的成员变量,成员方法,构造方法…,并可以访问
知识点–Class对象的获取方式
目标
- 能够获取一个类的Class对象
路径
- 通过类名.class获得
- 通过对象名.getClass()方法获得
- 通过Class类的静态方法获得： static Class forName(“类全名”)
讲解
* 方式1: 通过类名.class获得
* 方式2：通过对象名.getClass()方法获得
* 方式3：通过Class类的静态方法获得： static Class forName("类全名")
* 每一个类的Class对象都只有一个。
- 示例代码
package com.hyperqi.demo2_Class对象的获取;
public class Student {
private String name;
public void method1(){
}
}
public class Test {
public static void main(String[] args) throws Exception{
/*
Class对象的获取:
通过类名.class获得
通过对象名.getClass()方法获得
通过Class类的静态方法获得： static Class forName("类全名")
*/
// 1.方式一:通过类名.class获得
Class<Student> c1 = Student.class;
System.out.println(c1);
// 2.方式二:通过对象名.getClass()方法获得
Student stu = new Student();
Class<? extends Student> c2 = stu.getClass();
System.out.println(c2);
// 3.方式三:通过Class类的静态方法获得： static Class forName("类全名")
Class<?> c3 = Class.forName("com.hyperqi.demo2_Class对象的获取.Student");
System.out.println(c3);
// 问题:一个类只有一个字节码对象(Class对象)
System.out.println(c1 == c2);// true
System.out.println(c1 == c3);// true
}
}
小结
略
知识点–Class类常用方法
目标
- Class类的常用方法
路径
- Class类的常用方法
讲解
String getSimpleName(); 获得类名字符串：类名
String getName(); 获得类全名：包名+类名
T newInstance() ; 创建Class对象关联类的对象
- 示例代码
public class ReflectDemo02 {
public static void main(String[] args) throws Exception {
// 获得Class对象
Class c = Student.class;
// 获得类名字符串：类名
System.out.println(c.getSimpleName());
// 获得类全名：包名+类名
System.out.println(c.getName());
// 创建对象
Student stu = (Student) c.newInstance();
System.out.println(stu);
}
}
小结
略
知识点–反射之操作构造方法
目标
- 通过反射获取类的构造方法,并执行构造方法
路径
- Constructor类概述
- 通过反射获取类的构造方法
- 通过反射执行构造方法
讲解
Constructor类概述
反射之操作构造方法的目的
* 获得Constructor对象来创建类的对象。
Constructor类概述
* 类中的每一个构造方法都是一个Constructor类的对象
通过反射获取类的构造方法
Class类中与Constructor相关的方法
1. Constructor getConstructor(Class... parameterTypes)
* 根据参数类型获得对应的Constructor对象。
* 只能获得public修饰的构造方法
2. Constructor getDeclaredConstructor(Class... parameterTypes)
* 根据参数类型获得对应的Constructor对象
* 可以是public、protected、(默认)、private修饰符的构造方法。
3. Constructor[] getConstructors()
获得类中的所有构造方法对象，只能获得public的
4. Constructor[] getDeclaredConstructors()
获得类中的所有构造方法对象
可以是public、protected、(默认)、private修饰符的构造方法。
通过反射执行构造方法
Constructor对象常用方法
1. T newInstance(Object... initargs)
根据指定的参数创建对象
2. void setAccessible(true)
设置"暴力反射"——是否取消权限检查，true取消权限检查，false表示不取消
示例代码
package com.hyperqi.demo4_反射之构造方法;
public class Student {
// 属性
public String name;// 姓名
public String sex;// 性别
public int age;// 年龄
// 构造方法
public Student() {
}
public Student(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
private Student(String name, int age) {
this.name = name;
this.age = age;
}
// 成员方法
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
}
public class Test1 {
public static void main(String[] args) throws Exception{
/*
- 通过反射获取类的构造方法,并执行构造方法创建该类的对象
- Constructor类概述
概述:类中的每一个构造方法都是一个Constructor类的对象
通过反射获取类的构造方法,其实就是获取该构造方法对于的Constructor对象
- 通过反射获取类的构造方法: 使用Class类中的方法
我们每一个类都会有一个对于的Class对象,所以该类中的构造方法就在我们的Class对象中,
所以可以使用Class对象获取构造方法
Class类中与Constructor相关的方法
1. Constructor getConstructor(Class... parameterTypes) 获取单个public修饰的构造方法
* 根据参数类型获得对应的Constructor对象。
* 只能获得public修饰的构造方法
2. Constructor getDeclaredConstructor(Class... parameterTypes) 获取单个构造方法
* 根据参数类型获得对应的Constructor对象
* 可以是public、protected、(默认)、private修饰符的构造方法。
3. Constructor[] getConstructors() 获取所有public修饰的构造方法
获得类中的所有构造方法对象，只能获得public的
4. Constructor[] getDeclaredConstructors() 获取所有构造方法
获得类中的所有构造方法对象
可以是public、protected、(默认)、private修饰符的构造方法。
记忆方法:
1. 加了s的就是获取多个,不加s的就是获取单个
2. 加了Declared的就是获取任意修饰符修饰的构造方法,不加就只能获取public修饰的构造方法
小结:
Constructor getDeclaredConstructor(Class... parameterTypes) 获取单个构造方法
Constructor[] getDeclaredConstructors() 获取所有构造方法
- 通过反射执行构造方法:使用Constructor对象中的方法,来执行该对象表示的构造方法
Constructor对象常用方法
1. T newInstance(Object... initargs)
根据指定的参数创建对象
2. void setAccessible(true)
设置"暴力反射"——是否取消权限检查，true取消权限检查，false表示不取消
*/
// 0.获取Student类的Class对象
Class<?> c = Class.forName("com.hyperqi.demo4_反射之构造方法.Student");
// 1.获取单个public修饰的构造方法
// Constructor getConstructor(Class... parameterTypes) 获取单个public修饰的构造方法
// 参数:传入你要获取的构造方法的参数类型的Class对象
// 获取Student类的空参构造方法
Constructor<?> cons1 = c.getConstructor();
System.out.println(cons1);
// 获取Student类的带有三个参数的构造方法,并且参数的类型顺序为:String,String,int
Constructor<?> cons2 = c.getConstructor(String.class,String.class, int.class);
// public Student(String name,String sex,int.class);
// public Student(String name,int.class,String sex);
System.out.println(cons2);
// 2.获取单个非public修饰的构造方法
// Constructor getDeclaredConstructor(Class... parameterTypes) 获取单个构造方法
// 参数:传入你要获取的构造方法的参数类型的Class对象
// 获取Student类的带有2个参数的构造方法,并且参数的类型顺序为:String,int
Constructor<?> cons3 = c.getDeclaredConstructor(String.class, int.class);
System.out.println(cons3);
System.out.println("============================================");
// 3.获取多个public修饰的方法
// Constructor[] getConstructors() 获取所有public修饰的构造方法
Constructor<?>[] conArr1 = c.getConstructors();
for (Constructor<?> con : conArr1) {
System.out.println(con);
}
System.out.println("============================================");
// 4.获取所有修饰的方法
// Constructor[] getDeclaredConstructors() 获取所有构造方法
Constructor<?>[] conArr2 = c.getDeclaredConstructors();
for (Constructor<?> con : conArr2) {
System.out.println(con);
}
}
}
public class Test2 {
public static void main(String[] args) throws Exception{
/*
- 获取类的构造方法:
Constructor getDeclaredConstructor(Class... parameterTypes) 获取单个构造方法
Constructor[] getDeclaredConstructors() 获取所有构造方法
- 通过反射执行构造方法:使用Constructor对象中的方法,来执行该对象表示的构造方法
Constructor对象常用方法
1. T newInstance(Object... initargs)
根据指定的参数创建对象
参数: 传入执行该构造方法需要的实际参数
2. void setAccessible(boolean b)
设置"暴力反射"——是否取消权限检查，true取消权限检查，false表示不取消
*/
// 获取Student类的Class对象
Class<?> c = Class.forName("com.hyperqi.demo4_反射之构造方法.Student");
// 1.获取public修饰的构造方法对象,并执行该对象表示的构造方法来创建对象
// 1.1 获取public修饰的构造方法对象 public Student(String name, String sex, int age)
Constructor<?> cons1 = c.getDeclaredConstructor(String.class, String.class, int.class);
// 1.2 执行该对象表示的构造方法来创建对象
Object obj = cons1.newInstance("张三", "女", 18);// 真正返回的是Student对象
System.out.println(obj);// Student{name='张三', sex='女', age=18}
System.out.println("==========================================");
// 2.获取private修饰的构造方法对象,并执行该对象表示的构造方法来创建对象
// 2.1 获取private修饰的构造方法对象
Constructor<?> cons2 = c.getDeclaredConstructor(String.class, int.class);
// 2.2 执行该对象表示的构造方法来创建对象
// 设置"暴力反射"
cons2.setAccessible(true);
Object obj2 = cons2.newInstance("李四", 19);
System.out.println(obj2);
}
}
小结
略
知识点–反射之操作成员方法
目标
- 通过反射获取类的成员方法,并执行成员方法
路径
- Method类概述
- 通过反射获取类的成员方法
- 通过反射执行成员方法
讲解
Method类概述
反射之操作成员方法的目的
* 操作Method对象来调用成员方法
Method类概述
* 每一个成员方法都是一个Method类的对象。
通过反射获取类的成员方法
* Method getMethod(String name,Class...args);
* 根据方法名和参数类型获得对应的成员方法对象，只能获得public的
* Method getDeclaredMethod(String name,Class...args); 掌握
* 根据方法名和参数类型获得对应的成员方法对象，包括public、protected、(默认)、private的
* Method[] getMethods();
* 获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的
* Method[] getDeclaredMethods(); 掌握
* 获得类中的所有成员方法对象，返回数组,只获得本类的，包括public、protected、(默认)、private的
通过反射执行成员方法
Method对象常用方法
* Object invoke(Object obj, Object... args)
* 调用指定对象obj的该方法
* args：调用方法时传递的参数
* void setAccessible(true)
设置"暴力访问"——是否取消权限检查，true取消权限检查，false表示不取消
示例代码
ackage com.hyperqi.demo5_反射之操作成员方法;
/**
* @Author：hyperqi
* @Date: 2020/7/25 10:13
*/
public class Student {
public void show1(){
System.out.println("public 修饰的show1方法,无参数...");
}
public void show1(String str,int num){
System.out.println("public 修饰的show1方法,2个参数...");
System.out.println("str:"+str+",num:"+num);
}
public void show2(){
System.out.println("public 修饰的show2方法...");
}
private void show3(){
System.out.println("private 修饰的show3方法...");
}
}
package com.hyperqi.demo5_反射之操作成员方法;
import java.lang.reflect.Method;
/**
* @Author：hyperqi
* @Date: 2020/7/25 11:03
*/
public class Test1 {
public static void main(String[] args) throws Exception {
/*
反射之操作成员方法:
- 通过反射获取类的成员方法,并通过反射技术执行成员方法
- Method类概述
每一个成员方法都是一个Method类的对象。
- 通过反射获取类的成员方法
Class类中与Method相关的方法
* Method getMethod(String name,Class...args); 获取单个public修饰的成员方法
* 根据方法名和参数类型获得对应的构造方法对象，只能获得public的
* Method getDeclaredMethod(String name,Class...args); 获取任意修饰符修饰的单个成员方法
* 根据方法名和参数类型获得对应的构造方法对象，包括public、protected、(默认)、private的
* Method[] getMethods(); 获取所有public修饰的成员方法
* 获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的
* Method[] getDeclaredMethods(); 获取所有成员方法
* 获得类中的所有成员方法对象，返回数组,只获得本类的，包括public、protected、(默认)、private的
记忆:
Method getDeclaredMethod(String name,Class...args); 获取任意修饰符修饰的单个成员方法\
Method[] getDeclaredMethods(); 获取所有成员方法
- 通过反射执行成员方法
*/
// 1.获取Student类的Class对象
Class<?> c = Class.forName("com.hyperqi.demo5_反射之操作成员方法.Student");
// 2.获取单个成员方法
// 2.1 获取单个public修饰的方法
// Method getMethod(String name,Class...args);
// 第一个参数: 方法名
// 第二个参数: 该方法的参数类型的Class对象,如果没有参数就不传入
Method show1M1 = c.getMethod("show1");// 第一个show1方法
System.out.println(show1M1);
Method show1M2 = c.getMethod("show1", String.class, int.class);
System.out.println(show1M2);
// 2.2 获取单个private修饰的成员方法
// Method getDeclaredMethod(String name,Class...args);
// 第一个参数: 方法名
// 第二个参数: 该方法的参数类型的Class对象,如果没有参数就不传入
Method show3M = c.getDeclaredMethod("show3");
System.out.println(show3M);
System.out.println("=======================");
// 3.获取多个public修饰的成员方法
// 3.1 获取所有public修饰的成员方法
// Method[] getMethods();
Method[] mArr1 = c.getMethods();
for (Method method : mArr1) {
System.out.println(method);
}
System.out.println("=======================");
// 3.2 获取所有的成员方法
// Method[] getDeclaredMethods();
Method[] mArr2 = c.getDeclaredMethods();
for (Method method : mArr2) {
System.out.println(method);
}
}
}
package com.hyperqi.demo5_反射之操作成员方法;
import java.lang.reflect.Method;
/**
* @Author：hyperqi
* @Date: 2020/7/25 11:33
*/
public class Test2 {
public static void main(String[] args) throws Exception {
/*
Method getDeclaredMethod(String name,Class...args); 获取任意修饰符修饰的单个成员方法\
Method[] getDeclaredMethods(); 获取所有成员方法
通过反射技术执行成员方法:
Method对象常用方法
* Object invoke(Object obj, Object... args)
* 参数1: 调用该方法的对象
* 参数2：调用方法时传递的实际参数,如果方法没有参数,就不传
* void setAccessible(true)
设置"暴力访问"——是否取消权限检查，true取消权限检查，false表示不取消
*/
// 0.获取Student类的Class对象
Class<?> c = Class.forName("com.hyperqi.demo5_反射之操作成员方法.Student");
// 1.通过反射获取public修饰的成员方法对象,并通过反射执行该方法
// 1.1 通过反射获取public修饰的成员方法对象
Method show1M = c.getDeclaredMethod("show1", String.class, int.class);
// 1.2 通过反射执行该方法
Student stu = new Student();// 使用反射创建对象:通过反射获取构造方法对象,执行该构造方法
show1M.invoke(stu,"itheima",14);
System.out.println("=======================");
// 2.通过反射获取private修饰的成员方法对象,并通过反射执行该方法
// 2.1 通过反射获取private修饰的成员方法对象
Method show3M = c.getDeclaredMethod("show3");
// 2.2 通过反射执行该方法
// 设置暴力反射
show3M.setAccessible(true);
show3M.invoke(stu);
}
}
小结
略
知识点–反射之操作成员变量【自学】
目标
- 通过反射获取类的成员变量,并访问成员变量
路径
- Field类概述
- 通过反射获取类的成员变量
- 通过反射访问成员变量
讲解
Field类概述
反射之操作成员变量的目的
* 通过Field对象给对应的成员变量赋值和取值
Field类概述
* 每一个成员变量都是一个Field类的对象。
通过反射获取类的成员变量
Class类中与Field相关的方法
* Field getField(String name);
* 根据成员变量名获得对应Field对象，只能获得public修饰
* Field getDeclaredField(String name);
* 根据成员变量名获得对应Field对象，包括public、protected、(默认)、private的
* Field[] getFields();
* 获得所有的成员变量对应的Field对象，只能获得public的
* Field[] getDeclaredFields();
* 获得所有的成员变量对应的Field对象，包括public、protected、(默认)、private的
通过反射访问成员变量
Field对象常用方法
void set(Object obj, Object value)
void setInt(Object obj, int i)
void setLong(Object obj, long l)
void setBoolean(Object obj, boolean z)
void setDouble(Object obj, double d)
Object get(Object obj)
int getInt(Object obj)
long getLong(Object obj)
boolean getBoolean(Object ob)
double getDouble(Object obj)
void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。
Class getType(); 获取属性的类型，返回Class对象。
setXxx方法都是给对象obj的属性设置使用，针对不同的类型选取不同的方法。
getXxx方法是获取对象obj对应的属性值的，针对不同的类型选取不同的方法。
示例代码
package com.hyperqi.demo6_反射之操作成员变量;
/**
* @Author：hyperqi
* @Date: 2020/7/25 10:13
*/
public class Student {
public String name;// 姓名
public int age;// 年龄
private String sex;// 性别
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
public class Test1 {
public static void main(String[] args) throws Exception{
/*
反射之操作成员变量:
- Field类概述 : 每一个成员变量都是一个Field类的对象。
- 通过反射获取类的成员变量
Class类中与Field相关的方法
* Field getField(String name);获取单个public修饰的成员变量
* 根据成员变量名获得对应Field对象，只能获得public修饰
* Field getDeclaredField(String name);获取单个任意修饰符修饰的成员变量
* 根据成员变量名获得对应Field对象，包括public、protected、(默认)、private的
* Field[] getFields();获取所有的public修饰的成员变量
* 获得所有的成员变量对应的Field对象，只能获得public的
* Field[] getDeclaredFields();获取所有的成员变量
* 获得所有的成员变量对应的Field对象，包括public、protected、(默认)、private的
结论:
Field getDeclaredField(String name);获取单个任意修饰符修饰的成员变量
参数:成员变量名 字符串类型
Field[] getDeclaredFields();获取所有的成员变量
- 通过反射访问成员变量
*/
// 通过反射获取类的成员变量
// 1.获取Student类的Class对象
Class<?> c = Class.forName("com.hyperqi.demo6_反射之操作成员变量.Student");
// 2. 获取单个成员变量的Field对象
// 2.1 获取单个public修饰的成员变量
Field nameF = c.getDeclaredField("name");
System.out.println(nameF);
// 2.2 获取单个private修饰的成员变量
Field sexF = c.getDeclaredField("sex");
System.out.println(sexF);
System.out.println("==============================================");
// 3.获取所有的成员变量的Field对象
Field[] fieldArr = c.getDeclaredFields();
for (Field field : fieldArr) {
System.out.println(field);
}
}
}
public class Test2 {
public static void main(String[] args) throws Exception {
/*
通过反射获取类的成员变量
Field getDeclaredField(String name);获取单个任意修饰符修饰的成员变量
参数:成员变量名 字符串类型
Field[] getDeclaredFields();获取所有的成员变量
通过反射访问成员变量:
Field对象常用方法
为成员变量设置值的方法
void set(Object obj, Object value) 记住
参数1: 要赋值属性的对象
参数2: 属性具体的值
获取成员变量值的方法
Object get(Object obj) 记住
参数: 要获取属性值的对象
返回值: 属性具体的值
void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。 记住
Class getType(); 获取属性的类型，返回Class对象。
*/
// 通过反射获取类的成员变量
// 1.获取Student类的Class对象
Class<?> c = Class.forName("com.hyperqi.demo6_反射之操作成员变量.Student");
// 2. 获取单个成员变量的Field对象
// 2.1 获取单个public修饰的成员变量
Field nameF = c.getDeclaredField("name");
// 2.2 通过反射为name属性赋值
Student stu = new Student();
nameF.set(stu,"张三");
Field ageF = c.getDeclaredField("age");
// ageF.set(stu,18);
ageF.setInt(stu,19);
System.out.println(stu);// Student{name='张三', age=18, sex='null'}
// 2.3 获取某个属性的值
System.out.println(nameF.get(stu));// 张三
System.out.println(ageF.get(stu));// 19
// 2.2 获取单个private修饰的成员变量
Field sexF = c.getDeclaredField("sex");
// 暴力反射
sexF.setAccessible(true);
sexF.set(stu,"李四");
// 获取
System.out.println(sexF.get(stu));// 李四
// 获取nameF属性的类型
Class<?> c1 = nameF.getType();
System.out.println(c1);// class java.lang.String
}
}