变化是设计中最大的挑战，是复用的天敌。而使用抽象的面向对象设计最大优势就是抵御变化。

设计原则比设计模式更重要。有了设计原则呢，你可以发明自己的模式；你也可以去理解其他一些新的设计模式，或其他的设计模式。
一个错误的观点：把模式当成算法来学习。

  1. 两段代码非常像，但可能表达的是完全不同的设计模式
  2. 有的时候，两段代码千差万别，但可能表达的是同一个设计模式
  3. 评判设计模式的规则是设计原则，而不是代码本身，实现本身。是按照设计原则来归类的。

    将设计原则提升为设计经验

    设计经验有三类
类型 说明
设计习语
Design Idioms		 描述与特定编程语言相关的低层模式、技巧、惯用法。比如C++中的《Effective C++》等
设计模式
Design Patterns		 描述“类与相互通信的对象之间的组织关系”，包括它们的角色、职责、协作方式等方面。主要解决的是变化中的复用性问题
架构模式
Architectural Patterns		 描述系统中基本结构组织关系密切的高层模式，包括子系统划分，职责，以及如何组织它们之间关系的规则

示例

示例中包含两种思维模型，在接下来会以这两个例子来说明设计原则。

以一个画图工具为例，说明两种思维模型

  1. 一开始的需求：需要实现画线、画矩形两个方法
  2. 需求变更：需要在画线画矩阵的基础上，添加画圆

看两种思维模式在需求变更时，需要修改的地方。

第一种思维模型：分解（结构化编程）

分而治之，针对圆形怎么做、针对矩形怎么做，针对圆怎么做

  1. MainForm.cpp ```cpp class MainForm : public Form { private: Point p1; //鼠标点的第一个点 Point p2; //鼠标点的第二个点 //当下需求只有画线、画矩形 vector lineVector; vector rectVector; //需求变更后，新增画圆 vector circleVector;

public: MainForm(){ //… } protected: virtual void OnMouseDown(const MouseEventArgs& e); virtual void OnMouseUp(const MouseEventArgs& e); virtual void OnPaint(const PaintEventArgs& e); //界面被刷新 };

//鼠标按下：取第一个点坐标 void MainForm::OnMouseDown(const MouseEventArgs& e){ p1.x = e.X; p1.y = e.Y;

  1. //...
  2. Form::OnMouseDown(e);

}

//鼠标抬起：取第二个点坐标 void MainForm::OnMouseUp(const MouseEventArgs& e){ p2.x = e.X; p2.y = e.Y;

  1. if (rdoLine.Checked){ //用户选择画线
  2.     Line line(p1, p2);
  3.     lineVector.push_back(line);
  4. }
  5. else if (rdoRect.Checked){    //用户选择画矩形
  6.     int width = abs(p2.x - p1.x);
  7.     int height = abs(p2.y - p1.y);
  8.     Rect rect(p1, width, height);
  9.     rectVector.push_back(rect);
  10. }
  11. //需求变更后，新增画圆
  12. else if (...){
  13.     //...
  14.     circleVector.push_back(circle);
  15. }
  17. //刷新则调用onPaint
  18. this->Refresh();
  20. Form::OnMouseUp(e);

}

void MainForm::OnPaint(const PaintEventArgs& e){ //针对直线 for (int i = 0; i < lineVector.size(); i++){ e.Graphics.DrawLine(Pens.Red, lineVector[i].start.x, lineVector[i].start.y, lineVector[i].end.x, lineVector[i].end.y); }

  1. //针对矩形
  2. for (int i = 0; i < rectVector.size(); i++){
  3.     e.Graphics.DrawRectangle(Pens.Red,
  4.         rectVector[i].leftUp,
  5.         rectVector[i].width,
  6.         rectVector[i].height);
  7. }
  9. //需求变更：添加针对圆形
  10. for (int i = 0; i < circleVector.size(); i++){
  11.     e.Graphics.DrawCircle(Pens.Red, circleVector[i]);
  12. }
  14. //...
  15. Form::OnPaint(e);

}

  2. 2. shape.h
  3. ```cpp
  4. class Point{
  5. public:
  6.     int x;
  7.     int y;
  8. };
  10. class Line{
  11. public:
  12.     Point start;
  13.     Point end;
  15.     Line(const Point& start, const Point& end){
  16.         this->start = start;
  17.         this->end = end;
  18.     }
  20. };
  22. class Rect{
  23. public:
  24.     Point leftUp;
  25.     int width;
  26.     int height;
  28.     Rect(const Point& leftUp, int width, int height){
  29.         this->leftUp = leftUp;
  30.         this->width = width;
  31.         this->height = height;
  32.     }
  34. };
  36. //需求变更，增加代码：添加圆类
  37. class Circle{
  38. };

