Java 类加载&反射&模块化

最新推荐文章于 2021-08-20 10:50:55 发布

小马code

最新推荐文章于 2021-08-20 10:50:55 发布

阅读量212

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_44016361/article/details/119544209

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

类加载&反射&模块化

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化来对类进行初始化。如果不出意外，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化

类的加载：

就是将class文件读入内存，并为其创建一个java.lang.Class对象
任何类被使用时，系统都会为之建立一个java.lang.Class对象

类的连接：

验证阶段：用于检验被加载的类是否有正确的内部结构，并和其它类协调一致
准备阶段：负责为类的类变量分配内存，并设置默认初始化值
解析阶段：将类的二进制数据中的符号引用替换为直接引用

类的初始化：

在该阶段，主要是对类变量进行初始化

类加载

类的初始化步骤

假如类还未被加载和连接，则程序先加载并连接该类
假如该类的直接父类还未被初始化，则先初始化其直接父类
假如类中有初始化语句，则系统依次执行这些初始化语句

类的初始化时机：

创建类的实例
调用类的类方法
访问类或者接口的类变量，或者为该类变量赋值
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

类加载器

类加载器的通

负责将.class文件加载到内存中，并为之生成对应的java.lang.Class对象

JVM的类加载机制

全盘负责
父类委托
缓存机制

ClassLoader：是负责加载类的对象

Java运行时具有以下内置类加载器

Bootstrap class loader：是虚拟机的内置类加载器，通常表示为null
Platform class loader：平台类加载器
System class loader：应用程序类加载器
类加载器的继承关系：System的父加载器为Platform，Platform的父加载器为Bootstrap

ClassLoader中的两个方法

static ClassLoader getSystemClassLoader()：返回用于委派的系统类加载器
ClassLoader getParent()：返回父类加载器进行委派

反射

Java反射机制：是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍可以扩展

获取Class类的对象

我们要想通过反射区使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class的对象，有三种方法获取Class类型的对象

使用类的class属性来获取该类对应的Class对象。Student.class
调用对象的getClass()方法返回该对象所属类对应的Class对象，该方法是Object类中的方法，所有的Java对象都可以调用该方法
使用CLass类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整包名的路径

/**
 * @author: 小码农
 * @create: 2021-08-09 10:50
 **/
public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性获取对应的clss对象
        Class<Student> c1 = Student.class;
        Class<Student> c2 = Student.class;
        System.out.println(c1);
        System.out.println(c2==c1);
        System.out.println("---------------");
        //.getClass
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1==c3);
        System.out.println("-----------------");
        //forName
        Class<?> c4 = Class.forName("Student");
        System.out.println(c1==c4);
    }
}

反射获取构造方法并使用

Class类中用于获取构造方法的方法

getConstructors()方法，返回对象的公共构造函数数组
getDeclaredConstructors()方法，返回对象的所有构造函数数组，公共、私有、默认
获取对象单个的构造方法getConstructor，返回单个公共构造方法
getDeclaredConstructor()方法，返回单个构造方法对象，包含公共、私有默认

Constructor类中用于创建对象的方法

T newInstance(Object … initargs)：根据指定的构造方法创建对象

练习

练习1：通过反射实现如下操作

Student s = new Student(“林青霞”,30,“西安”);
System.out.println(s);
基本数据类型可以通过.class得到对应的类型

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author: 小码农
 * @create: 2021-08-09 11:47
 **/
public class Demo4 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<Student> s = Student.class;
        Constructor<Student> con = s.getConstructor(String.class, int.class, String.class);
        Student stu = con.newInstance("林青霞", 33, "西安");
        System.out.println(stu);
    }
}

练习2

Student s = new Student(“林青霞”);
System.out.println(s);
public void setAccessible(boolean b)：值为true，取消访问检查

Constructor<Student> de1 = s.getDeclaredConstructor(String.class);
//暴力反射 public void setAccessible(boolean b)：值为true，取消访问检查
de1.setAccessible(true);
Student stu2 = de1.newInstance("林青霞");
System.out.println(stu2);

反射获取成员变量并使用

Class类中用于获取成员变量的方法

Field[] getFields()：返回所有公共成员变量对象的数组
Field[] getDeclaredFields()：返回所有成员变量对象的数组
Field getField(String name)：返回单个公共成员变量对象
Field getDeclaredField(String name)：返回单个成员变量对象

Field类中用于给成员变量赋值的方法

void set(Object o,Object value)：给obj对象的成员变量赋值为value
public void setAccessible(boolean b)：值为true，取消访问检查

import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Calendar;

/**
 * @author: 小码农
 * @create: 2021-08-09 15:26
 **/
public class Demo5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> s1 = Class.forName("Student");
        /*
        Field[] getFields()返回一个包含Field对象的数组
        Field[] getDeclaredFields()返回一个包含Field对象的数组，包含私有默认
         */
