Java后端八股------设计模式

已于 2024-10-03 22:45:25 修改
阅读量954 收藏 4
点赞数 3
CC 4.0 BY-SA版权
文章标签： 设计模式
于 2024-03-19 21:52:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yusude123456/article/details/136853693
本文深入探讨了设计模式中的工厂方法和抽象工厂模式，通过Java代码示例详细解释了如何使用这些模式来创建对象，展示了产品接口、具体产品、工厂接口和具体工厂的实现方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在这里插入图片描述在这里插入图片描述

Coffee可以设计成接口。
在这里插入图片描述

示例：

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 简单工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type == null) {
            return null;
        }
        if (type.equalsIgnoreCase("A")) {
            return new ConcreteProductA();
        } else if (type.equalsIgnoreCase("B")) {
            return new Product(new ConcreteProductB());
        }
        return null;
    }
}

// 客户端代码
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Product product = SimpleFactory.createProduct("A");
        product.use();
    }
}

在这里插入图片描述
示例：

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂
class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactoryA();
        Product product = factory.createProduct();
        product.use();
    }
}

抽象工厂模式

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    Product createProduct();
}

// 具体工厂
class ConcreteFactory implements AbstractFactory {
    public Product createProduct() {
        // 决定创建哪种产品
        return new ConcreteProductA();
    }
}

// 客户端代码
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory();
        Product product = factory.createProduct();
        product.use();
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

单例

应用：线程池、数据库连接池、日志记录等。

饿汉式(线程安全)
public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {}

    public static HungrySingleton getInstance() {
        return instance;
    }
}
懒汉式
public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {}

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}
双重检查锁定(DCL)–线程安全
public class DoubleCheckedLockingSingleton {
    private static volatile DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {}

    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}
静态内部类
public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {}

    private static class Holder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance() {
        return Holder.INSTANCE;
    }
}

工厂方法

简单工厂

例子：

// 图形接口
public interface Shape {
    void draw();
}
// 圆形类
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 矩形类
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Rectangle");
    }
}


// 图形工厂
public class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("CIRCLE");
        circle.draw(); // 输出：Drawing a Circle

        Shape rectangle = ShapeFactory.getShape("RECTANGLE");
        rectangle.draw(); // 输出：Drawing a Rectangle
    }
}
方法工厂
// 图形接口
public interface Shape {
    void draw();
}

// 圆形类
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 矩形类
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Rectangle");
    }
}


// 抽象工厂类
public abstract class ShapeFactory {
    public abstract Shape createShape();
}

// 圆形工厂
public class CircleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 矩形工厂
public class RectangleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

客户端实现

public class Client {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw(); // 输出：Drawing a Circle

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw(); // 输出：Drawing a Rectangle
    }
}
抽象工厂
// 图形接口
public interface Shape {
    void draw();
}
// 圆形类
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 矩形类
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Rectangle");
    }
}
// 颜色接口
public interface Color {
    void fill();
}

// 红色类
public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Red color");
    }
}

// 蓝色类
public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Blue color");
    }
}

// 抽象工厂类
public interface AbstractFactory {
    Shape createShape();
    Color createColor();
}

// 圆形工厂
public class CircleFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }

    @Override
    public Color createColor() {
        return new Red(); // 默认返回红色
    }
}

// 矩形工厂
public class RectangleFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }

    @Override
    public Color createColor() {
        return new Blue(); // 默认返回蓝色
    }
}

客户端实现

public class Client {
    public static void main(String[] args) {
        AbstractFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        Color red = circleFactory.createColor();

        circle.draw(); // 输出：Drawing a Circle
        red.fill();    // 输出：Filling with Red color

        AbstractFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        Color blue = rectangleFactory.createColor();

        rectangle.draw(); // 输出：Drawing a Rectangle
        blue.fill();      // 输出：Filling with Blue color
    }
}

代理模式

静态代理的处理模式，在编译时就写死了，不足够灵活
JDK动态代理，靠接口实现(需要实现一些接口)
CGLIB动态代理，需要导入额外的包，

观察者模式

在这里插入图片描述

在这里插入图片描述
应用案例

  1. 事件监听
    在 GUI 应用程序中，按钮、文本框等组件通常使用观察者模式来处理用户事件。例如，按钮被点击时，所有注册的监听器都会被通知，执行相应的操作。
  2. 发布-订阅系统
    在消息推送系统中，观察者模式用于实现发布-订阅机制。发布者发布消息，所有订阅者收到通知并处理消息。例如，新闻网站发布新文章时，所有订阅用户都会收到通知。

策略模式