第二种思维模型：抽象（面向对象）

  1. MainFrom.cpp ```cpp class MainForm : public Form { private: Point p1; Point p2;

    //不需要一个类型一个数组，只需要一个父类指针就可对所有形状的描述 vector shapeVector; //说明：这里不能是vector，如果LineString赋值给Shape，会变成Shape结构空间 //这样就不能有多态性，Shape只能表示它自己，而不能表示子类

public: MainForm(){ //… } protected:

  1. virtual void OnMouseDown(const MouseEventArgs& e);
  2. virtual void OnMouseUp(const MouseEventArgs& e);
  3. virtual void OnPaint(const PaintEventArgs& e);

};

void MainForm::OnMouseDown(const MouseEventArgs& e){ p1.x = e.X; p1.y = e.Y;

  1. //...
  2. Form::OnMouseDown(e);

}

void MainForm::OnMouseUp(const MouseEventArgs& e){ p2.x = e.X; p2.y = e.Y;

  1. if (rdoLine.Checked){ //画线开关
  2.     shapeVector.push_back(new Line(p1,p2));
  3. }
  4. else if (rdoRect.Checked){ //画矩形开关
  5.     int width = abs(p2.x - p1.x);
  6.     int height = abs(p2.y - p1.y);
  7.     shapeVector.push_back(new Rect(p1, width, height));
  8. }
  9. //需求变更：添加画圆
  10. else if (...){
  11.     //...
  12.     shapeVector.push_back(circle);
  13. }
  15. //...
  16. this->Refresh();
  18. Form::OnMouseUp(e);

}

void MainForm::OnPaint(const PaintEventArgs& e){ //针对所有形状 for (int i = 0; i < shapeVector.size(); i++){ shapeVector[i]->Draw(e.Graphics); //多态调用，各负其责 }

  1. //...
  2. Form::OnPaint(e);

}

  2. 2. shape.h
  3. ```cpp
  4. class Shape{
  5. public:
  6.     virtual void Draw(const Graphics& g)=0;    //绘制
  7.     virtual ~Shape() { }    //析构
  8. };
  11. class Point{
  12. public:
  13.     int x;
  14.     int y;
  15. };
  17. class Line: public Shape{
  18. public:
  19.     Point start;
  20.     Point end;
  22.     Line(const Point& start, const Point& end){
  23.         this->start = start;
  24.         this->end = end;
  25.     }
  27.     //实现自己的Draw，负责画自己
  28.     virtual void Draw(const Graphics& g){
  29.         g.DrawLine(Pens.Red, 
  30.             start.x, start.y,end.x, end.y);
  31.     }
  33. };
  35. class Rect: public Shape{
  36. public:
  37.     Point leftUp;
  38.     int width;
  39.     int height;
  41.     Rect(const Point& leftUp, int width, int height){
  42.         this->leftUp = leftUp;
  43.         this->width = width;
  44.         this->height = height;
  45.     }
  47.     //实现自己的Draw，负责画自己
  48.     virtual void Draw(const Graphics& g){
  49.         g.DrawRectangle(Pens.Red,
  50.             leftUp,width,height);
  51.     }
  53. };
  55. //需求变更所添加的代码
  56. class Circle : public Shape{
  57. public:
  58.     //实现自己的Draw，负责画自己
  59.     virtual void Draw(const Graphics& g){
  60.         g.DrawCircle(Pens.Red,
  61.             ...);
  62.     }
  63. };