目录

一，类图

二，类的6种关系

1，泛化

2，实现

3，组合

4，聚合

5，关联

6，依赖

三，总结

一，类图

类图中，每个类由3个部分组成，上面的是类名，中间的是属性，下面的是方法。

属性和方法可以用修饰符修饰：加号（+）表示public；减号（-）表示private；井号(#)表示protected

二，类的6种关系

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

6种关系依次减弱。

参考：UML类图几种关系的总结

1，泛化

泛化是一种继承关系，如老虎类继承动物类，动物是老虎的泛化，老虎是动物的特化。

      class Animal {
      public:
         Animal() {
              posX = posY = 0;
          }
         void move(int dx, int dy) {
              posX += dx, posY += dy;
          }
         void getPos() {
              cout << "x=" << posX << ", y=" << posY << endl;
          }
      private:
         int posX, posY;
      };
      class Tiger :public Animal {
      public:
         Tiger() {
             this->name = "Tiger";
          }
          string name;
      };
      int main()
      {
          Tiger t;
          cout << t.name << endl;
          t.move(3, 4);
          t.getPos();
         return 0;
      }
  
 

2，实现

实现关系是子类实现了接口类。

在JAVA中，有专门的接口类和实现的关键字。

在C++中，用纯虚类作为接口类，而且纯虚类也没有关键字，包含纯虚函数的就是纯虚类。

 老虎类实现了攀爬接口类。

      class Animal {
      public:
         Animal() {
              posX = posY = 0;
          }
         void move(int dx, int dy) {
              posX += dx, posY += dy;
          }
         void getPos() {
              cout << "x=" << posX << ", y=" << posY << endl;
          }
      private:
         int posX, posY;
      };
      class Climb {
      public:
         Climb() {
              posZ = 0;
          }
         virtual void GoClimb(int dz) = 0;
         void getHeight() {
              cout << "z=" << posZ << endl;
          }
      protected:
         int posZ;
      };
      class Tiger :public Animal, public Climb {
      public:
         Tiger() {
             this->name = "Tiger";
          }
          string name;
         void GoClimb(int dz) {
              posZ += dz;
          }
      };
      int main()
      {
          Tiger t;
          cout << t.name << endl;
          t.move(3, 4);
          t.getPos();
          t.GoClimb(5);
          t.getHeight();
         return 0;
      }
  
 

3，组合

组合是整体与部分的关系，个体没有独立的生命周期。

组合是把个体对象作为整体类的属性。

组合关系中，有1对1的，也有1对多的。 

每只老虎有4条腿，1个头。

      class Leg {
      protected:
         int len;
      };
      class Head {
      protected:
         int size;
      };
      class Tiger {
      public:
         Tiger() {
             this->name = "Tiger";
          }
      private:
          string name;
          Leg leg[4];
          Head head;
      };
  
 

4，聚合

聚合也是整体与部分的关系，但个体有独立的生命周期。

聚合是把个体对象的指针作为整体类的属性。

 虎群里可能有1-n只老虎。

      class TigerGroup {
      private:
          vector<Tiger*> vtiger;
      };
  
 

5，关联

关联是一种拥有关系，它使一个类知道另一个类的属性和方法，

如老虎拥有若干食物，那么它就知道每个食物是什么，什么颜色，有没有坏掉等等。

有1-n的单向关联，也有n-n的双向关联，双向关联可以用双向箭头，也可以没有箭头。

      class Food {
      protected:
      	string foodName;
      	string foodColor;
      };
      class Tiger {
      public:
     	Tiger() {
     		this->name = "Tiger";
      	}
      private:
      	string name;
      	Leg leg[4];
      	Head head;
      	vector<Food> food;
      };
  
 

在《大话设计模式》中企鹅和气候的关系也是关联，理由是企鹅需要知道气候的变化。

6，依赖

依赖是一种使用关系，如老虎喝水。

      class Leg {
      protected:
     	int len;
      };
      class Head {
      protected:
     	int size;
      };
      class Food {
      protected:
      	string foodName;
      	string foodColor;
      };
      class Water {
      private:
     	float weight;
      };
      class Tiger {
      public:
     	Tiger() {
     		this->name = "Tiger";
      	}
     	void Drink(Water water) {
     		return;
      	}
      private:
      	string name;
      	Leg leg[4];
      	Head head;
      	vector<Food> food;
      };
  
 

三，总结

文章来源: blog.csdn.net，作者：csuzhucong，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/nameofcsdn/article/details/121063408