C++【设计模式】 | 【01】面向对象回顾

一、面向对象回顾

1、如何看待面向对象

• 从语言实现层面来看，对象封装了代码和数据；
• 从规格层面讲，对象是一系列可被使用的公共接口；
• 从概念层面讲，对象是某种拥有责任的抽象；

2、三大机制

• 封装：隐藏内部实现；
• 继承：复用现有代码；
• 多态：改写对象行为；

3、如何使用面向对象解决复杂性???

• 分解：人们面对复杂性有一个常见的做法：即分而治之，将大问题分解为多个小问题，将复杂问题分解为多个简单问题；
• 抽象：更高层次来讲，人们处理复杂性有一个通用的技术，即抽象。由于不能掌握全部的复杂对象，我们选择忽视它的非本质细节，而去处理泛化和理想化了的对象模型；

4、面向对象的优势

• 从宏观层面来看，面向对象的构建方式更能适应软件的变化，能将变化所带来的影响减为最小；
• 从微观层面来看，面向对象的方式更强调各个类的“责任”；由于需求变化导致的新增类型不应该影响原来类型的实现——
  是所谓各负其责；

5、面向对象原则八大原则

5.1 依赖倒置原则

• 高层模块(稳定)不应该依赖于低层模块(变化)，二者都应该依赖于抽象(稳定)；
• 抽象(稳定)不应该依赖于实现细节(变化) ，实现细节应该依赖于抽象(稳定)；

5.2 开放封闭原则

• 对扩展开放，对更改封闭；
• 类模块应该是可扩展的，但是不可修改；

5.3 单一职责原则

• 一个类应该仅有一个引起它变化的原因；
• 变化的方向隐含着类的责任；

5.4 Liskov 替换原则

• 子类必须能够替换它们的基类(IS-A)；
• 继承表达类型抽象；

5.5 接口隔离原则

• 不应该强迫客户程序依赖它们不用的方法；
• 接口应该小而完备；

5.6 优先使用对象组合，而不是类继承

• 类继承通常为白箱复用，对象组合通常为黑箱复用。
• 继承在某种程度上破坏了封装性，子类父类耦合度高；
• 而对象组合则只要求被组合的对象具有良好定义的接口，耦合度低；

5.7 封装变化点

• 使用封装来创建对象之间的分界层，让设计者可以在分界层的一侧进行修改，而不会对另一侧产生不良的影响，从而实现层
  次间的松耦合；

5.8 针对接口编程，而不是针对实现编程

• 不将变量类型声明为某个特定的具体类，而是声明为某个接口；
• 客户程序无需获知对象的具体类型，只需要知道对象所具有的接口；
• 减少系统中各部分的依赖关系，从而实现高内聚、松耦合的类型设计方案；

二、设计原则

1、设计习语

• 描述与特定编程语言相关的低层模式，技巧，惯用法；

2.、设计模式 Design Patterns

• 主要描述的是类与相互通信的对象之间的组织关系，包括它们的角色、职责、协作方式等方面；

3、架构模式 Architectural Patterns

• 描述系统中与基本结构组织关系密切的高层模式，包括子系统划分，职责，以及如何组织它们之间关系的规则；

三、模式分类

1、从目的来看：

• 创建型模式：将对象的部分创建工作延迟到子类或者其他对象，从而应对需求变化为对象创建时具体类型实现引来的冲击。
• 结构型模式：通过类继承或者对象组合获得更灵活的结构，从而应对需求变化为对象的结构带来的冲击。
• 行为型模式：通过类继承或者对象组合来划分类与对象间的职责，从而应对需求变化为多个交互的对象带来的冲击。

2、从范围来看：

• 类模式处理类与子类的静态关系。
• 对象模式处理对象间的动态关系。

四、封装变化角度对模式分类

1、组件协作：

• 模板方法（Template Method）算法步骤；
• 观察者（Observer / Event）：依赖对象如何保持最新；
• 策略（Strategy）：一种算法；

1、单一职责：

• 装饰者（Decorator）：没有子类化的对象的职责；
• 桥梁（Bridge）：对象的实现；

2、对象创建:

• 工厂模式（Factory Method）：被实例化的对象的子类；
• 抽象工厂Abstract Factory：产品对象族；
• 原型（Prototype）：被实例化的对象类；
• Builder：如何创建复合对象；

3、对象性能：

• 单例（Singleton）：类的唯一实例；
• 享元（Flyweight）：对象的存储成本；

4、接口隔离:

• 外观（Facade）：子系统的接口；
• 代理（Proxy）：如何访问对象（其位置）；
• 中介者（Mediator）：如何以及哪些对象相互交互；
• 适配器（Adapter）：对象的接口；

5、状态变化：

• 备忘录（Memento）：对象外部存储了哪些私人信息，以及何时存储；
• 状态（State）：对象的状态；

6、数据结构：

• 对象的复合（Composite）：结构和组合；
• 迭代器（Iterator）：如何访问聚合的元素；
• 责任链（Chain of Resposibility）：可以满足请求的对象；

7、行为变化：

• 命令（Command）：何时以及如何完成请求；
• 访问者（Visitor）：可以应用于对象而不更改其类的操作；

8、领域问题：

• 口译员（Interpreter）：语法和语言解释；

三、面向对象抽象代码示例

1、不使用多态代码

cpp

class MainForm : public Form {
private:
	Point p1;
	Point p2;

	vector<Line> lineVector;
	vector<Rect> rectVector;
	//改变
	vector<Circle> 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;

	//...
	Form::OnMouseDown(e);
}

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

	if (rdoLine.Checked){
		Line line(p1, p2);
		lineVector.push_back(line);
	}
	else if (rdoRect.Checked){
		int width = abs(p2.x - p1.x);
		int height = abs(p2.y - p1.y);
		Rect rect(p1, width, height);
		rectVector.push_back(rect);
	}
	//改变
	else if (...){
		//...
		circleVector.push_back(circle);
	}

	//...
	this->Refresh();

	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);
	}

	//针对矩形
	for (int i = 0; i < rectVector.size(); i++){
		e.Graphics.DrawRectangle(Pens.Red,
			rectVector[i].leftUp,
			rectVector[i].width,
			rectVector[i].height);
	}

	//改变
	//针对圆形
	for (int i = 0; i < circleVector.size(); i++){
		e.Graphics.DrawCircle(Pens.Red,
			circleVector[i]);
	}

	//...
	Form::OnPaint(e);
}

h

class Point{
public:
	int x;
	int y;
};

class Line{
public:
	Point start;
    Point end;

	Line(const Point& start, const Point& end){
        this->start = start;
        this->end = end;
    }

};

class Rect{
public:
	Point leftUp;
    int width;
	int height;

	Rect(const Point& leftUp, int width, int height){
        this->leftUp = leftUp;
        this->width = width;
		this->height = height;
    }

};

//增加
class Circle{
};

2、使用多态

cpp

class MainForm : public Form {
private:
	Point p1;
	Point p2;

	//针对所有形状
	vector<Shape*> shapeVector;

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;

	//...
	Form::OnMouseDown(e);
}

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

	if (rdoLine.Checked){
		shapeVector.push_back(new Line(p1,p2));
	}
	else if (rdoRect.Checked){
		int width = abs(p2.x - p1.x);
		int height = abs(p2.y - p1.y);
		shapeVector.push_back(new Rect(p1, width, height));
	}
	//改变
	else if (...){
		//...
		shapeVector.push_back(circle);
	}

	//...
	this->Refresh();

	Form::OnMouseUp(e);
}

void MainForm::OnPaint(const PaintEventArgs& e){

	//针对所有形状
	for (int i = 0; i < shapeVector.size(); i++){

		shapeVector[i]->Draw(e.Graphics); //多态调用，各负其责
	}

	//...
	Form::OnPaint(e);
}

h

class Shape{
public:
	virtual void Draw(const Graphics& g)=0;
	virtual ~Shape() { }
};


class Point{
public:
	int x;
	int y;
};

class Line: public Shape{
public:
	Point start;
	Point end;

	Line(const Point& start, const Point& end){
		this->start = start;
		this->end = end;
	}

	//实现自己的Draw，负责画自己
	virtual void Draw(const Graphics& g){
		g.DrawLine(Pens.Red, 
			start.x, start.y,end.x, end.y);
	}

};

class Rect: public Shape{
public:
	Point leftUp;
	int width;
	int height;

	Rect(const Point& leftUp, int width, int height){
		this->leftUp = leftUp;
		this->width = width;
		this->height = height;
	}

	//实现自己的Draw，负责画自己
	virtual void Draw(const Graphics& g){
		g.DrawRectangle(Pens.Red,
			leftUp,width,height);
	}

};

//增加
class Circle : public Shape{
public:
	//实现自己的Draw，负责画自己
	virtual void Draw(const Graphics& g){
		g.DrawCircle(Pens.Red,...);
	}

};