可以省掉很多的if-else

在这里插入图片描述

// 支付策略接口
public interface PaymentStrategy {
    void pay(int amount);
}
// 信用卡支付类
public class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;

    public CreditCardPayment(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card: " + cardNumber);
    }
}

// PayPal 支付类
public class PayPalPayment implements PaymentStrategy {
    private String email;

    public PayPalPayment(String email) {
        this.email = email;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal: " + email);
    }
}
// 上下文类
public class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        if (paymentStrategy == null) {
            System.out.println("Payment strategy not set!");
            return;
        }
        paymentStrategy.pay(amount);
    }
}
public class Client {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        // 使用信用卡支付
        cart.setPaymentStrategy(new CreditCardPayment("1234-5678-9012-3456"));
        cart.checkout(100); // 输出：Paid 100 using Credit Card: 1234-5678-9012-3456

        // 使用 PayPal 支付
        cart.setPaymentStrategy(new PayPalPayment("user@example.com"));
        cart.checkout(200); // 输出：Paid 200 using PayPal: user@example.com
    }
}
菜菜小堡
关注
速记Java八股文—— Java 设计模式篇
Hardy Army的博客
08-05 637
分类汇总 20+ 常见的 Java 设计模式篇 经典后端面试题，并对题目进行了精炼总结，旨在帮助大家高效记忆，在面试中游刃有余，不至于陷入词穷的窘境。
java后端工程师八股文合集
qq_54479267的博客
03-26 1935
首先要确定数据库中哪些查询是慢的，哪些查询最需要优化。可以通过监控数据库的CPU、磁盘I/O、网络I/O、缓存等指标来确定性能瓶颈。：如果查询语句本身存在问题，例如使用了不必要的子查询、重复的连接操作等，就需要对查询语句进行优化。：索引是提高查询性能的关键因素之一。可以通过创建、修改、删除索引来优化查询性能。：如果数据库中的表结构存在问题，例如表设计不合理、字段类型选择不当等，就需要对数据结构进行优化。：系统参数对数据库性能也有很大的影响，可以通过调整系统参数来优化数据库性能。
Java 面试八股文-设计模式
weixin_42435657的博客
02-23 955
文章目录1、你所知道的设计模式有哪些2、单例模式（Binary Search）3、工厂设计模式（Factory）4、代理模式（Proxy） 1、你所知道的设计模式有哪些 Java 中一般认为有 23 种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了，当然能掌握的越多越好。 总体来说设计模式分为三大类： 创建型模式，共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共7种：适配器模式、装饰器模式、
2025年最新Java后端场景题 + 八股文大全解析！
2501_91139003的博客
05-06 1299
JDK17+ 默认使用动态调整的元空间，减少OOM风险。：低延迟垃圾回收器，适用于云原生环境。：分代式 ZGC，减少年轻代回收开销。：如何实现热加载（如 Arthas）：基于 QPS + 响应时间动态调整。：减少 Consumer 网络开销。会导致虚拟线程被绑定到平台线程。管理任务生命周期，避免线程泄漏。：Serverless 消息处理。更安全，适用于自定义原子操作。：不影响集群投票，但能同步数据。：K8s 环境下自动注册。：支持补偿事务并发执行。：支持 Saga 模式。：冷数据自动转存 S3。
Java面试八股之设计模式01：Java中的设计模式
雍仲的迎客茶庄
05-30 368
Java面试八股之设计模式 最近已经开始接近尾声了，接近一年的开发学习已经结束，到目前为止我自己能够明显感觉到收获非常大，回想当时自己坚定地想要学习Java的决心那时候的自己确实了不起，无数个日日夜夜奋战在台灯下修改Bug，调试程序，每当上下眼皮打架的时候都会站起身来好好思考自己到底要什么，是工作后的高薪待遇，还是每天可以躺平摸鱼的大厂，亦或是说就是为了一个小小的兴趣而已，受过身边的人的冷嘲热讽，也得到过身边人的鼓励，在网上论坛，B站上认识到不少志同道合的人，来自不同的城市，有时候一起研究一些问题到凌晨两
【Java八股文总结】之Java设计模式
qq_46111316的博客
11-19 791
Java中常见的设计模式知识点总结
《Java后端知识体系》系列之设计模式
qq_40126996的博客
05-12 510
为了几个月后的面试做准备！ 设计模式 单例模式：单例模式中类只能有一个实例，单例模式的构造方法必须为私有的，防止外部创建，单例模式可以设计为final，目的在于不能被子类继承，在类中需要提供一个方法供外部类访问。 懒汉式： 理解：懒汉式顾名思义就是比较懒，在创建对象之后并不会直接初始化这个对象，只是将对象设置为null，因此并不会占用内存，在静态方法中进行初始化对象。 线程安全：线程不安全的，需要加同步锁，同步锁影响效率 实现方法： public class SingleTon { .
Java后端面试八股文
04-08
Java基础、容器、多线程、反射、对象拷贝、Java Web、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud 、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySQL、Redis、JVM等多种常用面试...
Java后端大厂面试八股文
03-30
Java后端大厂面试八股文是一份针对Java程序员求职面试的综合指南，包含了阿里、百度、腾讯等知名企业的高频面试题目。这份资料是代码随想录知识星球成员的智慧结晶，由程序员Carl精心筛选并整理，目的是为了帮助求职...
java后端开发面经-多个公司
m0_67455745的博客
03-16 4107
总体描述：从年前开始面试，先后面了，兴业数金、苏州银行、思科、之江实验室、新华三、招银网络科技、同花顺、招银理财、人寿研发中心、zoom、字节等公司；目前已oc的有兴业数金、之江实验室、新华三、招银网络科技、zoom；还在流程中的招银理财到终面、人寿研发中心到终面、字节到二面、蚂蚁做完线上笔试还没有消息；城市主要有杭州、合肥；面经主要以各个公司的面试流程为主，问的问题很多已经记不清了，只能大概回忆下，最终决定去zoom 1. 兴业数金 笔试加两轮技术面，总体难度一般 笔试是选择加编程，编程
2024最强Java面试八股文
01-04
《2024最强Java面试八股文》是一份针对Java面试的全面指南，内容涵盖JVM、MQ、MyBatis、MySQL、Redis、Spring Boot、Spring Cloud以及设计模式等多个方面。这份资料旨在帮助求职者系统地复习和掌握Java及相关技术的...
《Java 后端面试经》设计模式篇
华仔仔的博客
02-27 912
《Java 后端面试经》设计模式篇你了解的设计模式有哪些?在 Spring 框架中都用到了哪些设计模式，并举例说明？设计模式的原则有哪些？ 你了解的设计模式有哪些? 总的设计模式有 23 种，可以分为三大类： 创建型模式(共五种)：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式(共七种)：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式(共十一种)：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访
JAVA后端知识点碎片化整理 基础篇（十八） 设计模式 （手敲加深理解）
努力的颜值巨兽博客
07-29 615
目录   （1）什么是设计模式 （2）单例设计模式（饿汉模式 懒汉模式） （3）工厂设计模式 (4)建造者模式（Builder） (5)适配器设计模式 （6）装饰模式（Decorator） (7)策略模式（strategy） (8)观察者模式（Observer）  这个模式有点小触动！！！之前想写这种来着的，我。。。。。不会   （1）什么是设计模式 面向对象的设计比较困...
JAVA后端开发面试基础知识（十）——设计模式
达分柒的博客
03-09 1318
单例模式（单线程） 工厂模式（Bean） 原型模式（克隆） 建造者模式（构建与表示分离、StringBuilder） 代理模式（AOP、异常处理） 适配器模式 默认适配器模式 对象适配器模式 类适配器模式 适配器模式总结 桥梁模式 装饰模式 门面模式（外观模式，接口） 组合模式 享元模式 模板方法模式 策略模式（if...else） 观察者模式（发布订阅） 责任链模式 状态模式 spring中用到哪些设计模式？ mysql
秋招Java后端开发——设计模式
qq_50604294的博客
06-27 1131
定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。本模式使得算法可以独立于使用它的客户而变化。
后端开发工程师需要掌握哪些设计模式？
2301_82300081的博客
12-13 746
MVC模式（MVC Pattern）业务代表模式（Business Delegate Pattern）组合实体模式（Composite Entity Pattern）数据访问对象模式（Data Access Object Pattern）前端控制器模式（Front Controller Pattern）拦截过滤器模式（Intercepting Filter Pattern）服务定位器模式（Service Locator Pattern）传输对象模式（Transfer Object Pattern）
【后端高频面试题--设计模式下篇】
qq_45832651的博客
02-12 1981
最新后端设计模式面试题，设计模式真实开阔脑子的好思想，嘿嘿，来看看吧！
Java设计模式系列-02 23种设计模式之结构型模式
yangwei2048的博客
06-27 643
本文介绍了Java设计模式中的适配器模式，主要包括三种类型：类适配器、对象适配器和接口适配器。适配器模式用于解决接口不兼容问题，通过转换接口实现不同类的协同工作。类适配器通过继承实现，对象适配器通过组合实现（更常用灵活），接口适配器则通过抽象类选择性实现接口方法。文章以充电器为例说明类适配器原理，并展示了SpringMVC框架中HandlerAdapter的应用源码分析，体现了适配器模式在实际开发中的价值。该模式提高了代码复用性，符合开闭原则，是结构型设计模式的重要实现方式。
java后端八股文面试
最新发布
05-23
### Java后端开发经典面试题及答案解析 #### 1. JRE 和 JDK 的区别是什么？ JRE（Java Runtime Environment）是用于运行 Java 程序的环境，其中包括 JVM（Java Virtual Machine），以及支持 Applet 执行所需的浏览器插件[^1]。 JDK（Java Development Kit）则是完整的 Java 开发工具包，不仅包含 JRE，还提供了编译器、调试器以及其他开发工具（如 `javac` 编译器、`javadoc` 文档生成工具等），使开发者能够编写、编译并运行 Java 应用程序[^1]。 --- #### 2. 反射的作用及其实现原理是什么？如何获取反射对象？ 反射机制允许在运行时动态加载类、创建实例、访问字段和调用方法。其实现依赖于 `java.lang.reflect` 包中的核心类（如 `Class`、`Field`、`Method` 等）。通过反射，可以在不知道具体类名的情况下操作类成员[^2]。 以下是获取反射对象的三种方式： - 使用 `Class.forName(String className)` 方法； - 调用某个类的 `.class` 属性； - 对象的 `.getClass()` 方法。 示例代码如下： ```java // 方式一：通过 Class.forName 获取 Class<?> clazz1 = Class.forName("java.util.ArrayList"); // 方式二：通过 .class 属性获取 Class<?> clazz2 = ArrayList.class; // 方式三：通过对象的 getClass() 方法获取 ArrayList<String> list = new ArrayList<>(); Class<?> clazz3 = list.getClass(); ``` --- #### 3. 解释 `==` 和 `equals()` 的区别，并举例说明。 `==` 是比较两个变量的内存地址或基本数据类型的值是否相等，而 `equals()` 默认也是比较地址，但在某些类（如 `String` 或包装类）中会被重写以比较内容是否相同。 例如： ```java Integer a = 10; Integer b = 10; System.out.println(a == b); // true (因为 Integer 在 [-128, 127] 范围内会缓存) Integer c = 129; Integer d = 129; System.out.println(c == d); // false (超出范围未被缓存) System.out.println(c.equals(d)); // true (比较的是数值本身) ``` --- #### 4. `wait()` 和 `sleep()` 的主要区别有哪些？ 两者的差异体现在以下几个方面[^4]： - **所属类**：`wait()` 是 `Object` 类的方法，需配合锁使用；`sleep()` 则是 `Thread` 类的静态方法。 - **线程状态**：`wait()` 会使当前线程释放锁进入等待队列，直到其他线程唤醒它；`sleep()` 不会释放任何锁，仅让线程暂停指定时间。 - **异常抛出**：`wait()` 需要在同步块中调用，可能抛出 `InterruptedException`；`sleep()` 直接作用于线程，同样可能抛出该异常。 --- #### 5. `RuntimeException` 和受检异常的主要区别是什么？ `RuntimeException` 是非受检异常的一部分，其特点是无需显式声明或捕获即可抛出。常见的子类包括 `NullPointerException`、`ArrayIndexOutOfBoundsException` 等。相比之下，受检异常（Checked Exception）必须在方法签名中声明（通过 `throws` 关键字）或在其发生处被捕获处理[^3]。 | 特性 | RuntimeException | Checked Exception | |-------------------|----------------------------------|-------------------------------| | 是否强制处理 | 否 | 是 | | 常见例子 | NullPointerException | IOException | --- #### 6. 如何理解单例模式？请给出一个懒汉式的实现。 单例模式是一种设计模式，确保某类只有一个实例存在，并提供全局访问点。通常分为饿汉式和懒汉式两种形式。其中懒汉式会在首次使用时才初始化实例，从而延迟资源分配[^3]。 示例代码如下： ```java public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } ``` --- #### 7. GC 的工作原理是什么？哪些情况下触发垃圾回收？ GC（Garbage Collection）由 JVM 自动管理，负责清理不再使用的对象所占用的堆空间。当对象无法通过任何强引用到达时，即被认为是可回收的。触发条件主要包括但不限于以下几种情况： - 新对象分配失败（堆空间不足）； - 明确调用了 `System.gc()` 提示系统进行垃圾回收（不保证立即执行）。 --- ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值