关联关系理解

已于 2024-03-31 19:29:38 修改
阅读量799 收藏 11
点赞数 9
文章标签： 建模
于 2024-03-31 18:25:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74447750/article/details/137177325
版权

关联关系

1.关联关系

关联关系是面向对象编程中的一个概念，用于描述两个类之间的联系。在关联关系中，一个类的对象与另一个类的对象之间存在某种关联，但它们的关系不如组合关系那样密切。这种关联可以是单向的，也可以是双向的。
在关联关系中，一个类的对象可以作为另一个类的成员变量，或者作为方法的参数或返回值等形式出现。这种关系可以用来描述现实世界中的各种情况，例如学生和课程之间的关系、订单和产品之间的关系等。

关联关系的特点包括：

  1. 双向关系：两个类之间的关联可以是双向的，即彼此互相关联。
  2. 多重性：关联关系中的对象之间可能存在一对一、一对多、多对一或多对多等不同的关系。
  3. 独立性：关联关系中的两个对象的生命周期通常是独立的，它们之间的存在并不依赖于彼此。

关联关系在代码实现中通常通过成员变量、方法参数或返回值来体现，以反映出两个类之间的关联性。在使用关联关系时，需要注意避免过度耦合，以提高代码的灵活性和可维护性。

1.1单向关联

在下面的示例中，Order 类中使用了指针 const Customer* customer 来表示订单和客户之间的单向关联关系。在 main 函数中创建订单对象时，将客户对象的地址传入订单对象的构造函数中，从而建立了单向关联关系。这样，订单对象可以通过指针访问关联的客户对象的信息，但客户对象无法直接通过订单对象访问关联的订单信息，从而形成了单向关联关系。

#include <iostream>
#include <vector>
#include <string>

using namespace std;

// 定义客户类
class Customer {
private:
    int customerId;
    string customerName;

public:
    Customer(int id, const string& name) : customerId(id), customerName(name) {}

    int getCustomerId() const {
        return customerId;
    }

    const string& getCustomerName() const {
        return customerName;
    }
};

// 定义订单类
class Order {
private:
    int orderId;
    string orderDate;
    const Customer* customer; // 使用指针表示关联关系

public:
    Order(int id, const string& date, const Customer* cust) : orderId(id), orderDate(date), customer(cust) {}

    int getOrderId() const {
        return orderId;
    }

    const string& getOrderDate() const {
        return orderDate;
    }

    const Customer* getCustomer() const {
        return customer;
    }
};

int main() {
    // 创建客户对象
    Customer customer1(1, "John Doe");

    // 创建订单对象，并传入客户对象的地址作为关联
    Order order1(1001, "2024-03-30", &customer1);

    // 获取订单信息以及关联的客户信息
    cout << "Order ID: " << order1.getOrderId() << endl;
    cout << "Order Date: " << order1.getOrderDate() << endl;
    cout << "Customer ID: " << order1.getCustomer()->getCustomerId() << endl;
    cout << "Customer Name: " << order1.getCustomer()->getCustomerName() << endl;

    return 0;
}

1.2双向关联

双向关联关系意味着两个类之间的关联是双向的，每个类都能够直接访问关联的对象。在 C++ 中实现双向关联关系时，可以在每个类中使用指针或引用来表示另一个类的关联。在下面的示例中，Customer 类和 Order 类分别存储了彼此的指针，并提供了方法来访问关联的对象。在创建订单对象时，将订单添加到客户的订单列表中，从而建立了双向关联关系。

#include <iostream>
#include <vector>
#include <string>

using namespace std;

// 前置声明，避免互相引用时出错
class Order;

// 定义客户类
class Customer {
private:
    int customerId;
    string customerName;
    vector<Order*> orders; // 用于存储关联的订单指针

public:
    Customer(int id, const string& name) : customerId(id), customerName(name) {}

    int getCustomerId() const {
        return customerId;
    }

    const string& getCustomerName() const {
        return customerName;
    }

    // 添加订单到客户的订单列表中
    void addOrder(Order* order) {
        orders.push_back(order);
    }

    // 获取客户的所有订单
    const vector<Order*>& getOrders() const {
        return orders;
    }
};

