【Java笔记】Reflection的一个实践（模拟框架的服务管理与服务注入）

已于 2024-03-30 14:37:41 修改
阅读量1.2k 收藏 17
点赞数 48
分类专栏： Java 文章标签： java 开发语言
于 2024-03-29 10:01:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hansdas/article/details/137135127
版权

文章目录

前言&Reference

最近在学一些理论知识（背八股），在看AOP相关的资料的时候看到了Reflection：
（开始吟唱）Spring AOP的实现基于动态代理，动态代理的实现有两种方式：

  • JDK动态代理：代理实现接口的类，通过实现接口实现对目标方法的增强，通过反射（比如先通过Class.getMethod()等方法获得Method，再Method.invoke()）调用方法；
  • CGLIB动态代理：代理未实现接口的类，通过【子类继承父类】的方式继承目标类，重写目标方法实现增强，直接调用重写的增强方法

那么这个反射具体是怎么实现“代理”的过程，完成服务的管理与注入？
可以参考AlbertShen的这个视频
本文也是跟着这个视频学习的一个记录
代码都放github了

0. 需求

通过一个订单Order对象获取用户User信息和地址Address信息

1. 常规方法

Address address = new Address("99 Shangda Road", "114514");
Customer customer = new Customer("Hansdas", "Hansdas@xx.com");
Order order = new Order(customer, address);
order.getCustomer().printName();
order.getAddress().printStreet();

【缺陷】在面对动态场景时存在限制，一旦代码完成，就无法动态创建对象或调用方法

2. 反射方法实现

2.1 定义Config类与Container类

  • 先定义一个Config类：用于定义Customer服务与Address服务，通过对应方法进行实例化并返回需要的对象

    public class Config {
    public Customer customer(){
        // 定义Customer服务与Address服务，通过对应方法进行实例化并返回需要的对象
        return new Customer("Hansdas", "hansdas@xx.com");
    }

    public Address address(){
        return new Address("99 Shandda Road", "114514");
    }

    public Message message(){
        return new Message("Hi there!");
    }
}

  • 再定义一个Container类：注册和获得实例

    public class Container {
    // 创建一个Map类型来存放Config里的所有方法
    // K: 方法返回的Class，V：对应的方法
    // 注意：这里存储的时=是方法本身，而不是方法执行后获得的实例（具体实例在执行这些方法后获取，这样可以节省资源并提高性能）
    private Map<Class<?>, Method> methods;
    private Object config; // 用于存放config实例

    // 初始化注册加载所有的方法和实例化Config对象
    public void init() throws ClassNotFoundException {
        Class<?> clazz = Class.forName("Config");
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method: methods){
            System.out.println(method.getName());
        }
    }
}

2.2 使用注解过滤得到目标方法

比如上述Config中，我们只需要customer()与address()，不需要message()，可以在customer()与address()加自定义注解，通过Method.getDeclaredAnnotation()过滤。

  • 自定义一个Bean

    @Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Bean {
    
}

  • 在Config中为需要的方法加上注解

    public class Config {
    @Bean
    public Customer customer(){
        // 定义Customer服务与Address服务，通过对应方法进行实例化并返回需要的对象
        return new Customer("Hansdas", "hansdas@xx.com");
    }
    @Bean
    public Address address(){
        return new Address("99 Shandda Road", "114514");
    }

    public Message message(){
        return new Message("Hi there!");
    }
}

  • 修改Container init() 中注册服务的过程

    public void init() throws ClassNotFoundException {
    Class<?> clazz = Class.forName("Config");
    Method[] methods = clazz.getDeclaredMethods();
    for (Method method: methods){
        if (method.getDeclaredAnnotation(Bean.class) != null){
            // 如果有Bean注解的话就来处理这个方法
            System.out.println(method.getName());
        }
    }
}

2.3 使用Map在Container中进行管理

2.3.1 通过Map管理目标实例方法

