在一定环境下，用固定模式解决问题。
设计模式目前种类：GoF的23种 + “简单工厂模式” = 24种
包括：
创建型（Creational）模式：如何创建对象，6种
结构性（Structual）模式：如何实现类或对象的组合，7种
行为型（Behavioral）模式：类或对象怎样交互以及怎样分配职责，11种
学习设计模式有利于更深理解面向对象思想，让你知道：
1.如何将代码分散在几个不同的类中？
2.为什么要有“接口”
3.何胃针对抽象编程
4.何时不应该使用继承？
5.如果不修改源代码增加新功能？
6.更好低阅读和理解现有类库与其他系统中的源代码？
设计模式的基础：多态（继承，虚函数重写，父类指针或引用指向子类对象）
原则：
对于面向对象软件系统的设计而言，在支持可维护性的同时，提高系统的
可复用性是一个至关重要的问题，如何同时提高一个软件系统的可维护性和可
复用性是面向对象设计需要解决的核心问题之一。 在面向对象设计中，可维护
性的复用是以设计原则为基础的。每一个原则都蕴含一些面向对象设计的思想，
可以从不同的角度提升一个软件结构的设计水平。
面向对象设计原则为支持可维护性复用而诞生，这些原则蕴含在很多设计
模式中，它们是从许多设计方案中总结出的指导性原则。 面向对象设计原则也
是我们用于评价一个设计模式的使用效果的重要指标之一。
目标：高内聚，低耦合
单一职责原则：类的职责单一，对外只提供一种功能
将每个类的方法分离出来，就能保证每个类的指针单一
提高安全性
提高了维护性
提高了可读性
#include <iostream>
using namespace std;
class Clothes
{
public:
void shopping()
{
cout << "休闲的衣服" << endl;
}
void working()
{
cout << "工作的衣服" << endl;
}
};
class ClothesShoping
{
public:
void style()
{
cout << "休闲的衣服" << endl;
}
};
class ClothesWorking
{
public:
void style()
{
cout << "工作的衣服" << endl;
}
};
int main()
{
ClothesShoping cs;
cs.style();
ClothesWorking cw;
cw.style();
system("pause");
return 0;
}
开闭原则：类的改动是通过增加代码进行的，而不是修改源代码
提高了可读性
提高了安全性
提高了维护性
提高了可复用性
#include <iostream>
using namespace std;
// 银行业务员：
class Banker
{
public:
void save()
{
cout << "存款" << endl;
}
void pay()
{
cout << "支付" << endl;
}
void tansfer()
{
cout << "转账" << endl;
}
// 添加一个办理基金业务 若添加的业务多，则代码会越来越庞大
void fund()
{
cout << "办理基金" << endl;
}
};
/////////////////////////////////
//////////////////////////////////
// 抽象的银行业务员
//-------------------------------
//- worker() = 0 -
//- -
//-------------------------------
/////////////////////////////////
//////////////////////////////////
// 存款业务员
//-------------------------------
//- -
//- 存款 -
//-------------------------------
/////////////////////////////////
//////////////////////////////////
// 支付业务员
//-------------------------------
//- 支付 -
//- -
//-------------------------------
/////////////////////////////////
//////////////////////////////////
// 转账业务员
//-------------------------------
//- 转账 -
//- -
//-------------------------------
/////////////////////////////////
// 抽象类
// 添加新的业务不需要修改原来代码，只需要添加新代码
class AbstractBanker
{
public:
virtual void worker() = 0;// 抽象接口
};
class SaveBanker:public AbstractBanker
{
public:
virtual void worker()
{
cout << "存款" << endl;
}
};
class PayBanker :public AbstractBanker
{
public:
virtual void worker()
{
cout << "支付" << endl;
}
};
class TransferBanker :public AbstractBanker
{
public:
virtual void worker()
{
cout << "转账" << endl;
}
};
// 添加一个办理基金业务 若添加的业务多，则代码会越来越庞大
class FundBanker :public AbstractBanker
{
public:
virtual void worker()
{
cout << "基金业务" << endl;
}
};
int main()
{
#if 0 // 此方法不好
Banker b;
b.save();
#endif
AbstractBanker* ab = new SaveBanker();
ab->worker();
ab = new PayBanker();
ab->worker();
ab = new TransferBanker();
ab->worker();
delete ab;
system("pause");
return 0;
}
依赖倒转原则：依赖于抽象（借口），不要依赖于具体实现（类），也就是针对接口编程
将业务层和实现层通过抽象层隔离——解耦合
#include <iostream>
using namespace std;
class Benz
{
public:
void run()
{
cout << "奔驰启动了" << endl;
}
};
class Baoma
{
public:
void run()
{
cout << "宝马启动了" << endl;
}
};
class Zhangsan
{
public:
void driveBenz(Benz* b)
{
b->run();
}
void driveBMW(Baoma* b)
{
b->run();
}
};
///////////////////////////////////////
// 高层业务逻辑层
//
///////////////////////////////////////
///////////////////////////////////////
// 抽象层
// Driver Car
///////////////////////////////////////
///////////////////////////////////////
// 实现层 底层向上依赖
// zhangsan lisi baoma benz
///////////////////////////////////////
// 抽象层
class Car
{
public:
virtual void run() = 0;
};
class Driver
{
public:
virtual void driver(Car* car) = 0;
};
class Jeep:public Car
{
public:
virtual void run()
{
cout << "吉普启动了" << endl;
}
};
class Lisi :public Driver
{
public:
virtual void driver(Car* car)
{
cout << "李四开车了" << endl;
car->run();
}
};
// 业务
int main()
{
#if 0
// 让zhangsan 去开benz
Benz* benz = new Benz;
Zhangsan* zhangsan = new Zhangsan;
zhangsan->driveBenz(benz);
// 让zhangsan 去开benz
Baoma* BMW = new Baoma;
zhangsan->driveBMW(BMW);
// 去开大众，jeep...越写越复杂混乱
delete benz;
delete BMW;
delete zhangsan;
#endif
// 只使用两个类
Car* car = new Jeep;
Driver* lisi = new Lisi;
lisi->driver(car);
delete car;
delete lisi;
system("pause");
return 0;
}
合成复用原则：如果使用继承，会导致父类的任何变换都影响到子类的行为。如果使用对 象组合，就降低了这种依赖关系。对于继承和组合，优先使用组合。
如果使用继承方式，那么新的子类将会和所有的父类高耦合
#include <iostream>
using namespace std;
class Cat // 还可以继承动物...
{
public:
void sleep()
{
cout << "小猫睡觉" << endl;
}
};
// 继承方式
class AdCat :public Cat
{
public:
void eat_and_sleep()
{
cout << "吃东西" << endl;
sleep();
}
};
// 使用组合的方式来添加小猫吃东西的方法
// 降低了AdCat2和Cat的耦合度，跟Cat的父类没有任何关系
// 只跟Cat的sleep方法有关系
class AdCat2
{
public:
AdCat2(Cat* cat)
{
this->cat = cat;
}
void eat_and_sleep()// 若将cat以参数传入，则是依赖关系
{
cout << "吃东西" << endl;
cat->sleep();
}
private:
Cat* cat;// 这种关系是关联
};
int main()
{
Cat cat;
AdCat2 adcat(&cat);
adcat.eat_and_sleep();
system("pause");
return 0;
}
原文地址：https://www.cnblogs.com/xiangtingshen/p/10356594.html