最常用的设计模式----工厂模式家族（简单工厂模式，工厂方法模式，抽象工厂模式）_实现一个能够生产不同类型手机(android、iphone)的工厂,考虑未来可能的扩展-优快云博客

本文链接：https://blog.youkuaiyun.com/sunxiaopengsun/article/details/80391250

工厂模式是个系列，分为简单工厂模式，工厂方法模式，抽象工厂模式，这三种模式也非常常用。这些模式最最经典的就例子就是设计计算器。

简单工厂模式

严格的说，简单工厂模式并不是23种常用的设计模式之一，它只算工厂模式的一个特殊实现。简单工厂模式在实际中的应用相对于其他2个工厂模式用的还是相对少得多，因为它只适应很多简单的情况，最最重要的是它违背了我们在概述中说的开放-封闭原则。因为每次你要新添加一个功能，都需要在生switch-case 语句（或者if-else 语句）中去修改代码，添加分支条件。

简单工厂模式角色分配：

Creator（产品创建者）
简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
Product （产品抽象类）
简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
Concrete Product （具体产品）
是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

简单工厂模式uml图：

考虑下面一个事例：加入你是一个商人，你做的的是手机生意。现在你生产android 手机和iphone等，考虑到以后你可能还会生产其他手机例如ubuntu手机。假定你选择了简单工厂模式来实现。那么显然，我们需要所有产品的抽象基类（Product）即是Phone类：

[cpp] view plain copy

class Phone
{
public:
virtual ~Phone(){};//在删除的时候防止内存泄露
virtual void call(string number) = 0;
};

然后我们需要具体的产品类 Concrete Product： AndroidPhone 和 IosPhone

[cpp] view plain copy

class AndroidPhone : public Phone
{
public:
void call(string number){ cout<<"AndroidPhone is calling..."<<endl;}
};
class IosPhone : public Phone
{
public:
void call(string number) { cout<<"IosPhone is calling..."<<endl;}
};

最后我们需要Creator

[cpp] view plain copy

class PhoneFactory
{
public:
Phone* createPhone(string phoneName)
{
if(phoneName == "AndroidPhone")
{
return new AndroidPhone();
}else if(phoneName == "IosPhone")
{
return new IosPhone();
}
return NULL;
}
};

客户端这样实现：

[cpp] view plain copy

void main()
{
PhoneFactor factory;
Phone* myAndroid = factory.createPhone("AndroidPhone");
Phone* myIPhone = factory.createPhone("IosPhone");
if(myAndroid)
{
myAndroid->call("123");
delete myAndroid;
myAndroid = NULL;
}
if(myIPhone)
{
myIPhone->call("123");
delete myIPhone;
myIPhone = NULL;
}
}

这就是简单工厂方法，把所有的创建交给creator,creator 通过switch-case(或者if-else)语句来选择具体创建的对象。简单明了。但是就如上面所说，它最致命的问题的违背了开放-封闭原则。每次你要新添加一个功能，都要修改factor里面的createPhone代码。但是工厂方法模式可以解决这个问题。

工厂方法模式

为了让一个类中只依赖接口，不依赖具体类，需要将BinarySpliter类从调用类中分离出来，因此需要格式工厂

个人觉得工厂方法模式在工厂模式家族中是用的最多模式。上面说过了，如果简单工厂模式，要添加一个新功能，比如我现在要增加WinPhone 的生产，那么我要修改PhoneFactory中的createPhone 中的分支判断条件。这违背了开放-封闭原则，那为什么不能将创建方法放到子类中呢？

工厂方法的定义就是：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

工厂方法模式角色：

抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

工厂方法模式uml图：

看定义看的晕乎乎的？那么我们来看代码：

产品接口，以及其相应的子类。

[cpp] view plain copy

class Phone
{
public:
virtual ~Phone(){};//在删除的时候防止内存泄露
virtual void call(string number) = 0;
};
class AndroidPhone : public Phone
{
public:
void call(string number){ cout<<"AndroidPhone is calling..."<<endl;}
};
class IosPhone : public Phone
{
public:
void call(string number) { cout<<"IosPhone is calling..."<<endl;}
};

