面向对象设计原则
原则的目的：高内聚，低耦合
1. 单一职责原则
类的职责单一，对外只提供一种功能，而引起类变化的原因都应该只有一个。
2. 开闭原则
对扩展开放，对修改关闭；增加功能是通过增加代码来实现的，而不是去修改源代码。
#include<iostream>
using namespace std;
//开闭原则
//对扩展开放，对修改关闭；增加功能是通过增加代码来实现的，而不是去修改源代码
//写一个抽象类
class AbstractCaculator
{
public:
virtual int getResult() = 0;
virtual void setOperatorNumber(int a, int b) = 0;
};
//加法计算类
class AddCaculator :public AbstractCaculator
{
public:
virtual void setOperatorNumber(int a, int b)
{
this->mA = a;
this->mB = b;
}
virtual int getResult()
{
return mA + mB;
}
public:
int mA;
int mB;
};
//减法计算器
class SubCaculator :public AbstractCaculator
{
public:
virtual void setOperatorNumber(int a, int b)
{
this->mA = a;
this->mB = b;
}
virtual int getResult()
{
return mA - mB;
}
public:
int mA;
int mB;
};
//乘法计算器
class MolCaculator :public AbstractCaculator
{
public:
virtual void setOperatorNumber(int a, int b)
{
this->mA = a;
this->mB = b;
}
virtual int getResult()
{
return mA * mB;
}
public:
int mA;
int mB;
};
//取模计算器 通过增加代码来实现
class MulCaculator :public AbstractCaculator
{
public:
virtual void setOperatorNumber(int a, int b)
{
this->mA = a;
this->mB = b;
}
virtual int getResult()
{
return mA % mB;
}
public:
int mA;
int mB;
};
void test01()
{
AbstractCaculator* caculator = new AddCaculator;
caculator->setOperatorNumber(10, 20);
cout << "ret:" << caculator->getResult() << endl;
delete caculator;
caculator = new SubCaculator;
caculator->setOperatorNumber(10, 20);
cout << "ret:" << caculator->getResult() << endl;
}
int main()
{
test01();
return 0;
}3. 里氏代换原则
任何抽象类出现的地方都可以用他的实现类进行替换，实际就是虚拟机制，语言级别实现面向对象功能。
4. 依赖倒转原则
依赖于抽象(接口)，不要依赖具体的实现(类)，也就是针对接口编程。
传统方式：
#include<iostream>
using namespace std;
//银行工作人员
class BankWorker
{
public:
void saveService()
{
cout << "办理存款业务..." << endl;
}
void payService()
{
cout << "办理支付业务..." << endl;
}
void tranferService()
{
cout << "办理转账业务..." << endl;
}
};
//中层模块
void doSaveBussiness(BankWorker* worker) {
worker->saveService();
}
void doPayBussiness(BankWorker* worker) {
worker->payService();
}
void doTranferBussiness(BankWorker* worker) {
worker->tranferService();
}
void test04() {
BankWorker* worker = new BankWorker;
doSaveBussiness(worker); //办理存款业务
doPayBussiness(worker); //办理支付业务
doTranferBussiness(worker); //办理转账业务
}
int main()
{
test04();
return 0;
}依赖倒转原则：
#include<iostream>
using namespace std;
//银行工作人员
class AbstractWorker
{
public:
virtual void doBusiness() = 0;
};
//专门办理存款业务的工作人员
class SaveBankWorker :public AbstractWorker
{
public:
virtual void doBusiness()
{
cout << "办理存款业务..." << endl;
}
};
//专门办理支付业务的工作人员
class PayBankWorker :public AbstractWorker
{
public:
virtual void doBusiness()
{
cout << "办理支付业务..." << endl;
}
};
//专门办理转账业务的工作人员
class TransferBankWorker :public AbstractWorker
{
public:
virtual void doBusiness()
{
cout << "办理转账业务..." << endl;
}
};
//中层业务
void doNewBussiness(AbstractWorker* worker)
{
worker->doBusiness();
}
void test04_1()
{
AbstractWorker* transfer = new TransferBankWorker;
doNewBussiness(transfer);
}
int main()
{
test04_1();
return 0;
}5. 接口隔离原则
不应该强迫用户的程序依赖他们不需要的接口方法。一个接口应该只提供一种对外功能，不应该把所有操作都封装到一个接口中去。
6. 迪米特法则(最少知识原则)
一个对象应当对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性。例如在一个程序中，各个模块之间相互调用时，通常会提供一个统一的接口来实现。这样其他模块不需要了解另外一个模块的内部实现细节，这样当一个模块内部的实现发生改变时，不会影响其他模块的使用。（黑盒原理）
#include<iostream>
#include<string>
#include<vector>
using namespace std;
//迪米特法则---最少知识原则
class AbstractBuilding
{
public:
virtual void sale() = 0;
virtual string getQuality() = 0;
};
//楼盘A
class BuildingA : public AbstractBuilding
{
public:
BuildingA()
{
m_Quality = "高品质";
}
virtual void sale()
{
cout << "楼盘A" << m_Quality << "被售卖！" << endl;
}
virtual string getQuality()
{
return m_Quality;
}
public:
string m_Quality;
};
//楼盘B
class BuildingB : public AbstractBuilding
{
public:
BuildingB()
{
m_Quality = "低品质";
}
virtual void sale()
{
cout << "楼盘B" << m_Quality << "被售卖！" << endl;
}
virtual string getQuality()
{
return m_Quality;
}
public:
string m_Quality;
};
//客户端
void test02()
{
BuildingA* ba = new BuildingA;
if (ba->m_Quality == "高品质")
{
ba->sale();
}
BuildingB* bb = new BuildingB;
if (bb->m_Quality == "低品质")
{
bb->sale();
}
}
//中介类
class Mediator
{
public:
Mediator()
{
AbstractBuilding* building = new BuildingA;
vBuilding.push_back(building);
building = new BuildingB;
vBuilding.push_back(building);
}
//对外提供接口
AbstractBuilding* findMyBuilding(string quality)
{
for (vector<AbstractBuilding*>::iterator it = vBuilding.begin(); it != vBuilding.end(); it++)
if ((*it)->getQuality() == quality)
{
return *it;
}
return NULL;
}
~Mediator()
{
for (vector<AbstractBuilding *>::iterator it = vBuilding.begin();it != vBuilding.end();it++)
if (*it != NULL)
{
delete* it;
}
}
public:
vector<AbstractBuilding *> vBuilding;
};
void test02_1()
{
Mediator* meidator = new Mediator;
AbstractBuilding* building = meidator->findMyBuilding("高品质");
if (building != NULL)
{
building->sale();
}
else
{
cout << "没有符合条件的楼盘！" << endl;
}
}
int main()
{
test02();
test02_1();
return 0;
}7. 合成复用原则
如果使用继承，会导致父类的任何变换都可能影响到子类的行为。
如果使用对象组合，就降低了这种依赖关系。
对于继承和组合，优先使用组合。
#include<iostream>
using namespace std;
//抽象车
class AbstructCar
{
public:
virtual void run() = 0;
};
//大众车
class Dazhong :public AbstructCar
{
public:
virtual void run()
{
cout << "大众车启动" << endl;
}
};
//拖拉机
class Tuolaji :public AbstructCar
{
public:
virtual void run()
{
cout << "拖拉机启动" << endl;
}
};
//针对具体类，不适用继承
#if 0
class Person :public Tuolaji
{
public:
void Douofeng()
{
run();
}
};
class PersonB :public Dazhong
{
public:
void Douofeng()
{
run();
}
};
#endif
//可以使用组合
class Person
{
public:
void setCar(AbstructCar *car)
{
this->car = car;
}
void Doufeng()
{
this->car->run();
if (this->car != NULL)
{
delete this->car;
this->car = NULL;
}
}
public:
AbstructCar* car;
};
void test03()
{
Person* p = new Person;
p->setCar(new Dazhong);
p->Doufeng();
p->setCar(new Tuolaji);
p->Doufeng();
delete p;
}
//继承和组合 优先使用组合
int main()
{
test03();
return 0;
}
