类图的六种关系实现：泛化、依赖、组合、聚合、关联

类图的六种关系实现：泛化、依赖、组合、聚合、关联

1. 实现（Realization）

注意：实际为空心箭头

实现关系在C++中通常是通过类实现接口（通常使用纯虚函数）的方式来实现的。下面是一个Shape接口和实现这个接口的Circle类的示例。

// 接口
class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

// 具体类实现接口
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Circle.draw() method called" << std::endl;
    }
};

在这个示例中，Circle类通过实现Shape接口的draw()方法来体现实现关系。

2. 泛化（Generalization）

注意：实际为空心箭头

泛化关系在C++中通过类的继承来实现。下面是一个基类Animal和其子类Dog的示例。

// 基类
class Animal {
public:
    void eat() {
        std::cout << "Animal is eating" << std::endl;
    }
};

// 子类继承基类
class Dog : public Animal {
public:
    void bark() {
        std::cout << "Dog is barking" << std::endl;
    }
};

在这里，Dog类继承了Animal类，从而获得了eat()方法，并且还定义了自己的bark()方法，这就是泛化关系。

3. 依赖（Dependency）

依赖关系表示一个类（或方法）依赖于另一个类（或方法）来完成其工作。下面是一个Driver类依赖于Car类的示例。

class Car {
public:
    void start() {
        std::cout << "Car started" << std::endl;
    }
};

class Driver {
public:
    void drive(Car& car) {
        car.start();
        std::cout << "Car is being driven" << std::endl;
    }
};

在这个示例中，Driver类的drive()方法依赖于Car类的start()方法来完成驾驶操作，这就是依赖关系。

4. 组合（Composition）

组合关系表示一个类（整体）由另一个类的对象（部分）组成，并且这些对象的生命周期与整体相同。下面是一个Car对象由Engine和Wheel组成的示例。

class Engine {
public:
    void start() {
        std::cout << "Engine started" << std::endl;
    }
};

class Wheel {
public:
    void rotate() {
        std::cout << "Wheel rotating" << std::endl;
    }
};

class Car {
private:
    Engine engine;
    Wheel wheels[4];

public:
    void start() {
        engine.start();
        std::cout << "Car started" << std::endl;
    }
};

在这个示例中，Car类通过组合Engine和Wheel类来形成一个完整的汽车，Engine和Wheel的生命周期与Car相同，这就是组合关系。

5. 聚合（Aggregation）

聚合关系也表示整体与部分之间的关系，但部分对象的生命周期可以独立于整体存在。下面是一个学校包含多个学生的示例。

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

class Student {
private:
    std::string name;
    int age;

public:
    Student(const std::string& name, int age) : name(name), age(age) {}

    void study() {
        std::cout << name << " is studying" << std::endl;
    }
};

class School {
private:
    std::vector<Student*> students;

public:
    void addStudent(Student* student) {
        students.push_back(student);
    }

    void conductClass() {
        for (Student* student : students) {
            student->study();
        }
    }
};

在这个示例中，School类聚合了Student类的多个实例，但学生可以独立于学校存在，这就是聚合关系。

6. 关联（Association）

关联关系表示两个类之间的联系，比如一个类知道另一个类的存在。下面是一个订单类关联一个客户类的示例。

class Customer {
private:
    std::string name;

public:
    Customer(const std::string& name) : name(name) {}

    std::string getName() const {
        return name;
    }
};

class Order {
private:
    int orderId;
    Customer* customer;

public:
    Order(int orderId, Customer* customer) : orderId(orderId), customer(customer) {}

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

在这个示例中，Order类关联了Customer类，通过Customer类的实例来标识订单的客户，这就是关联关系。