1.类加载器
1.类加载器分类
JVM支持两种类型的类加载器,分别为引导类加载器(BootstrapClassLoader)和自定义类加载器(User-Defined ClassLoader)
从概念上来讲, 自定义类加载器一般指的是程序中由开发人员自定义的一类,类加载器,但是Java虚拟机规范却没有这么定义,而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器
无论类加载器的类型如何划分,在程序中我们最常见的类加载器始终只有3个
所以具体为引导类加载器(BootstrapClassLoader)和自定义类加载器（包括ExtensionClassLoader、Application ClassLoader、User Defined ClassLoader）
Application ClassLoader也叫System ClassLoader
ExtensionClassLoader、APPClassLoader都间接继承了ClassLoader。
四类加载器之间的关系可以看做是阶级关系，分为上下级，并不是子父类的继承关系。
Boot strapClassLoader由C/C++实现的，其他三类加载器是由Java实现的
2.类加载
当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接,类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤,所以有时也把这三个步骤统称为类加载或者类初始化
-
类的加载
- 就是指将class文件读入内存， 并为之创建一个java.lang.Class 对象
- 任何类被使用时， 系统都会为之建立一个java.lang.Class对象
-
类的连接
- 验证阶段: 用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
- 准备阶段: 负责为类的类变量分配内存,并设置默认初始化值
- 解析阶段: 将类的二进制数据中的符号引用替换为直接引用
-
类的初始化
- 在该阶段, 主要就是对类变量进行初始化
-
类的初始化步骤
- 假如类还未被加载和连接, 则程序先加载并连接该类
- 假如该类的直接父类还未被初始化, 则先初始化其直接父类
- 假如类中有初始化语句， 则系统依次执行这些初始化语句
- 注意：在执行第2个步骤的时候,系统对直接父类的初始化步骤也遵循初始化步骤1-3
-
类的初始化时机
- 创建类的实例（对象）
- 调用类的类方法
- 访问类或者接口的类变量， 或者为该类变量赋值
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个主类
3.类加载器
- 类加载器的作用
- 负责将.class文件加载到内存中， 并为之生成对应的java.lang.Class对象
- 虽然我们不用过分关心类加载机制， 但是了解这个机制我们就能更好的理解程序的运行
优点
避免类的重复加载
保护程序安全,防止核心API被随意篡改
JVM的类加载机制
- 全盘负责: 就是当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
- 父类委托: 就是当一个类加载器负责加载某个Class时,先让父类加载器试图加载该Class,只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
- 缓存机制: 保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class,只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据,并将其转换成Class对象，存储到缓存区
ClassLoader：是负责加载类的对象
包：java.lang.ClassLoader
ClassLoader中的两个方法
| 方法名 | 说明 |
|---|---|
| public static ClassLoader getSystemClassLoader() | 返回用于委派的系统类加载器 |
| public ClassLoader getParent() | 返回父加载器进行委派 |
| public InputStream getResourceAsStream(String name) | 加载某一个资源文件 |
Java运行时具有以下内置类加载器
- 启动类加载器Bootstrap class loader：它是虚拟机的内置类加载器，通常表示为null,并且没有父null
- 平台类加载器Platform class loader：平台类加载器可以看到所有平台类,平台类包括由平台类加载器或其祖先定义的Java SE平台API,其实现类和JDK特定的运行时类，负责JDK中的一些特殊模块
- 系统类加载器System class loader（常用）：它也被称为应用程序类加载器，与平台类加载器不同。系统类加载器通常用于定义应用程序类路径,模块路径和JDK特定工具上的类，负责加载用户路径上所指定的类库
- 类加载器的继承关系：System的父加载器为Platform,而Platform的父加载器为Bootstrap
例1
public class ClassLoaderDemo {
public static void main(String[] args) {
//static ClassLoader getSystemClassLoader()：返回用于委派的系统类加载器
ClassLoader c = ClassLoader.getSystemClassLoader();
System.out.println(c); //AppClassLoader
//ClassLoader getParent()：返回父类加载器进行委派
ClassLoader c2 = c.getParent();
System.out.println(c2); //PlatformClassLoader
ClassLoader c3 = c2.getParent();
System.out.println(c3); //null
}
}
例2
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class ClassLoaderDemo {
public static void main(String[] args) throws IOException {
//static ClassLoader getSystemClassLoader() 获取系统类加载器
//InputStream getResourceAsStream(String name) 加载某一个资源文件
//获取系统类加载器
ClassLoader systemClassLoader= ClassLoader.getSystemClassLoader();
//利用加载器去加载一个指定的文件
//参数：文件的路径
//返回值：字节流
InputStream is=systemClassLoader.getResourceAsStream("prop.properties");
Properties prop=new Properties();
prop.load(is);
System.out.println(prop);//{age=13, name=zhang san}
is.close();
}
}
2.反射
1.反射的概述
Java反射机制：是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象,调用方法的一种机制。由于这种动态性,可以极大的增强程序的灵活性,程序不用在编译期就完成确定,在运行期仍然可以扩展
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。
（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
2.反射获取Class类的对象
我们要想通过反射去使用一个类,首先我们要获取到该类的字节码文件对象,也就是类型为Class类型的对象这里我们提供三种方式获取Cass类型的对象
-
1、使用类的class属性来获取该类对应的Class对象。举例:Student.class将会返回Student类对应的Class对象
-
2、调用对象的getClass()方法, 返回该对象所属类对应的Class对象
该方法是Object类中的方法，所有的Java对象都可以调用该方法 -
3、使用Class类中的静态方法forName(String ClassName//全类名), 该方法需要传入字符串参数,该字符串参数的值是某个类的全路径,也就是完整包名的路径
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
//1、使用类的class属性来获取该类对应的Class对象
Class<Student> c1 = Student.class;
System.out.println(c1); //class test.Student
Class<Student> c2 = Student.class;
System.out.println(c1 == c2); //true;一个类只有一个字节码文件对象
//2、调用对象的getClass()方法, 返回该对象所属类对应的Class对象
Student s = new Student();
Class<? extends Student> c3 = s.getClass();
System.out.println(c1 == c3); //true
//3、使用Class类中的静态方法forName(StringclassName)
Class<?> c4 = Class.forName("test.Student");
System.out.println(c1 == c4); //true
}
}
3. 反射获取构造方法
Class类中用于获取构造方法的方法
| 方法名 | 说明 |
|---|---|
| Constructor<?>[] getConstructors() | 返回所有公共构造方法对象的数组 |
| Constructor<?>[] getDeclaredConstructors() | 返回所有构造方法对象的数组 |
| Constructor getConstructor(Class<?>… parameterTypes) | 返回单个公共构造方法对象 |
| Constructor getDeclaredConstructor(Class<?>… parameterTypes) | 返回单个构造方法对象 |
Constructor类中用来创建对象的方法
| 方法名 | 说明 |
|---|---|
| T newInstance(Object…initargs) | 根据指定的构造方法创建对象 |
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//获取Class对象
Class<?> c = Class.forName("test.Student");
//1,Constructor<?>[] getConstructors() 返回所有公共构造方法对象的数组
Constructor<?>[] cons1 = c.getConstructors();
for(Constructor con:cons1) {
System.out.println(con);
// public test.Student(java.lang.String,int,java.lang.String)
// public test.Student()
}
System.out.println("--------");
//2,Constructor<?> [] getDeclaredConstructors 返回所有构造方法对象的数组
Constructor<?>[] cons2 = c.getDeclaredConstructors();
for(Constructor con:cons2) {
System.out.println(con);
// public test.Student(java.lang.String,int,java.lang.String)
// test.Student(java.lang.String,int)
// private test.Student(java.lang.String)
// public test.Student()
}
System.out.println("--------");
/*
一、首先把这个类的带包的字符串路径传给forName()方法得到字节码文件Class对象c
二、c调用getConstructors()得到单个的构造方法对象con1
三、通过con1调用newInstance()创建一个对象，这就叫反射*/
//3,Constructor<T> getConstructor(Class<?>...parameterTypes) 返回单个公共构造方法对象
//参数是：你要获得的构造方法的参数个数和数据类型对应字节码文件
Constructor<?> con1 = c.getConstructor();
//Constructor提供了一个类的单个构造方法信息和访问权限
//5,T newInstance(Object…initargs) 根据指定的构造方法创建对象
Object obj1 = con1.newInstance();
System.out.println(obj1); //Student{name='null', age=0, address='null'}
}
}
练习
通过反射获取公共的构造方法并创建对象
学生类：
public class Student {
//成员变量：一个私有，一个默认，一个公共
private String name;
int age;
public String address;
//构造方法：一个私有，一个默认，两个公共
public Student() {
}
private Student(String name) {
this.name = name;
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
//成员方法：一个私有，四个公共
private void function() {
System.out.println("function");
}
public void method1() {
System.out.println("method");
}
public void method2(String s) {
System.out.println("method:" + s);
}
public String method3(String s, int i) {
return s + "," + i;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
测试类：
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Demo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//一、首先把这个类的带包的字符串路径传给Class类的forName()方法得到字节码文件Class对象c
Class<?> c = Class.forName("test.Student");
//public Student(String name, int age, String address)
// 二、c调用getConstructor()得到单个的构造方法对象con1
Constructor<?> con = c.getConstructor(String.class, int.class, String.class);//基本数据类型int也可以通过.class得到对应class类型
// 三、通过con调用newInstance()创建一个对象，这就叫反射
Object obj = con.newInstance("迪迦",23, "M78");
System.out.println(obj); //Student{name='迪迦', age=23, address='M78'}
}
}
4.反射获取成员变量
Class类中用于获取成员变量的方法
| 方法名 | 说明 |
|---|---|
| Field[ ] getFields() | 返回所有公共成员变量对象的数组 |
| Field[ ] getDeclaredFields() | 返回所有成员变量对象的数组 |
| Field getField(String name) | 返回单个公共成员变量对象 |
| Field getDeclaredField(String name) | 返回单个成员变量对象 |
Field类中用于给成员变量赋值的方法
| 方法名 | 说明 |
|---|---|
| void set(Object obj, Object value) | 给obj对象的成员变量赋值为value |
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class Demo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
//获取Class对象
Class<?> c = Class.forName("test.Student");
//1,Field[] getFields() 返回所有公共成员变量对象的数组
Field[] fields1 = c.getFields();
for(Field field:fields1) {
System.out.println(field);
//public java.lang.String test.Student.address
}
System.out.println("--------");
//2,Field[ ] getDeclaredFields() 返回所有成员变量对象的数组
Field[] fields2 = c.getDeclaredFields();
for(Field field:fields2) {
System.out.println(field);
// private java.lang.String test.Student.name
// int test.Student.age
// public java.lang.String test.Student.address
}
System.out.println("--------");
/*
一、首先把这个类的带包的字符串路径传给forName()方法得到字节码文件Class对象c
二、通过c调用getField()得到成员变量对象addressField
三、addressField调用set()方法给obj对象的address赋值*/
//3,Field getField(String name) 返回单个公共成员变量对象
Field addressField = c.getField("address");
System.out.println(addressField);
//public java.lang.String test.Student.address
//获取无参构造方法创建对象
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
//5,void set(Object obj, Object value) 给obj对象的成员变量赋值为value
addressField.set(obj,"成都"); //给obj的成员变量addressField》address赋值为成都
System.out.println(obj); //Student{name='null', age=0, address='成都'}
}
}
练习
通过反射获取成员变量并赋值
学生类：同上
测试类：
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class Demo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
//一、首先把这个类的带包的字符串路径传给forName()方法得到字节码文件Class对象c
Class<?> c = Class.forName("test.Student");
//二、通过c调用getConstructor()创建无参构造方法对象
Constructor<?> con = c.getConstructor();
//三、通过con调用newInstance()创建一个对象
Object obj = con.newInstance();
//四、通过c调用getDeclaredField()得到成员变量对象
Field nameField = c.getDeclaredField("name");
nameField.setAccessible(true); //取消私有变量的访问检查
//五、成员变量对象调用set()方法给obj对象的成员变量赋值
nameField.set(obj,"迪迦");
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj,23);
Field addressField = c.getDeclaredField("address");
addressField.setAccessible(true);
addressField.set(obj,"M78");
System.out.println(obj); //Student{name='迪迦', age=23, address='M78'}
}
}
5.反射获取成员方法并使用
Class类中获取成员方法的方法
| 方法名 | 说明 |
|---|---|
| Method[ ] getMethods() | 返回所有公共成员方法对象的数组,包括继承的 |
| Method[ ] getDeclaredMethods() | 返回所有成员方法对象的数组,不包括继承的 |
| Method getMethod(String name, Class<?> … parameterTypes) | 返回单个公共成员方法对象 |
| Method getDeclaredMethod(String name, Class<?> … parameterTypes) | 返回单个成员方法对象 |
Method类中用于调用成员方法的方法
| 方法名 | 说明 |
|---|---|
| Object invoke(Object obj, Objet… args) | 调用obj对象的成员方法，参数是args,返回值是Object类型 |
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Demo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//获取Class对象
Class<?> c = Class.forName("test.Student");
//1,Method[ ] getMethods() 返回所有公共成员方法对象的数组,包括继承的
Method[] methods1 = c.getMethods();
for(Method method:methods1) {
System.out.println(method);
// public java.lang.String test.Student.toString()
// public void test.Student.method1()
// public void test.Student.method3()
// public void test.Student.method2()
// public final void java.lang.Object.wait() throws java.lang.InterruptedException
// public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
// ...
}
System.out.println("---------");
//2,Method[ ] getDeclaredMethods() 返回所有成员方法对象的数组,不包括继承的
Method[] methods2 = c.getDeclaredMethods();
for(Method method:methods2) {
System.out.println(method);
// public java.lang.String test.Student.toString()
// private void test.Student.function()
// public void test.Student.method1()
// public void test.Student.method3()
// public void test.Student.method2()
}
//3,Method getMethod(String name, Class<?> … parameterTypes) 返回单个公共成员方法对象
Method m = c.getMethod("method1");
//获取无参构造方法并创建对象
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
//5,Object invoke(Object obj, Objet… args) 调用obj对象的成员方法，参数是args,返回值是Object类型
//第一个Object：返回值类型；obj：对象；args：方法需要的参数
m.invoke(obj); //method1
}
}
练习
通过反射获取成员方法并赋值
学生类：同上
测试类：
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Demo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//一、首先把这个类的带包的字符串路径传给forName()方法得到字节码文件Class对象c
Class<?> c = Class.forName("test.Student");
//二、通过c调用getConstructor()创建无参构造方法对象
Constructor<?> con = c.getConstructor();
//三、通过con调用newInstance()创建一个对象
Object obj = con.newInstance();
//四、通过字节码文件对象调用getMethod()方法得到method方法对象
Method m1 = c.getMethod("method1");
Method m2 = c.getMethod("method2", String.class);
Method m3 = c.getMethod("method3", String.class, int.class);
Method m4 = c.getDeclaredMethod("function");
//五、通过method方法对象调用invoke()方法
m1.invoke(obj); //method1
m2.invoke(obj,"迪迦"); //method2:迪迦
Object o = m3.invoke(obj, "赛罗", 24);
System.out.println(o); //赛罗,24
m4.setAccessible(true);
m4.invoke(obj); //function
}
}
扫一扫
907
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