前面Container中有个Map类型的methods属性

// 创建一个Map类型来存放Config里的所有方法
// K: 方法返回的Class，V：对应的方法
// 注意：这里存储的时=是方法本身，而不是方法执行后获得的实例（具体实例在执行这些方法后获取，这样可以节省资源并提高性能）
private Map<Class<?>, Method> methods;

  • 在Container的init()中，将需要的Method加入methods的map中，并实例化config用于之后调用方法服务与对象

    public void init() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        this.methods = new HashMap<>();
        Class<?> clazz = Class.forName("Config");
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method: methods){
            if (method.getDeclaredAnnotation(Bean.class) != null){
                // 如果有Bean注解的话就来处理这个方法
                this.methods.put(method.getReturnType(), method);
            }
        }
        this.config = clazz.getConstructor().newInstance();
 }

  • 在Container中写一个getServiceInstanceByClass方法，通过类的class对象获取相应的服务实例

    public Object getServiceInstanceByClass(Class<?> clazz) throws InvocationTargetException, IllegalAccessException {
	   // 使用Class对象作为Key，在事先初始化的map中查找对应的方法
	   // 找到了相应的方法就执行该方法，返回对应的实例化服务对象
	  if (this.methods.containsKey(clazz)){
	      Method method = this.methods.get(clazz);
	      Object obj = method.invoke(this.config);
	      return obj;
	  }
	  return null;
}

  • main中测试一下能否根据class拿到相应对象

    public static void main(String[] args) throws IllegalAccessException, ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException {
    Container container = new Container();
    container.init();
    Class<?> clazz = Class.forName("Customer");
    Object obj = container.getServiceInstanceByClass(clazz);
    System.out.println(obj);

}

    输出如下，成功拿到

    Customer@21b8d17c

这里成功通过该方法获得了一个对象实例，但此时每次调用这个方法获取一个实例时，都会创建一个新对象，有的服务是全局的，希望只创建一次，之后就复用这个实例，因此可以增加一个Map来维护这个对实例的唯一性

2.3.2 通过Map实现目标的唯一性

创建一个Map来存储已经创建的实例，在init()中初始化，并修改 getServiceInstanceByClass 返回实例的流程，修改后的Container如下：

public class Container {
    // 创建一个Map类型来存放Config里的所有方法
    // K: 方法返回的Class，V：对应的方法
    // 注意：这里存储的时=是方法本身，而不是方法执行后获得的实例（具体实例在执行这些方法后获取，这样可以节省资源并提高性能）
    private Map<Class<?>, Method> methods;
    private Object config; // 用于存放config实例
    private Map<Class<?>, Object> services; // 存放已经创建的对象实例

    // 初始化注册加载所有的方法和实例化Config对象
    public void init() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        this.methods = new HashMap<>();
        this.services = new HashMap<>();
        Class<?> clazz = Class.forName("Config");
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method: methods){
            if (method.getDeclaredAnnotation(Bean.class) != null){
                // 如果有Bean注解的话就来处理这个方法
                this.methods.put(method.getReturnType(), method);
            }
        }
        this.config = clazz.getConstructor().newInstance();
    }

    public Object getServiceInstanceByClass(Class<?> clazz) throws InvocationTargetException, IllegalAccessException {
        if (this.services.containsKey(clazz)){
            // 如果已经创建过这个class的实例，直接返回
            return this.services.get(clazz);
        }else{
            // 如果没有创建过这个class的实例：
            // 使用Class对象作为Key，在事先初始化的map中查找对应的方法，找到了相应的方法就执行该方法，返回对应的实例化服务对象
            if (this.methods.containsKey(clazz)){
                Method method = this.methods.get(clazz);
                Object obj = method.invoke(this.config);
                this.services.put(clazz, obj);
                return obj;
            }
            return null;
        }

    }
}

2.4 实现服务自动注入

