一. 面向对象设计原则
1. 依赖倒置原则 ( DIP )
- 高层模块 (稳定) 不应该依赖于底层模块 (变化) , 二者都应该依赖于抽象
- 抽象 (稳定) 不应该依赖于实现细节 (变化),实现细节都应该依赖于抽象
2. 开放封闭原则 ( OCP )
- 对扩展开放,对更改封闭
- 类模块应该是可扩展的,但是不可修改
3. 单一职责原则 (SRP)
- 一个类应该仅有一个引起它变化的原因
- 变化的方向隐含着类的责任
4. Liskov替换原则 (LSP)
- 子类必须能够替换他们的基类 (IS-A)
- 继承表达类型抽象
5. 接口隔离原则 (ISP)
- 不应该强迫客户程序依赖他们不用的方法
- 接口应该小而完备
6. 优先使用对象组合,而不是类继承
- 类继承通常为 "白箱复用" ,对象组合通常为 "黑箱复用"
- 继承在某种程度上破坏了封装性, 子类父类耦合度高。
- 而对象组合则只要求被组合的对象具有良好定义的接口,耦合度低
7. 封装变化点
- 使用封装来创建对象之间的分界层,让设计者可以在分界点一侧进行修改,而不会对另一侧产生不良的影响,
从而实现层次间耦合
8. 针对接口编程,而不是针对实现编程
- 不将变量类型声明而某个特定的具体类,而是声明为某个接口
- 客户程序无需获知对象的具体类型,只需知道对象所具有的接口
- 减少系统中各部分的依赖关系, 从而实现“高内聚,松耦合” 的类型设计方案
标准
二. 设计模式
组件协作
1. Template Method - 模版方法
Template 模式是采用继承的方式实现这一点:将逻辑(算法)框架放在抽象基类中,并 定义好细节的接口,子类中实现细节。
类图
Template 模式获得一种反向控制结构效果,这也是面向对象系统的分析和设计中一个原
则 DIP(依赖倒置:Dependency Inversion Principles)。其含义就是父类调用子类的操作(高 层模块调用低层模块的操作),
低层模块实现高层模块声明的接口。这样控制权在父类(高 层模块),低层模块反而要依赖高层模块。
简略代码实现
#include <stdio.h>
#include <iostream>
using namespace std;
class AbstractClass {
public:
void TemplateMethod() {
primitiveOperation1();
primitiveOperation4();
primitiveOperation2();
primitiveOperation3();
}
void primitiveOperation1() { }
void primitiveOperation4() { }
protected:
void primitiveOperation2() { }
void primitiveOperation3() { }
};
class ConcreteClass : public AbstractClass {
protected:
void primitiveOperation2() { }
void primitiveOperation3() { }
};
int main(int argc, char *argv[])
{
ConcreteClass c;
c.TemplateMethod();
return 0;
}
2. Stragety - 策略模式
Strategy 模式将逻辑(算法)封装到一个类(Context) 里面,通过组合的方式将具体算法的实现在组合对象中实现,
再通过委托的方式将抽象接口 的实现委托给组合对象实现
#include <stdio.h>
#include <iostream>
using namespace std;
class Stragegy{
public:
virtual void AlgrithmInterface() = 0;
virtual ~Stragegy(){};
};
class ConcreteStrategyA : public Stragegy
{
public:
void AlgrithmInterface() {
printf("algorithm 1");
}
};
class ConcreteStrategyB : public Stragegy
{
public:
void AlgrithmInterface() {
printf("algorithm 2");
}
};
class Context {
public:
void DoAction() {
m_s->AlgrithmInterface();
}
Context(Stragegy *s)
:m_s(s) {}
~Context() {
if(m_s) delete m_s;
}
private:
Stragegy *m_s;
};
int main(int argc, char *argv[])
{
Stragegy *s = new ConcreteStrategyA();
Context c(s);
c.DoAction();
return 0;
}
3. Observer - 观察者模式
目标对象的状态发生改变,所有的观察者对象都将得到通知
定义对象间的一种一对多(变化)的依赖关系,以便当一个对象(Subject)的状态发生改变时,所有依赖于它的对象得到通知并自动更新
#include <list>
#include <string>
#include <iostream>
using namespace std;
//观察者的基类
class Subject;
class Observer {
public:
virtual ~Observer(){ }
virtual void Update(Subject* sub) = 0;
virtual void PrintInfo() = 0;
protected:
Observer(){
_st = "";
}
string _st;
};
^^^^^^^^^^^^^^^^^^^^观察的对象
class Subject {
public:
virtual ~Subject(){
if(_obvs) { delete _obvs;}
}
virtual void Attach(Observer* obv){
_obvs->push_back(obv);
}
virtual void Detach(Observer* obv){
if(obv != NULL) {
_obvs->remove(obv);
}
}
virtual void Notify() {
list<Observer*>::iterator it = _obvs->begin();
for(; it != _obvs->end(); it++) {
(*it)->Update(this);
}
}
virtual void SetState(const string &st) = 0;
virtual string GetStatus() = 0;
protected:
Subject() { _obvs = new list<Observer*>;}
private:
list<Observer*> * _obvs;
};
class ConcreteSubject : public Subject
{
public:
ConcreteSubject() {_st= "";}
~ConcreteSubject(){}
string GetStatus(){ return _st;}
void SetState(const string &st) { _st = st;}
private:
string _st;
};
///^^^^^^^^^^^^^^^^^^^^^^^^^^^观察者
class ConcreteObserverA : public Observer
{
public:
ConcreteObserverA(Subject* sub) {
_sub = sub;
_sub->Attach(this);
}
virtual ~ConcreteObserverA(){
if(_sub) {
_sub->Detach(this);
}
}
Subject* GetSubject() {
return _sub;
}
void Update(Subject* sub){
_st = sub->GetStatus();
PrintInfo();
}
void PrintInfo(){
cout << "ConcreteObserverA get notify." <<endl;
}
private:
Subject *_sub;
};
class ConcreteObserverB : public Observer
{
public:
ConcreteObserverB(Subject* sub) {
_sub = sub;
_sub->Attach(this);
}
virtual ~ConcreteObserverB(){
if(_sub) {
_sub->Detach(this);
}
}
Subject* GetSubject() {
return _sub;
}
void Update(Subject* sub){
_st = sub->GetStatus();
PrintInfo();
}
void PrintInfo(){
cout << "ConcreteObserverB get notify." <<endl;
}
private:
Subject *_sub;
};
int main(int argc, char *argv[])
{
ConcreteSubject * sub = new ConcreteSubject();
Observer* o1 = new ConcreteObserverA(sub);
Observer* o2 = new ConcreteObserverB(sub);
sub->SetState("old");
sub->Notify();
sub->SetState("new");
sub->Notify();
delete o2;
delete o1;
delete sub;
return 0;
}
单一职责模式
4. Decorator - 装饰器模式
通过组合的方式,给已经定义好的类增加新的职责/操作,比生成子类更为灵活
//
// week11_Decorator.cpp
// Boolan
//
// Created by 张峰 on 29/03/2017.
// Copyright © 2017 张峰. All rights reserved.
//
//
// week11_Decorator.cpp
// Boolan
//
// Created by 张峰 on 29/03/2017.
// Copyright © 2017 张峰. All rights reserved.
//
#include <stdio.h>
#include <iostream>
using namespace std;
class Component {
public:
virtual ~Component() {}
virtual void Operation() { }
protected:
Component(){}
};
class ConcreteComponent:public Component {
public:
ConcreteComponent(){}
~ConcreteComponent(){}
virtual void Operation(){
std::cout<< "ConcreteComponent Operation" << std::endl;
}
};
class Decorator : public Component {
public:
Decorator(Component* com)
:_com(com){}
virtual ~Decorator() {
if(_com) delete _com;
}
virtual void Operation(){}
protected:
Component* _com;
};
class ConcreteDecorator : public Decorator {
public:
ConcreteDecorator(Component* com)
:Decorator(com)
{}
~ConcreteDecorator(){}
virtual void Operation(){
_com->Operation();
this->AddedBehavior();
}
void AddedBehavior(){
std::cout << "ConcreteDecorator AddedBehavior"<< std::endl;
}
};
int main(int argc, char * argv[])
{
Component *p = new ConcreteComponent();
Decorator *dc = new ConcreteDecorator(p);
dc->Operation();
delete dc;
return 0;
}
5. Bridge - 桥模式
将抽象部分与它的实现部分分离,使得它们可以独立地变化
//
// week11_Bridge.cpp
// Boolan
//
// Created by 张峰 on 02/04/2017.
// Copyright © 2017 张峰. All rights reserved.
//
#include <iostream>
using namespace std;
//动作接口的基类
class AbstractionImp
{
public:
virtual ~AbstractionImp(){}
virtual void Operation() = 0;
protected:
AbstractionImp(){}
};
class Abstraction{
public:
virtual ~Abstraction(){
}
virtual void Operation() = 0;
protected:
Abstraction(){}
};
class RefinedAbstraction : public Abstraction
{
public:
RefinedAbstraction(AbstractionImp* imp)
:_imp(imp){
}
~RefinedAbstraction(){}
void Operation(){
_imp->Operation();
}
private:
AbstractionImp* _imp;
};
class ConcreteAbstractionImpA : public AbstractionImp
{
public:
ConcreteAbstractionImpA(){}
~ConcreteAbstractionImpA(){}
virtual void Operation(){
std::cout << "ConcreteAbstractionImpA" << std::endl;
}
};
class ConcreteAbstractionImpB : public AbstractionImp
{
public:
ConcreteAbstractionImpB(){
std::cout << "ConcreteAbstractionImpB" << std::endl;
}
~ConcreteAbstractionImpB(){}
virtual void Operation(){}
};
int main(int argc, char *argv[])
{
AbstractionImp* imp = new ConcreteAbstractionImpA();
Abstraction* abs = new RefinedAbstraction(imp);
abs->Operation();
return 0;
}