// 定义订单类
class Order {
private:
    int orderId;
    string orderDate;
    Customer* customer; // 用于存储关联的客户指针

public:
    Order(int id, const string& date, Customer* cust) : orderId(id), orderDate(date), customer(cust) {
        // 在订单构造函数中，将订单添加到客户的订单列表中
        customer->addOrder(this);
    }

    int getOrderId() const {
        return orderId;
    }

    const string& getOrderDate() const {
        return orderDate;
    }

    // 获取订单关联的客户
    Customer* getCustomer() const {
        return customer;
    }
};

int main() {
    // 创建客户对象和订单对象
    Customer customer1(1, "John Doe");
    Order order1(1001, "2024-03-30", &customer1);

    // 获取订单关联的客户以及客户关联的订单
    cout << "Order ID: " << order1.getOrderId() << endl;
    cout << "Order Date: " << order1.getOrderDate() << endl;
    cout << "Customer ID: " << order1.getCustomer()->getCustomerId() << endl;
    cout << "Customer Name: " << order1.getCustomer()->getCustomerName() << endl;

    cout << "Customer's Orders:" << endl;
    const vector<Order*>& customer1Orders = customer1.getOrders();
    for (const auto& order : customer1Orders) {
        cout << " - Order ID: " << order->getOrderId() << ", Order Date: " << order->getOrderDate() << endl;
    }

    return 0;
}

1.3自关联

自关联是指一个类与自身建立关联关系。在 C++ 中，可以通过在类中使用指针或引用来实现自关联。在下面的示例中，Node 类表示一个简单的链表节点，包含一个整数数据成员和一个指向下一个节点的指针。通过在节点类中使用指针来指向下一个节点，实现了节点之间的自关联关系。在 main 函数中，创建了三个节点对象，并通过调用 setNext 方法建立了节点之间的关联关系。然后，通过遍历链表输出节点数据，最后释放了动态分配的内存。

#include <iostream>
#include <string>

using namespace std;

// 定义节点类
class Node {
private:
    int data;
    Node* next; // 指向下一个节点的指针

public:
    Node(int val) : data(val), next(nullptr) {}

    // 设置下一个节点
    void setNext(Node* node) {
        next = node;
    }

    // 获取下一个节点
    Node* getNext() const {
        return next;
    }

    // 获取节点数据
    int getData() const {
        return data;
    }
};

int main() {
    // 创建节点对象
    Node* node1 = new Node(1);
    Node* node2 = new Node(2);
    Node* node3 = new Node(3);

    // 建立节点之间的关联关系
    node1->setNext(node2);
    node2->setNext(node3);

    // 遍历节点链表
    Node* current = node1;
    while (current != nullptr) {
        cout << "Node data: " << current->getData() << endl;
        current = current->getNext();
    }

    // 释放动态分配的内存
    delete node1;
    delete node2;
    delete node3;

    return 0;
}

2.聚合关系

聚合关系是关联关系的一种，是强关联关系，是整体和部分之间的关系。在聚合关系中，一个类作为另一个类的成员，并且这个成员对象的生命周期可以独立于包含它的类。在 C++ 中，聚合关系通常通过在类中创建成员对象或指针来实现。聚合关系的特点是，成员可以脱离于整体对象独立存在，比如学校与老师的关系，学校包含老师，但是就算学校没了，老师依然可以存在。
在下面的示例中，Teacher 类表示老师，School 类表示学校。在 School 类中，使用了一个 vector 来存储学校包含的老师对象的指针，这体现了学校和老师之间的聚合关系。通过 addTeacher 方法可以向学校对象中添加老师。通过 getTeacherNames 方法可以获取学校所有老师的姓名。

#include <iostream>
#include <string>
#include <vector>

using namespace std;

// 老师类
class Teacher {
private:
    string name;

public:
    Teacher(const string& n) : name(n) {}

    const string& getName() const {
        return name;
    }
};

// 学校类
class School {
private:
    string name;
    vector<Teacher*> teachers; // 聚合关系，学校包含了多个老师对象的指针

public:
    School(const string& n) : name(n) {}

    // 添加老师
    void addTeacher(Teacher* teacher) {
        teachers.push_back(teacher);
    }