在Container中定义一个createInstance方法，用于通过Class对象创建普通实例，并且将服务自动注入到对象中

2.4.1 获取目标对象的构造器

  • 增加createInstance方法，通过Class.getDeclaredConstructors() 获取目标的构造器

    public Object createInstance(Class<?> clazz) throws NoSuchMethodException {
    Constructor<?>[] constructors =  clazz.getDeclaredConstructors();
    for (Constructor<?> constructor : constructors){
        System.out.println(constructor);
    }
    return null;
}

  • 在main中测试一下

    public class Main {
    public static void main(String[] args) throws IllegalAccessException, ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException {
        Container container = new Container();
        container.init();
        Class<?> clazz = Class.forName("Order");
        container.createInstance(clazz);
    }
}

    输出如下，成功拿到Order的两个构造器

    public Order(Customer, Address)
public Order()

2.4.2 通过注解获得指定构造器

上面已经成功拿到了目标对象Order的连个给构造器，与前面2.2相同，具体获取哪一个可以通过注解选择

  • 定义一个Autowired注解

    @Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
public @interface Autowired {
}

  • 在Order中需要的构造函数上加注解

    public class Order {
    private Customer customer;
    private Address address;

    @Autowired
    public Order(Customer customer, Address address) {
        this.customer = customer;
        this.address = address;
    }
	...
}

  • 修改createInstance，根据注解进行过滤

    public Object createInstance(Class<?> clazz) throws NoSuchMethodException {
    Constructor<?>[] constructors =  clazz.getDeclaredConstructors();
    for (Constructor<?> constructor : constructors){
        if (constructor.getDeclaredAnnotation(Autowired.class) != null){
            System.out.println(constructor);
        }
    }
    return null;
}

  • 在main里测试一下，只有加了Autowired注解的有参构造了

    public Order(Customer, Address)

2.4.3 通过构造器实例化对象

  • 修改createInstance

  • public Object createInstance(Class<?> clazz) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
    Constructor<?>[] constructors =  clazz.getDeclaredConstructors();
    for (Constructor<?> constructor : constructors){
        if (constructor.getDeclaredAnnotation(Autowired.class) != null){
            // 获取所有的参数类型
            Class<?>[] parameterTypes = constructor.getParameterTypes();
            // 存储参数的对象实例
            Object[] arguements = new Object[parameterTypes.length];
            for (int i = 0; i < parameterTypes.length; i++) {
                arguements[i] = getServiceInstanceByClass(parameterTypes[i]);
            }
            return constructor.newInstance(arguements);
        }
    }
    // 无Autowired注解直接通过无参构造返回实例
    return clazz.getDeclaredConstructor().newInstance();
}

  • 注入测试

    public static void main(String[] args) throws IllegalAccessException, ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException {
    Container container = new Container();
    container.init();
    Class<?> clazz = Class.forName("Order");
    Object obj = container.createInstance(clazz);
    Field field = clazz.getDeclaredField("customer");
    field.setAccessible(true);
    Object fieldValue = field.get(obj);
    System.out.println(fieldValue);
}

    输出如下，获取到Customer服务对象，注入成功

    Customer@41cf53f9

2.4.4 调用服务对象的方法

  • 在main中通过Class.getDeclaredMethods获得服务对象的所有方法，print一下

    Method[] methods = fieldValue.getClass().getDeclaredMethods();
for (Method method: methods){
    System.out.println(method.getName());
}

    输出如下，成功拿到Customer的方法

    getName
printEmail
printName
getEmail

    这里获得了Customer的所有方法，如果想要获取带print的方法，也只需要加上注解即可

  • 定义Printable注解

    @Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Printable {
}

  • 在print相关方法上增加注解

    public class Customer {
		...

    @Printable
    public void printName(){
        System.out.println("Customer email: "+ name);
    }
    @Printable
    public void printEmail(){
        System.out.println("Customer email: "+ email);
    }
}

  • 测试增加约束，过滤掉不含Printable注解的方法

    Method[] methods = fieldValue.getClass().getDeclaredMethods();