//        Field[] fields = s1.getFields();
        Field[] fields = s1.getDeclaredFields();
        for (Field f:fields){
            System.out.println(f);
        }
        System.out.println("----------------");
        //Field getField 返回Field对象
        //Field getDeclaredField 返回Field对象
        Field address = s1.getField("address");
        //获取无参构造方法创建对象
        Constructor<?> con = s1.getConstructor();
        Object o = con.newInstance();
        //对成员变量赋值
        address.set(o,"西安");
        System.out.println(o);
    }
}

反射获取成员变量并使用练习

练习：通过反射做到以下操作

Student s = new Student();
s.name = “林青霞”;
s.age = 30;
s.address = “西安”;
System.out.println(s);

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
 * @author: 小码农
 * @create: 2021-08-09 15:42
 **/
public class Demo6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> stu = Class.forName("Student");
        Field name = stu.getDeclaredField("name");
        Field age = stu.getDeclaredField("age");
        Field address = stu.getField("address");
        name.setAccessible(true);   //私有变量使用setAccessible取消检查


        Constructor<?> con = stu.getConstructor();
        Object obj = con.newInstance();
        name.set(obj,"李红");
        age.set(obj,33);
        address.set(obj,"陕西");
        System.out.println(obj);
    }
}

反射获取成员方法并使用

Class类中用于获取成员方法的方法

Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()：返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name)：根据传入的方法名称，返回单个公共成员方法对象
Method getDeclaredMethod(String name)：返回单个成员方法对象

Method类中用于调用成员方法的方法

Object invoke(Object obj,Object…args)：调用obj对象的成员方法，参数是args，返回值是Object类型
```
成员方法对象.invoke(obj);
```

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author: 小码农
 * @create: 2021-08-09 15:52
 **/
public class Demo7 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //第一步获取Class对象
        Class<?> stu = Class.forName("Student");
        Constructor<?> con = stu.getConstructor();
        Object obj = con.newInstance();

        //返回方法对象数组
        /*Method[] getMethods()返回一个包含方法对象的数组，包含所有公共方法
        Method[] getDeclaredMethods()返回包含所有方法对象的数组，包含私有、默认*/
//        Method[] methods = stu.getMethods();
        Method[] methods = stu.getDeclaredMethods();
        for (Method method:methods){
            System.out.println(method);
        }

        //返回单个方法getMethod
        Method toString = stu.getMethod("toString");

        //返回单个方法，私有方法可以用 getDeclaredMethod()
        Method method2 = stu.getDeclaredMethod("method2", String.class);

        System.out.println("---------------");
        //我们获取方法对象可以使用反射做什么,可以通过对象调方法
        Object invoke = toString.invoke(obj);
        System.out.println(invoke);
        Object ssss = method2.invoke(obj, "ssss");
        System.out.println(ssss);
    }
}

练习：通过反射实现如下操作

Student s = new Student();
s.method1();
s.method2(“林青霞”);
String ss = s.method3(“林青霞”,30);
System.out.println(ss);
s.function();

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author: 小码农
 * @create: 2021-08-09 16:09
 **/
public class Demo8 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //创建Class对象
        Class<?> stu = Class.forName("Student");

        //通过Class对象获取构造方法
        Constructor<?> con = stu.getConstructor();

        //通过构造方法对象创建Student对象
        Object obj = con.newInstance();

        //创建成员方法对象
        Method method1 = stu.getDeclaredMethod("method1");
        method1.setAccessible(true);
        Method method2 = stu.getDeclaredMethod("method2", String.class);
        method2.setAccessible(true);
        Method method3 = stu.getDeclaredMethod("method3", String.class, int.class);
        method3.setAccessible(true);

        Method func = stu.getDeclaredMethod("function");
        func.setAccessible(true);

        //使用成员方法
        method1.invoke(obj);    //没有返回值
        method2.invoke(obj, "李红");  //没有返回值

        Object in3 = method3.invoke(obj, "王伟", 33);
        System.out.println(in3);

        func.invoke(obj);

    }
}

/**
 * @author: 小码农
 * @create: 2021-08-09 11:19
 **/
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("method1");
    }
    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 + '\'' +
                '}';
    }
}

反射练习

练习1：在一个ArrayList<Integer>集合中添加一个字符串数据

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * @author: 小码农
 * @create: 2021-08-09 16:30
 * 练习1：在一个ArrayList<Integer>集合中添加一个字符串数据
 **/
