设计模式-工厂模式

为了提高内聚和降低耦合,我们经常会定义一些抽象基类或接口,然后声明一个基类指针指向实际子类,来达到多态的目的。外部使用时,需要知道子类的具体名称才能创建相应的对象。

但这样的话,当子类的种类变多时,就会变得凌乱,于是就需要一个工厂类来进行管理,使用枚举等方式来选择要创建的子类。

说明

工厂模式包含:简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂:定义对象创建接口,将其封到工厂类中,外部不需要知道具体的子类对象。

image-20220609103204358

工厂方法:简单工厂升级,抽象工厂类的创建对象接口,让工厂子类决定如何创建对象。

image-20220609103334048

抽象工厂: 工厂方法升级,工厂类中定义多个创建不同对象的接口,减少工厂类。

image-20220609103348748

实现

定义抽象基类Protocol,延伸子类TcpProtocolUdpProtocol:

1
2
3
4
5
6
7
8
9
10
11
12
class Protocol 
{
virtual string name() = 0;
}
class TcpProtocol : public Protocol
{
string name() {return "Tcp"};
}
class UdpProtocol : public Protocol
{
string name() {return "Udp"};
}

简单工厂

唯一工厂类,一个产品抽象类,工厂类的创建方法依据入参判断并创建具体产品对象。

1
2
3
4
5
6
7
8
9
10
class Factory 
{
Protocol* createProtocol(ProtocolType type)
{
if (type == ProtocolType::Tcp)
return new TcpProtocol();
else if (type == ProtocolType::Udp)
return new UdpProtocol();
}
}

工厂方法

多个工厂类,一个产品抽象类,利用多态创建不同的产品对象,避免了大量的if-else判断。

1
2
3
4
5
6
7
8
9
10
11
12
class Factory 
{
virtual Protocol* createProtocol() = 0;
}

class TcpFactory : public Factory
{
Protocol* createProtocol(ProtocolType type)
{
return new TcpProtocol();
}
}

抽象工厂

多个工厂类,多个产品抽象类,产品子类分组,同一个工厂实现类创建同组中的不同产品,减少了工厂子类的数量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Modbus 
{
virtual string device() = 0;
}
class NetModbus : public Modbus
{
string device() {return "net"};
}
class SerialModbus : public Modbus
{
string device() {return "serial"};
}

class Factory
{
virtual Protocol* createProtocol() = 0;
virtual Modbus* createModbus() = 0;
}

class TcpFactory : public Factory
{
Protocol* createProtocol()
{
return new TcpProtocol();
}
Modbus* createModbus()
{
return new NetProtocol();
}
}

参考: