设计模式笔记
设计模式
单例设计模式
什么是单例模式
单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。
为什么使用单例模式
在应用系统开发中，我们常常有以下需求：
1.需要生成唯一序列的环境
2.需要频繁实例化然后销毁的对象。
3.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
4.方便资源相互通信的环境
实际案例:
- 多线程中网络资源初始化
- 回收站机制
- 任务管理器
- 应用程序日志管理
- …
单例模式实现步骤
- 构造函数私有化
- 提供一个全局的静态方法，访问唯一对象
- 类中定义一个静态指针，指向唯一对象
单例模式实现代码
懒汉式
#include
using namespace std;
//懒汉式
class SingleTon
{
private:
SingleTon();
public:
static SingleTon* m_singleTon;
static SingleTon* GetInstance();
void TestPrint();
};
//懒汉式并没有创建单例对象
SingleTon* SingleTon::m_singleTon = NULL;
int main()
{
SingleTon* p1 = SingleTon::GetInstance();
SingleTon* p2 = SingleTon::GetInstance();
cout << "p1:"<< hex << p1 << endl;
cout << "p2:" << hex << p2 << endl;
p1->TestPrint();
p2->TestPrint();
return 0;
}
SingleTon::SingleTon()
{
m_singleTon = NULL;
cout << "构造了对象....." << endl;
}
SingleTon* SingleTon::GetInstance()
{
if (m_singleTon == NULL)
{
m_singleTon = new SingleTon;
}
return m_singleTon;
}
void SingleTon::TestPrint()
{
cout << "测试调用....." << endl;
}
简单工厂模式
什么是简单工厂
简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式。
通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
为什么使用简单工厂
减少客户程序对类创建过程的依赖
简单工厂实现步骤
1.提供一个工厂类
简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
2.提供一个抽象产品类
简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
3.提供一个具体产品类
简单工厂模式所创建的具体实例对象
#include
#include
using namespace std;
//产品抽象父类
class Operation
{
public:
double m_leftVlaue;
double m_rightValue;
virtual double GetResult() = 0;
};
//具体产品实现类
class AddOperation:public Operation
{
double GetResult()
{
return m_leftVlaue + m_rightValue;
}
};
class SubOperation :public Operation
{
double GetResult()
{
return m_leftVlaue - m_rightValue;
}
};
class MulOperation :public Operation
{
double GetResult()
{
return m_leftVlaue * m_rightValue;
}
};
class DivOperation :public Operation
{
double GetResult()
{
return m_leftVlaue / m_rightValue;
}
};
//工厂类
class OperatorFactory
{
public:
static Operation* createOperation(char c)
{
switch (c)
{
case '+':
return new AddOperation;
break;
case '-':
return new SubOperation;
break;
case '*':
return new MulOperation;
break;
case '/':
return new DivOperation;
break;
}
}
};
int main()
{
Operation* operation = OperatorFactory::createOperation('+');
operation->m_leftVlaue = 1;
operation->m_rightValue = 2;
cout << operation->GetResult() << endl;
return 0;
}
工厂模式
什么是简单工厂模式
工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是 定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。 核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类 必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工 厂角色的情况下引进新的产品
为什么使用工厂模式
工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽 象工厂类，而简单工厂模式把核心放在一个具体类上。 工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口， 或者有共同的抽象父类。 当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对 象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭” 原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。
工厂模式实现步骤
1.提供一个抽象工厂类 :所有具体工厂类的父类
2.提供与产品对应的工厂类:负责实例化产品对象
3.提供一个抽象产品类： 所有产品的父类
4.提供一个或多个产品类:工厂方法模式所创建的具体实例对象
#include
using namespace std;
class AbstractProduct
{
public:
virtual void makeProduct() = 0;
};
class AbstractFactory
{
public:
virtual AbstractProduct* createProduct() = 0;
};
class PlaneProduct :public AbstractProduct
{
public:
void makeProduct()
{
cout << "造飞机....." << endl;
}
};
class PlaneFactory :public AbstractFactory
{
public:
AbstractProduct* createProduct()
{
AbstractProduct* product = new PlaneProduct;
return product;
}
};
class RocketProduct :public AbstractProduct
{
public:
void makeProduct()
{
cout << "造火箭...." << endl;
}
};
class RocketFactory :public AbstractFactory
{
public :
AbstractProduct* createProduct()
{
AbstractProduct* product = new RocketProduct;
return product;
}
};
int main()
{
//造飞机
AbstractFactory* factory = new PlaneFactory;
AbstractProduct* product = factory->createProduct();
product->makeProduct();
//造火箭
factory = new RocketFactory;
product = factory->createProduct();
product->makeProduct();
return 0;
}
抽象工厂模式
什么是抽象工厂模式
抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向 客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。
为什么使用抽象工厂模式
抽象工厂方法是针对与一个产品族，使得易于交换产品系列，只需改变具体的工厂就可以使用不同的产品配置。当一个族中的产品对象被设计成一起工作且一个应用只是用同一族的对象，例如设计系统生成不同风格的UI界面，按钮，边框等UI元素在一起使用，并且只能同属于一种风格，这很容易使用抽象工厂实现。
抽象工厂模式实现步骤
**1.提供一个抽象工厂类：**声明一组创建一族产品的工厂方法
**2.提供一个具体工厂类：**实现了在抽象工厂创建产品的工厂方法
**3.提供一个抽象产品类：**抽象产品中声明了产品具有的业务方法
**4.提供一个具体产品类：**实现抽象产品接口中声明的业务方法
#include
using namespace std;
//抽象产品
class Product
{
public:
virtual void show() = 0;
};
//抽象产品族1
class KeyBoard :public Product{};
//罗技键盘
class LogiKeyBoard :public KeyBoard
{
void show()
{
cout << "罗技键盘......" << endl;
}
};
//雷蛇键盘
class RazerKeyBoard :public KeyBoard
{
void show()
{
cout << "雷蛇键盘......" << endl;
}
};
//抽象产品族2
class Mouse :public Product {};
//罗技鼠标
class LogiMouse :public Mouse
{
void show()
{
cout << "罗技鼠标......" << endl;
}
};
class RazerMouse :public Mouse
{
void show()
{
cout << "雷蛇鼠标......" << endl;
}
};
//抽象工厂
class Factory
{
public:
virtual KeyBoard* createKeyBoard() = 0;
virtual Mouse* createMouse() = 0;
};
class LogiFactory :public Factory
{
KeyBoard* createKeyBoard()
{
return new LogiKeyBoard;
}
Mouse* createMouse()
{
return new LogiMouse;
}
};
class RazerFactory :public Factory
{
KeyBoard* createKeyBoard()
{
return new RazerKeyBoard;
}
Mouse* createMouse()
{
return new RazerMouse;
}
};
int main()
{
Factory* factory = new LogiFactory;
KeyBoard* keyBoard = factory->createKeyBoard();
Mouse* mouse = factory->createMouse();
keyBoard->show();
mouse->show();
delete factory;
delete keyBoard;
delete mouse;
factory = new RazerFactory;
keyBoard = factory->createKeyBoard();
mouse = factory->createMouse();
keyBoard->show();
mouse->show();
delete factory;
delete keyBoard;
delete mouse;
factory = NULL;
keyBoard = NULL;
mouse = NULL;
return 0;
}
适配器模式
什么是适配器模式
适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。好比日本现在就只提供110V的电压，而我的电脑就需要220V的电压，那怎么办啦?适配器就是干这活的，在不兼容的东西之间搭建一座桥梁，让二者能很好的兼容在一起工作。
为什么使用适配器模式
在软件开发中，有的时候系统的数据和行为都正确，但接口不符合，我们应该考虑使用适配器模式，目的是使控制范围之外的一个原有对象与某个接口匹配。举个例子:在开发一个模块的时候，有一个功能点实现起来比较费劲，但是，之前有一个项目的模块实现了一样的功能点;但是现在这个模块的接口和之前的那个模块的接口是不一致的。此时，作为项目经理的你，该怎么办啦?使用适配器模式，将之前实现的功能点适配进新的项目了。
适配器模式实现步骤
- 适配器实现与其中一个现有对象兼容的接口
- 现有对象可以使用该接口安全地调用适配器方法
- 适配器方法被调用后将以另一个对象兼容的格式和顺序将请求传递给该对象
一般适配器模式分为以下两类:
适配器模式实现代码
对象适配器实现代码
//电源插座 三插头到两插头转换
#include
using namespace std;
class ThreeOutlet
{
public:
void ThreeOutletCharge()
{
cout << "开始三插座充电......" << endl;
}
};
class AbstractTwoOutlet
{
public:
virtual void TwoOutletCharge() = 0;
};
class TwoOutlet:public AbstractTwoOutlet
{
public:
void TwoOutletCharge()
{
cout << "开始二插座充电......" << endl;
}
};
//对象适配器
class OutletAdapterObject :public AbstractTwoOutlet
{
public:
OutletAdapterObject(ThreeOutlet* out)
{
pOut = out;
}
void TwoOutletCharge()
{
Convertor();
pOut->ThreeOutletCharge();
}
void Convertor()
{
cout << "三插头转换为两插头后:";
}
ThreeOutlet* pOut;
};
int main()
{
ThreeOutlet* pThree = new ThreeOutlet;
AbstractTwoOutlet* pTwo = new OutletAdapterObject(pThree);
pTwo->TwoOutletCharge();
return 0;
}