Java核心类库之（类加载器、反射机制、模块化）(1)

最新推荐文章于 2024-05-16 15:30:42 发布

2401_84002594

最新推荐文章于 2024-05-16 15:30:42 发布

阅读量713

点赞数 30

分类专栏：程序员文章标签： java python 开发语言

本文链接：https://blog.csdn.net/2401_84002594/article/details/138315275

版权

程序员专栏收录该内容

196 篇文章 0 订阅

订阅专栏

Class<?> c = Class.forName(“test.Student”);

//private Student(String name)

//二、通过c调用getConstructor()创建无参构造方法对象

Constructor<?> con = c.getDeclaredConstructor(String.class);

//三、通过con调用newInstance()创建一个对象

// Object obj = con.newInstance(“小黑”);

// System.out.println(obj); //IllegalAccessException：没法访问异常：private修饰的私有构造方法

//暴力反射:public void setAccessible(boolean flag)：值为true，取消访问检查

con.setAccessible(true);

Object obj = con.newInstance(“小黑”);

System.out.println(obj); //Student{name=‘小黑’, age=0, address=‘null’}

}

2.4 反射获取成员变量并使用

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

| 方法名 | 说明 |

| — | — |

| Field[ ] getFields() | 返回所有公共成员变量对象的数组 |

| Field[ ] getDeclaredFields() | 返回所有成员变量对象的数组 |

| Field getField(String name) | 返回单个公共成员变量对象 |

| Field getDeclaredField(String name) | 返回单个成员变量对象 |

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

| 方法名 | 说明 |

| — | — |

| void set(Object obj, Object value) | 给obj对象的成员变量赋值为value |

package test;

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=‘成都’}

}

案例：

在这里插入图片描述

package test;

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,10);

Field addressField = c.getDeclaredField(“address”);

addressField.setAccessible(true);

addressField.set(obj,“成都”);

System.out.println(obj); //Student{name=‘小黑’, age=10, address=‘成都’}

}

2.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类型 |

package test;

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

}

案例：

在这里插入图片描述

Student类

package test;

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(“method2:” + s);

}

public String method3(String s, int i) { return s + “,” + i; }

@Override

public String toString() {

return “Student{” +

“name='” + name + ‘’’ +

“, age=” + age +

“, address='” + address + ‘’’ +

‘}’;

}

测试类

package test;

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, “小白”, 10);

System.out.println(o); //小白,10

m4.setAccessible(true);

m4.invoke(obj); //function

}

2.6 案例

2.6.1案例1：通过反射往`ArrayList<Integer>`集合中，添加字符串数据

package test;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.ArrayList;

public class Demo {

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

ArrayList array = new ArrayList<>();

// array.add(“小黑”); 报错

Class<? extends ArrayList> c = array.getClass();

Method m = c.getMethod(“add”, Object.class); //因为Object是泛型没有指定数据类型

m.invoke(array, “小黑”);

System.out.println(array); //[小黑, 小黑, 小黑]

}

2.6.2 案例2：通过配置文件运行类中的方法

Student类

package test;

public class Student {

public void study() {

System.out.println(“好好学习天天向上”);

}

class.txt配置文件

className=test.Student

methodName=study

测试类

package test;

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 Demo {

public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

//加载数据

Properties prop = new Properties();

FileReader fr = new FileReader(“E:\test\Demo\class.txt”);

prop.load(fr);

fr.close();

System.out.println(prop); //{methodName=study, className=test.Student}

String className = prop.getProperty(“className”);

String methodName = prop.getProperty(“methodName”);

//通过反射来使用

Class<?> c = Class.forName(className); //test.Student

Constructor<?> con = c.getConstructor();

Object obj = con.newInstance();

Method m = c.getMethod(methodName);//study

m.invoke(obj); //好好学习天天向上

//class.txt中只需要改文件路径和方法名

}

3 模块化

3.1 模块化概述

Java语言随着这些年的发展已经成为了一]影响深远的编程语言，无数平台,系统都采用Java语言编写。但是，伴随着发展，Java也越来越庞大，逐渐发展成为-门“臃肿” 的语言。而且，无论是运行个大型的软件系统，还是运行一一个小的程序，即使程序只需要使用Java的部分核心功能，JVM也要加载整个JRE环境。
为了给Java“瘦身”，让ava实现轻量化，Java 9正式的推出了模块化系统。Java被拆分为N多个模块，并允许Java程序可以根据需要选择加载程序必须的Java模块，这样就可以让ava以轻星化的方式来运行
模块结构

在这里插入图片描述

3.2 模块的基本使用

模块的创建步骤

在这里插入图片描述

使用不同模块下的内容

更多：Java进阶核心知识集

包含：JVM，JAVA集合，网络，JAVA多线程并发，JAVA基础，Spring原理，微服务，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存等等

高效学习视频

G4ubmV0L3l1YW4yMDE5MDM1MDU1,size_16,color_FFFFFF,t_70)

在这里插入图片描述

使用不同模块下的内容

更多：Java进阶核心知识集

[外链图片转存中…(img-LjbNSzEX-1714376470949)]

高效学习视频

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

2401_84002594

关注

30
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Java核心类库之（类加载器、反射机制、模块化）(1)

Java语言随着这些年的发展已经成为了一]影响深远的编程语言，无数平台,系统都采用Java语言编写。但是，伴随着发展，Java也越来越庞大，逐渐发展成为-门“臃肿” 的语言。而且，无论是运行个大型的软件系统，还是运行一一个小的程序，即使程序只需要使用Java的部分核心功能，JVM也要加载整个JRE环境。为了给Java“瘦身”，让ava实现轻量化，Java 9正式的推出了模块化系统。
复制链接

扫一扫