上面这个和简单工厂方法还是一样的。接下来不一样的来了...

[cpp] view plain copy

class PhoneFactory
{
public:
virtual ~PhoneFactory(){};
virtual Phone* createPhone() = 0;
};
class AndroidPhoneFactory : public PhoneFactory
{
public:
virtual Phone* createPhone()
{
return new AndroidPhone();
}
};
class IosPhoneFactory : public PhoneFactory
{
public:
virtual Phone* createPhone()
{
return new IosPhone();
}
};

工厂方法将PhoneFactory抽象成了基类，PhoneFactory的createPhone不在像以前那样将所有的判断塞到里面。而是改由其子类来实现创建功能，这感觉就是权力下放。

客户端：

class A
{
    public:
        void  Init(PhoneFactory* pfac);
}


void  Init(PhoneFactory* pfac)
{
    Phone*pPhone = pfac->createPhone();
    pPhone->Call()
}

[cpp] view plain copy

void main()
{
PhoneFactory* androidCreator = new AndroidPhoneFactory();
PhoneFactory* iosCreator = new IosPhoneFactory();
Phone* myAndroid = androidCreator->createPhone();
Phone* myIPhone = iosCreator->createPhone();
if(myAndroid)
{
myAndroid->call("123");
delete myAndroid;
myAndroid = NULL;
}
if(myIPhone)
{
myIPhone->call("123");
delete myIPhone;
myIPhone = NULL;
}
delete androidCreator;
delete iosCreator;
}

在工厂方法模式中，核心工厂类不在负责产品的创建，而是将具体的创建工作交给子类去完成。也就是后所这个核心工厂仅仅只是提供创建的接口，具体实现方法交给继承它的子类去完成。当我们的系统需要增加其他新功能时，只需要继承PhoneFactory这个类，并且实现createPhone接口。不需要对原工厂PhoneFactory进行任何修改，这样很好地符合了“开放-封闭“原则。

虽然工厂方法模式满足了"开放-封闭”原则，但是这个模式也仍然有缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，是的系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

抽象工厂模式

在工厂方法模式中，其实我们有一个潜在意识的意识。那就是我们生产的都是同一类产品，例如我们生产的都是手机！那么现在假如现在我们又要生产平板了了呢？那么就要用到抽象工厂模式。我抽象工厂模式也用的比较多在工厂模式家族中，仅次于工厂方法模式。在了解抽象工厂模式之前，还是老生常谈的理清下产品等级结构和产品簇的概念。下面的图还是老图。但是我讲讲我的理解：

产品等级结构：产品的等级结构也就是产品的继承结构。我理解就是同一类产品，比如手机是一个系列，有android手机，ios手机，win手机，那么这个抽象类手机和他的子类就构成了一个产品等级结构。那其他的平板显然不是和手机一个系列的，一个平板，一个是手机，所以他们是不同的产品等级结构。
产品族: 在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如分为android产品，和ios产品。其中一个ios产品包含ios手机和ios平板。显然ios手机和ios平板不是同一个产品等级结构的，因为一个是手机，一个是平板。但他们是同一个产品簇---都是ios产品。

希望大家通过上面的例子大家明白了这两个概念。
抽象工厂模式的Uml 图：

接着上面的话题，现在假如我要增加对平板的支持，那么我们肯定先添加两个产品等级结构，一个是手机，一个是平板：

[cpp] view plain copy

//产品等级结构--手机
class Phone
{
public:
virtual ~Phone(){};//在删除的时候防止内存泄露
virtual void call(string number) = 0;
};
class AndroidPhone : public Phone
{
public:
void call(string number){ cout<<"AndroidPhone is calling..."<<endl; }
};
class IosPhone : public Phone
{
public:
void call(string number) { cout<<"IosPhone is calling..."<<endl; }
};
//产品等级结构--平板
class Pad
{
public:
virtual ~Pad(){};
virtual void playMovie() = 0;
};
class AndroidPad : public Pad
{
public:
virtual void playMovie(){ cout<<"AndriodPad is playing movie..."<<endl; }
};
class IosPad : public Pad
{
public:
virtual void playMovie(){ cout<<"IosPad is playing movie..."<<endl; }
};