面向对象设计原则
依赖倒置原则
- 高层模块（稳定）不应该依赖低层模块（变化），二者都应该依赖于抽象（稳定）
- 抽象（稳定）不应该依赖于实现细节（变化），实现细节应该依赖于抽象（稳定）
- 分解：大问题分解成小问题，在面向过程的设计中使用。
- 抽象：忽略细节只抓重点去处理泛化的、理想化的模型，在面向对象中使用。
- 画图操作中，高层模块为main的画图操作，底层模块为各种形状类，抽象为Shape基类；main和形状都依赖于Shape基类，而Shape基类独立于具体形状类型。软件需求改变时，要改变低层模块，而不是抽象或是高层模块
开放封闭原则
- 对扩展开放，对更改封闭
- 类模块应该是可扩展的，但是不可修改
- 设计者可以通过增加内容进行扩展，而不需要在各段代码中修改东西
单一职责原则
- 类应该仅有一个引起他变化的原因
- 变化的方向隐含着类的责任
替换原则
- 子类必须能够替换他们的基类（IS-A）
- 继承表达类型抽象
- 所有需要父类的地方，作为子类都应该能够使用
接口隔离原则
- 不应该强迫客户程序依赖他们不用的方法
- 接口应该小而完备
- 不必要的方法不要public
优先使用对象组合，而不是类继承
- 继承在某种程度上破坏了封装性，子类父类耦合度高
- 对象组合则只要求被组合的对象具有良好定义的接口，耦合度低
封装变化点
- 使用封装来创建对象之间的分界层，让设计者可以在分界层一侧进行修改，而不会对另一侧产生不良影响，从而实现层次间的松耦合
针对接口编程，而不是针对实现编程
模版方法：：组件协作
class Library**{**
public**:**
//稳定 template method
void Run**(){**
Step1**();**
**if** **(**Step2**())** **{** //支持变化 ==> 虚函数的多态调用
Step3**();**
**}**
**for** **(**int i **=** 0**;** i **<** 4**;** i**++){**
Step4**();** //支持变化 ==> 虚函数的多态调用
**}**
Step5**();**
**}**
virtual **~**Library**(){** **}**
protected**:**
void Step1**()** **{** //稳定
//.....
**}**
void Step3**()** **{**//稳定
//.....
**}**
void Step5**()** **{** //稳定
//.....
**}**
virtual bool Step2**()** **=** 0**;**//变化
virtual void Step4**()** **=**0**;** //变化
**};**
策略模式
- 定义一系列算法，把他们一个个封装起来，并且使他们可以互相替换（变化）。改模式使得算法可以独立于使用它的客户程序（稳定）而变化（扩展，子类化）
- 用改模式替换多种switch
class TaxStrategy**{**
public**:**
virtual double Calculate**(**const Context**&** context**)=**0**;** //纯虚算法
virtual **~**TaxStrategy**(){}**
**};**
class CNTax **:** public TaxStrategy**{**
public**:**
virtual double Calculate**(**const Context**&** context**){**
//***********
**}**
**};**
//扩展
//*********************************
class FRTax **:** public TaxStrategy**{**
public**:**
virtual double Calculate**(**const Context**&** context**){**
//.........
**}**
**};**
//使用****
class SalesOrder**{**
private**:**
TaxStrategy***** strategy**;**
public**:**
****//利用工厂模式（以后学到）来动态得到一个堆对象，这里暂时不表。****
SalesOrder**(**StrategyFactory***** strategyFactory**){**
**this->**strategy **=** strategyFactory**->**NewStrategy**();**
**}**
**~**SalesOrder**(){**
**delete** **this->**strategy**;**
**}**
public double CalculateTax**(){**
//...
Context context**();**
double val **=**
strategy**->**Calculate**(**context**);** //多态
//...
**}**
**};**
观察者模式
- 定义对象间的一种一对多（变化）的依赖关系以便当一个对象（Subject）的状态发生变化时，所有依赖于它得对象都得到通知并自动更新
Paste_Image.png
class IProgress**{**// 抽象通知机制的接口
public**:**
virtual void DoProgress**(**float value**)=**0**;**
virtual **~**IProgress**(){}**
**};**
class FileSplitter
**{**
string m_filePath**;**
int m_fileNumber**;**
List**<**IProgress***>** m_iprogressList**;** // 抽象通知机制，支持多个观察者
public**:**
FileSplitter**(**const string**&** filePath**,** int fileNumber**)** **:**
m_filePath**(**filePath**),**
m_fileNumber**(**fileNumber**){**
**}**
void split**(){**
//1.读取大文件
//2.分批次向小文件中写入
**for** **(**int i **=** 0**;** i **<** m_fileNumber**;** i**++){**
//...
float progressValue **=** m_fileNumber**;**
progressValue **=** **(**i **+** 1**)** **/** progressValue**;**
onProgress**(**progressValue**);**//发送通知
**}**
**}**
void addIProgress**(**IProgress***** iprogress**){**
m_iprogressList**.**push_back**(**iprogress**);**
**}**
void removeIProgress**(**IProgress***** iprogress**){**
m_iprogressList**.**remove**(**iprogress**);**
**}**
protected**:**
virtual void onProgress**(**float value**){** //作为虚方法，以备将来可能对分割器进行扩展
List**<**IProgress***>::**iterator itor**=**m_iprogressList**.**begin**();**
**while** **(**itor **!=** m_iprogressList**.**end**()** **)**
**(***itor**)->**DoProgress**(**value**);** //由框架告知控件进行数据更新
itor**++;**
**}**//利用循环通知所有想要获取进行状态的对象，支持多个观察者。
**}**
**};**
class MainForm **:** public Form**,** public IProgress
**{**
TextBox***** txtFilePath**;**
TextBox***** txtFileNumber**;**
ProgressBar***** progressBar**;**
public**:**
void Button1_Click**(){**
string filePath **=** txtFilePath**->**getText**();**
int number **=** atoi**(**txtFileNumber**->**getText**().**c_str**());**
ConsoleNotifier cn**;**
FileSplitter splitter**(**filePath**,** number**);**
splitter**.**addIProgress**(this);** //订阅通知，添加到Observer的通知列表中
splitter**.**addIProgress**(&**cn**)**;
splitter**.**split**();**
splitter**.**removeIProgress**(this);**
**}**
virtual void DoProgress**(**float value**){**
progressBar**->**setValue**(**value**);**
**}**
**};**
//提供另一种显示方式。
class ConsoleNotifier **:** public IProgress **{**
public**:**
virtual void DoProgress**(**float value**){**
cout **<<** "."**;**
**}**
**};**
装饰器
- 动态（组合）地给 一个对象增加些额外的职责。 就增加功能而言， Decorator模式比生成子类（继承）更为灵活（消除重复代码＆减少子类个数）
class Stream**{**
public：
virtual char Read**(**int number**)=**0**;**
virtual void Seek**(**int position**)=**0**;**
virtual void Write**(**char data**)=**0**;**
virtual **~**Stream**(){}**
**};**
//主体类
class FileStream**:** public Stream**{**
public**:**
virtual char Read**(**int number**){**
//读文件流
**}**
virtual void Seek**(**int position**){**
//定位文件流
**}**
virtual void Write**(**char data**){**
//写文件流
**}**
**};**
class NetworkStream **:**public Stream**{**
public**:**
virtual char Read**(**int number**){**
//读网络流
**}**
virtual void Seek**(**int position**){**
//定位网络流
**}**
virtual void Write**(**char data**){**
//写网络流
**}**
**};**
//扩展操作，使用传统方法，存在大量的重复代码。。
class CryptoFileStream **:**public FileStream**{**
public**:**
virtual char Read**(**int number**){**
//额外的加密操作...
FileStream**::**Read**(**number**);**//读文件流
**}**
virtual void Seek**(**int position**){**
//额外的加密操作...
FileStream**::**Seek**(**position**);**//定位文件流
//额外的加密操作...
**}**
virtual void Write**(**byte data**){**
//额外的加密操作...
FileStream**::**Write**(**data**);**//写文件流
//额外的加密操作...
**}**
**};**
class CryptoNetworkStream **:** **:**public NetworkStream**{**
public**:**
virtual char Read**(**int number**){**
//额外的加密操作...
NetworkStream**::**Read**(**number**);**//读网络流
**}**
virtual void Seek**(**int position**){**
//额外的加密操作...
NetworkStream**::**Seek**(**position**);**//定位网络流
//额外的加密操作...
**}**
virtual void Write**(**byte data**){**
//额外的加密操作...
NetworkStream**::**Write**(**data**);**//写网络流
//额外的加密操作...
**}**
**};**//每种流的同样处理却要用很多段不同的代码。
======================================================================
//扩展操作，应用装饰器。
//使用继承的目的在于，只有通过继承才能改写虚函数Read，Seek等；如果是再重新定义一个Read，Seek操作，则有装饰流和无装饰流不从属于个基类，无法放在一个容器里实现多态。
//实用组合的目的在于，可以把具体的被装饰类延迟到运行时决定，而不用静态的决定好。（因为继承一定是静态的，组合可以是动态的。）
DecoratorStream**:** public Stream**{**
//作为基类的第一派生类（中间类），为其赋予一个委托。
//stream对象也可以直接扔在下面的加密流中，不过考虑到可能还有内存流，缓冲流等其他的//流，他们都要有这样一个委托。根据马丁福勒的重构理论，同一基类的不同子类中的相同元//素应该"往上提"。
protected**:**
Stream***** stream**;**//...
DecoratorStream**(**Stream ***** stm**):**stream**(**stm**){**
**}**
**};**
class CryptoStream**:** public DecoratorStream **{**
public**:**
CryptoStream**(**Stream***** stm**):**DecoratorStream**(**stm**){**
**}**
virtual char Read**(**int number**){**
//额外的加密操作...
stream**->**Read**(**number**);**//读文件流
**}**
virtual void Seek**(**int position**){**
//额外的加密操作...
stream**::**Seek**(**position**);**//定位文件流
//额外的加密操作...
**}**
virtual void Write**(**byte data**){**
//额外的加密操作...
stream**::**Write**(**data**);**//写文件流
//额外的加密操作...
**}**
**};**//所有的流都可以用这个类进行装饰，只需要把流指定为基类的成员。
void Process**(){**
//运行时装配
FileStream***** s1**=new** FileStream**();**
CryptoStream***** s2**=new** CryptoStream**(**s1**);**
//使用时最外层应该是装饰器。
**}**
桥模式