public class Demo9 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //创建集合
        ArrayList<Integer> arrayList = new ArrayList<>();

        arrayList.add(10);
        arrayList.add(20);
        //传统的添加方法无法添加字符串元素，我们使用反射越过添加类型检查
        Class<? extends ArrayList> c = arrayList.getClass();
        Method meth = c.getDeclaredMethod("add", Object.class);
        meth.invoke(arrayList,"hello");
        meth.invoke(arrayList,"world");

        System.out.println(arrayList);
    }
}

练习2：通过配置文件运行类中的方法

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;

/**
 * @author: 小码农
 * @create: 2021-08-09 16:35
 * 练习2：通过配置文件运行类中的方法
 **/
public class Demo10 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, IOException, ClassNotFoundException, InstantiationException {
        /*Stu stu = new Stu();
        Class<? extends Stu> s = stu.getClass();
        Method study = s.getDeclaredMethod("study");
        study.setAccessible(true);
        study.invoke(stu);*/

        /*  使用配置文件
            class.txt
            className = xxx
            methodName = xxx
         */
        //加载数据
        Properties prop = new Properties();
        FileReader fr = new FileReader("E:\\MYZ\\Code\\JAVA\\20210809\\src\\Class.txt");
        prop.load(fr);
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        //通过反射来使用
        Class<?> c = Class.forName(className);
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        Method m = c.getDeclaredMethod(methodName);
        m.invoke(obj);

    }
}

Class.txt

className = Tea
methodName = teach

模块化

概述

如今，java语言过于庞大，无论是运行小程序还是运行一个大型程序，都需要JVM加载整个JRE环境。因此Java 9退出了模块化系统，允许Java程序可以根据需要选择加载必须的Java模块。

模块的基本使用

基本使用步骤

创建模块，按照以前的讲解方式创建模块，创建包，创建类，定义方法
- 为了体现模块的使用，我们创建两个模块，一个是myOne，一个是myTwo
在模块的src目录下新建一个名为moudule-info.java的描述性文件，该文件专门定义模块名，访问权限，模块依赖等信息。描述性文件中使用模块导出和模块依赖来进行配置并使用（JDK 9以上才有）
模块中所有未导出的包都是模块私有的，它们不能在模块之外被访问
- 在myOne这个模块下的描述性文件转给你配置模块导出
- 模块导出格式：exports 包名
一个模块要访问其他的模块，必须明确指定依赖哪些模块，未明确指定依赖的模块不能访问。在myTwo这个模块下的描述性文件中配置模块依赖
- 模块依赖格式：requires 模块名;
- 注意：写模块名报错，需要按Alt+Enter提示，然后选择模块依赖
现在，在myTwo模块的类中可以使用依赖模块下的内容

总结：

简单来说就是在被使用类模块的描述性文件中需要导出包含类的包，exports 包名
在使用者模块的描述性文件中要依赖被使用模块，requires 被使用类模块名

模块服务的使用

服务：从Java6开始，Java提供了一种服务机制，允许服务提供者和服务使用者之间完成解耦，简单来说，就是服务使用者只面向接口编程，但不清楚服务提供者的实现类

Java 9模块化系统进一步简化了Java的服务机制。Java 9允许将服务接口定义在一个模块中，并使用uses语句来声明该服务接口，然后针对该服务接口提供不同的服务实现类，这些服务实现类可以分布在不同的模块中，服务实现模块则使用provides语句为服务接口指定实现类，服务使用者只需要面向接口编程即可

模块服务的使用步骤

在myOne模块下创建一个包com.itheima_03，在该包下提供一个接口，接口中定义一个抽象方法
- ```
public interface MyServer{
	void service();
}
```
在com.itheima_03包下创建一个包impl，在该包下提供接口的两个实现类Itheima和Czxy
在myOne这个模块下的描述性文件中添加配置：
- 模块导出：exports com.itheima_03
- 服务提供：provides MyServer with Itheima; 指定MyServer的服务实现类是Itheima
在myTwo这个模块下的描述文件中添加配置
- 声明服务接口：uses MyService;
在myTwo模块的类中使用Myservice接口提供的服务
- ServiceLoader：一种加载服务实现的工具

package cn.itcast;
import com.myz03.MyServer;
import java.util.ServiceLoader;

/**
 * @author: 小码农
 * @create: 2021-08-09 18:09
 **/
public class Demo2 {
    public static void main(String[] args) {
        //加载服务
        ServiceLoader<MyServer> load = ServiceLoader.load(MyServer.class);

        //遍历服务
        for (MyServer ser:load){
            ser.service();
        }
    }
}

小马code

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 类加载&反射&模块化

类加载&反射&模块化当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化来对类进行初始化。如果不出意外，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化类的加载：就是将class文件读入内存，并为其创建一个java.lang.Class对象任何类被使用时，系统都会为之建立一个java.lang.Class对象类的连接：验证阶段：用于检验被加载的类是否有正确的内部结构，并和其它类协调一致准备阶段：负责为类的
复制链接

扫一扫