    // 获取学校所有老师的姓名
    vector<string> getTeacherNames() const {
        vector<string> teacherNames;
        for (const auto& teacher : teachers) {
            teacherNames.push_back(teacher->getName());
        }
        return teacherNames;
    }

    // 获取学校名称
    const string& getName() const {
        return name;
    }
};

int main() {
    // 创建老师对象
    Teacher mrSmith("Mr. Smith");
    Teacher msJohnson("Ms. Johnson");

    // 创建学校对象
    School highSchool("High School");

    // 将老师添加到学校中
    highSchool.addTeacher(&mrSmith);
    highSchool.addTeacher(&msJohnson);

    // 输出学校名称
    cout << "School name: " << highSchool.getName() << endl;

    // 输出学校所有老师的姓名
    cout << "Teachers in " << highSchool.getName() << ":" << endl;
    for (const auto& teacherName : highSchool.getTeacherNames()) {
        cout << teacherName << endl;
    }

    return 0;
}

3.组合关系

组合表示类之间的整体与部分的关系，但它是一种更强烈的聚合关系。在组合关系中，整体对象可以控制部分对象的生命周期，一旦整体对象不存在，部分对象也将不存在，部分对象不能脱离整体对象而存在。在组合关系中，一个类包含另一个类的对象，并且包含的对象的生命周期与包含它的类的生命周期相同。在 C++ 中，组合关系通常通过在类中直接创建成员对象来实现。
在下面的示例中，Wheel 类表示轮子，Car 类表示汽车。Car 类包含了四个 Wheel 类的对象作为成员变量，这实现了 Car 类对 Wheel 类的组合关系。在 main 函数中，创建了一个汽车对象 myCar，并输出了汽车的型号以及每个轮子的尺寸。

#include <iostream>
#include <string>

using namespace std;

// 定义轮子类
class Wheel {
private:
    int size;

public:
    Wheel(int s) : size(s) {}

    int getSize() const {
        return size;
    }
};

// 定义汽车类，其中包含轮子对象
class Car {
private:
    string model;
    Wheel frontLeftWheel;
    Wheel frontRightWheel;
    Wheel rearLeftWheel;
    Wheel rearRightWheel;

public:
    Car(const string& m, int wheelSize) :
        model(m),
        frontLeftWheel(wheelSize),
        frontRightWheel(wheelSize),
        rearLeftWheel(wheelSize),
        rearRightWheel(wheelSize) {}

    const string& getModel() const {
        return model;
    }

    const Wheel& getFrontLeftWheel() const {
        return frontLeftWheel;
    }

    const Wheel& getFrontRightWheel() const {
        return frontRightWheel;
    }

    const Wheel& getRearLeftWheel() const {
        return rearLeftWheel;
    }

    const Wheel& getRearRightWheel() const {
        return rearRightWheel;
    }
};

int main() {
    // 创建汽车对象
    Car myCar("Toyota", 18);

    // 输出汽车信息及轮子信息
    cout << "Car Model: " << myCar.getModel() << endl;
    cout << "Front Left Wheel Size: " << myCar.getFrontLeftWheel().getSize() << " inches" << endl;
    cout << "Front Right Wheel Size: " << myCar.getFrontRightWheel().getSize() << " inches" << endl;
    cout << "Rear Left Wheel Size: " << myCar.getRearLeftWheel().getSize() << " inches" << endl;
    cout << "Rear Right Wheel Size: " << myCar.getRearRightWheel().getSize() << " inches" << endl;

    return 0;
}

4.依赖关系

依赖关系是一种使用关系，它是对象之间耦合度最弱的一种关联方式，是临时性的关联。在代码中，某个类的方法通过局部变量、方法的参数或者对静态方法的调用来访问另一个类（被依赖类）中的某些方法来完成一些职责。在依赖关系中，一个类使用另一个类的对象作为参数或者局部变量，但是它们之间没有拥有关系。依赖关系通常体现在方法参数的传递或局部变量的使用上。
在下面的示例中，Engine 类表示引擎，Car 类表示汽车。在 Car 类的 drive 方法中，使用了 Engine 类的对象作为参数，这体现了 Car 类对 Engine 类的依赖关系。在 main 函数中，创建了一个汽车对象 myCar 和一个引擎对象 myEngine，然后调用了汽车对象的 drive 方法，并将引擎对象作为参数传入。

