01.工厂模式

1.1概念

• 工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。
• 核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

1.2类图角色和职责

• 抽象工厂（Creator）角色
• • 工厂方法模式的核心，任何工厂类都必须实现这个接口。
• 具体工厂（ Concrete Creator）角色
• • 具体工厂类是抽象工厂的一个实现，负责实例化产品对象。
• 抽象（Product）角色
• • 工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
• 具体产品（Concrete Product）角色
• 工厂方法模式所创建的具体实例对象

1.3工厂方法模式和简单工厂模式比较

• 工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
• • 工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。
• 当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

1.4简单工厂案例代码

#include <iostream>     
 
using namespace std;

//抽象水果类：Fruit
//抽象工厂类：FruitFactory

//具体的工厂： BananaFactory PearFactory
//具体的水果：Banana Pear

class Fruit
{
public:
        virtual void sayName()
        {
                cout << "Fruit" << endl;
        }
private:
};

//抽象工厂 和 一本的工厂模式 相比较的话 产品细化
class FruitFactory
{
public:
        virtual Fruit* getFruit()//依赖关系
        {
                return NULL;
        }
private:
};

class Banana : public Fruit
{
public:
        virtual void sayName()
        {
                cout << "Banana" << endl;
        }
private:
};

class Pear : public Fruit
{
public:
        virtual void sayName()
        {
                cout << "Pear" << endl;
        }
private:
};

class BananaFactory : public FruitFactory
{
public:
        virtual Fruit* getFruit()//依赖关系
        {
                return new Banana;
        }
private:
};

class PearFactory : public FruitFactory
{
public:
        virtual Fruit* getFruit()//依赖关系
        {
                return new Pear;
        }
private:
};

void main()
{
        FruitFactory* ff = NULL;
        Fruit* fruit = NULL;

        //香蕉
        ff = new BananaFactory;
        fruit =  ff->getFruit();
        fruit->sayName();
        delete fruit;
        delete ff;

        //梨
        ff = new PearFactory;
        fruit = ff->getFruit();
        fruit->sayName();
        delete fruit;
        delete ff;
}

• 输出

Banana
Pear

02.抽象工厂

2.1概念

• 抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

2.2产品族和产品等级结构

备注1：工厂模式：要么生产香蕉、要么生产苹果、要么生产西红柿；但是不能同时生产一个产品组。抽象工厂：能同时生产一个产品族。===》抽象工厂存在原因

解释:具体工厂在开闭原则下, 能生产香蕉/苹果/梨子; (产品等级结构)

抽象工厂:在开闭原则下, 能生产：南方香蕉/苹果/梨子 (产品族)

北方香蕉/苹果/梨子

重要区别：

• 工厂模式只能生产一个产品。（要么香蕉、要么苹果）
• 抽象工厂可以一下生产一个产品族（里面有很多产品组成）

2.3模式中包含的角色及其职责

• 抽象工厂（Creator）角色
• • 抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。
• 具体工厂（ Concrete Creator）角色
• • 具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。
• 抽象（Product）角色
• • 抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
• 具体产品（Concrete Product）角色
• • 抽象模式所创建的具体实例对象

2.4简单工厂案例代码

#include <iostream>

using namespace std;

class Fruit
{
public:
        virtual void sayname()
        {
                cout << "fruit\n";
        }
};

class FruitFactory
{
public:
        virtual Fruit* getApple()
        {
                return new Fruit();
        }
        virtual Fruit* getBanana()
        {
                return new Fruit();
        }
};

//南方香蕉
class SouthBanana : public Fruit
{
public:
        virtual void sayname()
        {
                cout << "South Banana \n" << endl;
        }
};

//南方苹果
class SouthApple : public Fruit
{
public:
        virtual void sayname()
        {
                cout << "South Apple \n" << endl;
        }
};

//北方香蕉
class NorthBanana : public Fruit
{
public:
        virtual void sayname()
        {
                cout << "North Banana \n" << endl;
        }
};

//北方苹果
class NorthApple : public Fruit
{
public:
        virtual void sayname()
        {
                cout << "North Apple \n" << endl;
        }
};

class SourthFruitFactory : public FruitFactory
{
public:
        virtual Fruit* getApple()
        {
                return new SouthApple();
        }
        virtual Fruit* getBanana()
        {
                return new SouthBanana();
        }
};

class NorthFruitFactory : public FruitFactory
{
public:
        virtual Fruit* getApple()
        {
                return new NorthApple();
        }
        virtual Fruit* getBanana()
        {
                return new NorthBanana();
        }
};

void main()
{
        FruitFactory* ff = NULL;
        Fruit* fruit = NULL;

        ff = new SourthFruitFactory();
        fruit = ff->getApple();
        fruit->sayname();
        fruit = ff->getBanana();
        fruit->sayname();

        delete fruit;
        delete ff;

        ff = new NorthFruitFactory();
        fruit = ff->getApple();
        fruit->sayname();
        fruit = ff->getBanana();
        fruit->sayname();

        delete fruit;
        delete ff;
}

• 输出

South Apple

South Banana

North Apple

North Banana

点个赞吧