for (Method method: methods){
    if (method.getDeclaredAnnotation(Printable.class) != null){
        System.out.println(method.getName());
    }
}

    输出如下，成功

    printName
printEmail

  • Main中使用Method.invoke执行方法

    Method[] methods = fieldValue.getClass().getDeclaredMethods();
for (Method method: methods){
    if (method.getDeclaredAnnotation(Printable.class) != null){
        method.invoke(fieldValue);
    }
}

    输出

    Customer email: Hansdas
Customer email: hansdas@xx.com

  • 也可以把类名与变量名放到变量里，方便配置，最终的Main如下

    public static void main(String[] args) throws IllegalAccessException, ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException {
        Container container = new Container();
        container.init();
        String className = "Order";
        String fieldName = "customer";
        Class<?> clazz = Class.forName(className);
        Object obj = container.createInstance(clazz);
        Field field = clazz.getDeclaredField(fieldName);
        field.setAccessible(true);
        Object fieldValue = field.get(obj);
        Method[] methods = fieldValue.getClass().getDeclaredMethods();
        for (Method method: methods){
            if (method.getDeclaredAnnotation(Printable.class) != null){
                method.invoke(fieldValue);
            }
        }
 }

2.5 其他测试

如果要换一下class跟field，记得加上相应注解：

  1. User中将相应构造函数加@Autowired
  2. Message中print方法加@Printable
  3. Config 中将message()加@Bean
public static void main(String[] args) throws IllegalAccessException, ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException {
    Container container = new Container();
    container.init();
    String className = "User";
    String fieldName = "message";
    Class<?> clazz = Class.forName(className);
    Object obj = container.createInstance(clazz);
    Field field = clazz.getDeclaredField(fieldName);
    field.setAccessible(true);
    Object fieldValue = field.get(obj);
    Method[] methods = fieldValue.getClass().getDeclaredMethods();
    for (Method method: methods){
        if (method.getDeclaredAnnotation(Printable.class) != null){
            method.invoke(fieldValue);
        }
    }
}

反射的优缺点

反射的优点

可以看出，此时对象的实例化和方法的调用不再依赖于硬编码的类名和方法名，而是基于字符串和注解Annotation提供的配置信息

使得代码非常的灵活且通用，适合编写需要高度解耦的框架与程序

反射的缺点

会带来性能开销、安全性问题和维护的复杂性，需要在灵活性与这些问题中平衡