#include <iostream>
#include <string>

using namespace std;

// 定义引擎类
class Engine {
public:
    void start() {
        cout << "Engine started." << endl;
    }

    void stop() {
        cout << "Engine stopped." << endl;
    }
};

// 定义汽车类，其中使用了引擎对象作为参数
class Car {
private:
    string model;

public:
    Car(const string& m) : model(m) {}

    // 方法中使用了引擎对象作为参数，体现了依赖关系
    void drive(Engine& engine) {
        cout << "Driving the " << model << " car." << endl;
        engine.start();
        // Driving logic...
        engine.stop();
    }
};

int main() {
    // 创建汽车对象和引擎对象
    Car myCar("Toyota");
    Engine myEngine;

    // 调用汽车对象的方法，传入引擎对象作为参数
    myCar.drive(myEngine);

    return 0;
}

5.继承关系

继承关系是耦合度最大的一种，也是我们最常看见的一种，子类基础父类。在关联关系中，一个类和另一个类有联系，但它们之间的关系不如组合关系密切。通常，一个类的对象可以作为另一个类的成员变量，但它们之间的生命周期可以是独立的。继承关系则是一种类与类之间的特殊关系，其中一个类（子类）可以继承另一个类（父类）的属性和方法。
在下面的示例中，Wheel 类表示轮子，Car 类表示汽车，SportsCar 类表示跑车。Car 类中包含了四个 Wheel 对象的指针，这体现了关联关系。而 SportsCar 类继承自 Car 类，这体现了继承关系。在 main 函数中，创建了一个跑车对象 mySportsCar，并输出了跑车的型号、是否有涡轮增压以及每个轮子的尺寸。

#include <iostream>
#include <string>

using namespace std;

// 定义轮子类
class Wheel {
private:
    int size;

public:
    Wheel(int s) : size(s) {}

    int getSize() const {
        return size;
    }
};

// 定义汽车类，其中关联了轮子对象
class Car {
private:
    string model;
    Wheel* wheels[4]; // 关联了四个轮子对象的指针

public:
    Car(const string& m, int wheelSize) : model(m) {
        for (int i = 0; i < 4; ++i) {
            wheels[i] = new Wheel(wheelSize);
        }
    }

    ~Car() {
        for (int i = 0; i < 4; ++i) {
            delete wheels[i];
        }
    }

    const string& getModel() const {
        return model;
    }

    const Wheel* getWheel(int index) const {
        if (index >= 0 && index < 4) {
            return wheels[index];
        } else {
            return nullptr;
        }
    }
};

// 定义跑车类，继承自汽车类
class SportsCar : public Car {
private:
    bool turbo;

public:
    SportsCar(const string& m, int wheelSize, bool t) : Car(m, wheelSize), turbo(t) {}

    bool hasTurbo() const {
        return turbo;
    }
};

int main() {
    // 创建跑车对象
    SportsCar mySportsCar("Ferrari", 20, true);

    // 输出跑车信息及轮子信息
    cout << "Sports Car Model: " << mySportsCar.getModel() << endl;
    cout << "Has Turbo: " << (mySportsCar.hasTurbo() ? "Yes" : "No") << endl;
    for (int i = 0; i < 4; ++i) {
        cout << "Wheel " << i + 1 << " Size: " << mySportsCar.getWheel(i)->getSize() << " inches" << endl;
    }

    return 0;
}

6 实现关系

实现关系（Implementation Relationship）是面向对象编程中描述类与接口之间的关系。在实现关系中，类实现了一个或多个接口，它承诺实现接口中定义的所有抽象方法和属性。
在下面示例中，Transportation 是一个接口类，其中声明了纯虚函数 move()，表示交通工具的移动操作。Car 和 Ship 分别是实现了 Transportation 接口的类，它们都必须提供 move() 方法的具体实现。在 main() 函数中，我们创建了 Car 和 Ship 的对象，并通过这些对象调用了 move() 方法，展示了实现关系的用法。

#include <iostream>

// 定义交通工具接口
class Transportation {
public:
    virtual void move() = 0; // 抽象方法，表示交通工具的移动操作
};