Hansdas
关注
  • 48
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
一个java基础项目(学习笔记).zip
02-18
一个java基础项目(学习笔记).zip一个java基础项目(学习笔记).zip一个java基础项目(学习笔记).zip一个java基础项目(学习笔记).zip一个java基础项目(学习笔记).zip一个java基础项目(学习笔记).zip一个java基础项目...
项目管理实践笔记一.pdf
10-29
项目管理实践笔记一.pdf,项目管理实践笔记一.pdf,项目管理实践笔记一.pdf,项目管理实践笔记一.pdf,
Java常用框架---Spring(一)
xzh2022的博客
10-04 589
JavaGuide学习笔记
JavaWeb笔记（三）Java与数据库
qq_25928447的博客
11-17 9182
Java与数据库 通过Java如何去使用数据库来帮助我们存储数据呢，这将是本章节讨论的重点。 初识JDBC JDBC是什么？JDBC英文名为：Java Data Base Connectivity(Java数据库连接)，官方解释它是Java编程语言和广泛的数据库之间独立于数据库的连接标准的Java API，根本上说JDBC是一种规范，它提供的接口，一套完整的，允许便捷式访问底层数据库。可以用JAVA来写不同类型的可执行文件：JAVA应用程序、JAVA Applets、Java Servlet、JSP等，不同
Java笔记-----（5）Spring 框架
王胖泽的博客
02-28 413
Java核心技术解析笔记-----（5）Java框架-Spring必会知识点（1）Spring中的控制反转（IOC）（2）Spring中的面向切面编程（AOP） Spring是目前流行的一站式框架，包括SpringMVC和SpringBoot都给我们搭建Web系统提供了便利。 （1）Spring中的控制反转（IOC） IOC（Inversion Of Control)也叫控制反转，将对象间的依赖关...
java学习笔记之Spring依赖注入和控制反转
CodingBlog的博客
04-20 623
相信对于很多学习spring框架的朋友，控制反转(Ioc)和依赖注入(Di)这两个概念并不陌生，但很多朋友可能总对着两个概念的理解含糊不清，网上很多资料阅读了之后还是让人云里雾里，本篇就是笔者在使用和学习过程中对这个两个概念的理解和心得。 1. 引言 在之前不使用spring框架的传统j2ee开发中，如果一个类中依赖另一个类的方法去实现处理一个功能，那程序员需要
laravel 学习笔记：IoC服务容器（依赖注入与控制反转）
神奕的专栏
11-08 737
容器，字面上理解就是装东西的东西。常见的变量、对象属性等都可以算是容器。一个容器能够装什么，全部取决于你对该容器的定义。当然，有这样一种容器，它存放的不是文本、数值，而是对象、对象的描述（类、接口）或者是提供对象的回调，通过这种容器，我们得以实现许多高级的功能，其中最常提到的，就是 “解耦” 、“依赖注入（DI）”。本文就从这里开始。 一、IoC 容器， laravel 的核心 Laravel...
【Java笔记】如何创建自己的注解+注解怎么用于反射+SpringBoot常见注解
Hansdas的博客
04-21 666
Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。注解就是我们平常看到的@开头的玩意儿，有时候加载方法上，有时候又会加在类、变量、参数上。别的注解没见过，那@Override总见过吧？这就是Java内置的注解之一。大概格式如下可以看到用了几个元注解：注解会在class字节码文件中存在，在运行时可以通过反射获取到；：注解可以加在函数方法上；：可有可无，希望加入javadoc就加上。我们也可以给注释绑定一些数据:其中，default可以指定默认值。
尚学堂JAVA高级学习笔记_1/2
李英俊小朋友
03-19 2519
尚学堂JAVA高级学习笔记 文章目录尚学堂JAVA高级学习笔记写在前面第1章 手写webserver1. 灵魂反射2. 高效解析xml3. 解析webxml4. 反射webxml5. 简单易学的html6. 不得不提的http协议7. 获取请求协议8. 返回响应协议9. 封装响应信息10. 封装请求信息11. 引入servlet12. 整合webxml13. 高效分发器14. 经典404及首页处理...
java基本原理及三大框架原理和数据库基本知识点总结
网络安全领域优质创作者
06-06 9329
这个也是超详细的，自己遇到的问题，然后总结下来的，有查的和自己理解的，很多点，对于做java web开发的同学很有帮助。笔记如下：1、面向对象的特征有哪些方面 1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。2.继承：继承是一种联结类的层...
Laravel 学习笔记 —— 神奇的服务容器
Loven Niu的博客
11-14 415
Laravel 的核心就是一个 IoC 容器，根据文档，称其为“服务容器”，顾名思义，该容器提供了整个框架中需要的一系列服务。作为初学者，很多人会在这一个概念上犯难，因此，我打算从一些基础的内容开始讲解，通过理解面向对象开发中依赖的产生和解决方法，来逐渐揭开“依赖注入”的面纱，逐渐理解这一神奇的设计理念。 本文一大半内容都是通过举例来让读者去理解什么是 IoC（控制反转） 和 DI（依赖注入），通过理解这些概念，来
Istio服务网格实践指南学习笔记-Istio架构
02-24
组建是可拔插的5.Istio作为控制平面，在每个服务中注入一个Envoy代理以Sidecar形式运行来拦截所有进出服务的流量，同时对流量加以控制6.应用程序应该关注于业务逻辑（这才能生钱），非功能性需求交给ServiceMeshIst
Java框架部分SSM笔记
04-30
SSWM笔记深入探讨了Java开发中常用的几个框架，内容涵盖： Spring框架：依赖注入、面向切面编程(AOP)、事务管理等。 SpringMVC：作为表现层框架，处理HTTP请求和响应。 Spring Boot：简化新Spring应用的初始搭建...
jar包增量更新分析
junlaiyan的专栏
05-16 285
借助jdeps分析出jar包的增量文件
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
最新发布
qq_29022265的博客
05-19 1053
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
Spring-Cloud 微服务
weixin_65127444的博客
05-15 913
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 644
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 917
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
帮我用java代码写一个笔记本管理系统
04-24
好的，我可以帮你设计一个简单的笔记本管理系统。首先，你需要定义数据模型来存储笔记本信息，例如品牌、型号、颜色和价格等。然后，你可以使用Java编写控制台应用或者图形用户界面 (GUI) 应用来实现该系统。以下是一个简单的控制台应用的代码示例： ```java import java.util.ArrayList; import java.util.Scanner; public class NotebookManager { private ArrayList<Notebook> notebookList; public NotebookManager() { this.notebookList = new ArrayList<Notebook>(); } public void addNotebook(Notebook notebook) { this.notebookList.add(notebook); } public void removeNotebook(Notebook notebook) { this.notebookList.remove(notebook); } public void displayNotebookList() { System.out.println("Notebook List:"); for (Notebook notebook : this.notebookList) { System.out.println(notebook); } } public static void main(String[] args) { NotebookManager notebookManager = new NotebookManager(); Scanner scanner = new Scanner(System.in); int choice = 0; do { System.out.println("Notebook Management System"); System.out.println("==========================="); System.out.println("1. Add a new notebook"); System.out.println("2. Remove an existing notebook"); System.out.println("3. Display notebook list"); System.out.println("4. Exit"); System.out.println("Enter your choice:"); choice = scanner.nextInt(); switch (choice) { case 1: System.out.println("Add a new notebook"); System.out.println("==================="); System.out.println("Enter brand name:"); String brand = scanner.next(); System.out.println("Enter model:"); String model = scanner.next(); System.out.println("Enter color:"); String color = scanner.next(); System.out.println("Enter price:"); double price = scanner.nextDouble(); Notebook newNotebook = new Notebook(brand, model, color, price); notebookManager.addNotebook(newNotebook); break; case 2: System.out.println("Remove an existing notebook"); System.out.println("============================="); notebookManager.displayNotebookList(); System.out.println("Enter index to remove:"); int index = scanner.nextInt(); Notebook notebook = notebookManager.notebookList.get(index); notebookManager.removeNotebook(notebook); break; case 3: System.out.println("Display notebook list"); System.out.println("======================="); notebookManager.displayNotebookList(); break; case 4: System.out.println("Goodbye!"); break; default: System.out.println("Invalid choice!"); } } while (choice != 4); } } class Notebook { private String brand; private String model; private String color; private double price; public Notebook(String brand, String model, String color, double price) { this.brand = brand; this.model = model; this.color = color; this.price = price; } public String getBrand() { return brand; } public String getModel() { return model; } public String getColor() { return color; } public double getPrice() { return price; } @Override public String toString() { return String.format("Brand: %s, Model: %s, Color: %s, Price: %.2f", brand, model, color, price); } } ``` 这个笔记本管理系统可以执行以下操作： 1. 添加一个新的笔记本 2. 删除一个已有的笔记本 3. 显示当前的笔记本列表 4. 退出系统 你可以选择用一个简单的菜单界面命令来执行这些操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值