// 汽车类实现了交通工具接口
class Car : public Transportation {
public:
    void move() override {
        std::cout << "Car is moving on the road." << std::endl;
    }
};

// 船类实现了交通工具接口
class Ship : public Transportation {
public:
    void move() override {
        std::cout << "Ship is sailing on the sea." << std::endl;
    }
};

int main() {
    Car car;
    Ship ship;

    // 通过实现了接口的对象调用接口方法
    car.move();
    ship.move();

    return 0;
}
hu_yuchen
关注
UML图中类之间的关系:依赖,泛化,关联,聚合,组合,实现
weixin_30517001的博客
06-07 1645
类与类图 1) 类(Class)封装了数据和行为，是面向对象的重要组成部分，它是具有相同属性、操作、关系的对象集合的总称。 2) 在系统中，每个类具有一定的职责，职责指的是类所担任的任务，即类要完成什么样的功能，要承担什么样的义务。一个类可以有多种职责，设计得好的类一般只有一种职责，在定义类的时候，将类的职责分解成为类的属性和操作（即方法）。 3) 类的属性即类的数据职责，类的...
关联分析概述
weixin_41418263的博客
02-02 5108
关联分析 1：关联分析概述 1. 1关联分析前言 在去杂货店买东西的过程中，实际包含了很多机器学习的当前及未来应用，这包括物品的展示方式、购物之后优惠券的提供以及用户忠诚度计划，等等。他们都离不开大量数据的分析。商品希望从顾客身上获得尽可能多的利润，所以他们必然会利用各种技术来达到这一目的。 通过查看哪些商品经常一起购买，可以帮助商店了解用户的购买行为。这种从数据海洋中抽取的知识可以用于商品定价、市场促销、存货管理等环节。从大规模数据集中寻找物品间的隐含关系被称为关联分析或者关联规则学习。 这里的主要问题在
类与类之间的关系
11-04
java类的阐述,简单的讲述类与类之间的关系。
类的关联关系
weixin_34336526的博客
12-16 494
UML 类图中的几种关系 : 1、关联关系 (1)关联关系是类与类之间的联结，它使一个类知道另一个类的属性和方法。 (2)关联可以是双向的，也可以是单向的。双向的关联可以有两个箭头或者没有箭头，单向的关联有一个箭头。 (3)在 Java 或 c++ 中，关联关系是通过使用成员变量来实现的。 class A{ } class B{ publi...
详解类与类的关联关系
hu_xinxin的专栏
06-28 1141
仔细想了类与类之间的关系，感觉很多资料书说得有很多地方都是不正确的，很多也没有说清楚。希望本篇文章能给读者一些帮助，也自勉。本篇文章引用了别人的东西，并非全部原创。   一：一般化关系（也称泛化关系） UML的关系图： 代码描述： public interface Animal { public void breath(); }   public class D
关联关系映射
Zhangrunhong的博客
09-28 259
文章目录1、mybatis的一对多关联关系2、mybatis的多对多的关联关系 1、mybatis的一对多关联关系 一对多 对应的实体类中是有对象的引用（应用的就是一个类） 重要是描述关联属性的配置 1.1 修改数据表* <table schema="" tableName="t_hibernate_order" domainObjectName="Order" ...
彩色圆点五数据项关联关系PPT图表
07-16
"彩色圆点五数据项关联关系PPT图表"是一个这样的工具，它能够帮助用户直观地理解五个不同数据项之间的相互联系。在本篇内容中，我们将深入探讨这种图表的设计原理、应用场景以及如何有效地利用它来传达复杂的信息。 ...
两张圆环关联关系图表PPT模板
03-20
"两张圆环关联关系图表PPT模板"是专门设计用于展示不同元素之间相互关联和影响关系的一种图形化表达方式。在这样的模板中，圆环通常代表不同的类别或阶段，而它们之间的重叠部分则表示这些类别或阶段之间的关联程度...
matlab.rar_关联关系
09-24
总的来说，“matlab.rar_关联关系”这个压缩包提供的源代码资源，为学习和实践灰色关联分析提供了便利，用户可以通过阅读和运行代码，加深对这一数据分析方法的理解，并将其应用到实际问题中，解决相关领域的关联性...
解除与正常纳税人关联关系--个人声明.rar
12-11
在税务管理中，个人与纳税人的关联关系是一个重要的概念，涉及到个人的税务责任、权益以及税务机关的管理工作。本文将详细解析标题“解除与正常纳税人关联关系--个人声明”所涉及的知识点，并根据提供的文件名“解除...
三角形关联关系PPT图表
07-16
1. 数据可视化：三角形关联关系图可以帮助观众快速理解复杂的数据或概念，通过将信息分解为三个关键组成部分，它简化了复杂性。每个角代表一个要素，而连接它们的线条表示这些要素之间的关系，可能是因果、依赖或者...
10. 类的关系——关联关系
baidu_41907361的博客
06-20 3197
10. 类的关系——关联关系 1、类的四种关系 · 关联关系 · 依赖关系 · 继承关系 · 实现关系（本质也是继承关系） 2、关联关系 在关联关系中，没有新的语法和概念，不过是一种思想。 对象和对象之间的连接。在Java中，关联关系的代码表现形式为一个类做为另一个类的属性类型存在。即语义上是“有”的关系：”has-a”。 2.1 按整体和部分分类： （1）组合——同生共死 （2）聚合——不同生不同死 区别：生命周期不同 例：组合——同生同死 ​ 创建整体时部分也同时创建，整体销毁部分也销毁 /
设计模式之UML（一）类图以及类间关系（泛化 、实现、依赖、关联、聚合、组合）
IT小智博客
12-07 2068
类图用于描述系统中所包含的类以及它们之间的相互关系，帮助人们简化对系统的理解，它是系统分析和设计阶段的重要产物，也是系统编码和测试的重要模型依据。接下来我们就来谈谈类图的组成，在下一篇中我们将讨论一下类图之间的关系。 一、类图的组成 1. 普通类 上图就是一个UML的普通类图，从上图我们看出，一个UML通常由三部分组成。 第一部分是类名：每个类都必须有一个名字，类名
类之间的关系
a3060858469的博客
10-25 876
一、关联关系关联关系(Association)是类与类之间最常用的一种关系，它是一种结构化关系，用于表示一类对象与另一类对象之间有联系。在UML类图中，用实线连接有关联的对象所对应的类，在使用Java、C#和C++等编程语言实现关联关系时，通常将一个类的对象作为另一个类的属性。在使用类图表示关联关系时可以在关联线上标注角色名。1.关联关系 public class LoginForm {
【类关系】关联关系
bug制造者
09-13 267
概念 关联关系的代码表现形式为一个类做为另一个类的属性类型存在。 即“有”的关系：”has-a”。 关联关系分为单向关联和双向关联 单向关联： A类关联B类。 双向关联： A类关联B类,B类关联A类; ...
关联分析（一）
G090909的博客
10-11 5488
关联分析是数据挖掘中很重要的一类技术，其实就是挖掘事物之间的联系。关联分析研究的关系有两种：简单关联关系和序列关联关系。简单关联关系经典的购物篮分析中有个例子说，购买面包的顾客中80%会购买牛奶。面包和牛奶作为一种早餐的搭配是大家所接受的，二者没有共同属性，但是二者搭配后就是一顿美味早餐，这是一种简单的关联关系。序列关联关系比如买了iphone手机的顾客中80%会选择购买iphone手机保护壳，这就
java中类的关联
qq_41961113的博客
11-27 272
1、 泛化(Generalization) 常说的继承。是说子类获得父类的功能的同时，还可以扩展自己的功能。 Java代码中表现为：extends 和 implements 2、 依赖(Dependency) 依赖：对象之间的临时关系，临时性体现在不超越方法的周期。简单的说，在方法使用到的，如参数类，就一定是依赖关系。 Java代码中的表现为局部变量，方法的参数，以及对静态方...
基于ssm的二手车交易网站设计与实现.docx
最新发布
09-17
基于ssm的二手车交易网站设计与实现.docx
python 关联关系图
08-17
Python 关联关系图是一种用于...总之，Python 关联关系图是一种有助于我们理解对象之间联系和依赖关系的图形表示方式。通过绘制关联关系图，我们可以更好地理解和分析系统的结构，从而提升软件设计和系统分析的效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值