设计模式——7.抽象工厂-CSDN博客

抽象工厂（Abstract Factory）

Abstract Factory模式简介：

提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。

Abstract Factory模式结构：

C++代码

AbstractProductA抽象类以及1系列和2系列的具体实现类：


    //file: AbstractProductA.h
    #pragma once
    class AbstractProductA
    {
    public:
        AbstractProductA();
        virtual ~AbstractProductA();
        
        virtual void stepA() = 0;
    };
    
    class ProductA1 : public AbstractProductA
    {
    public:
        ProductA1();
        virtual ~ProductA1();
    
        void stepA();
    };
    
    class ProductA2 : public AbstractProductA
    {
    public:
        ProductA2();
        virtual ~ProductA2();
    
        void stepA();
    };


    //file: AbstractProductA.cpp
    #include "pch.h"
    #include "AbstractProductA.h"
    #include <iostream>
    using namespace std;
    
    //AbstractProductA
    AbstractProductA::AbstractProductA() {}
    
    AbstractProductA::~AbstractProductA() {}
    
    
    //ProductA1
    ProductA1::ProductA1() {}
    
    ProductA1::~ProductA1() {}
    
    void ProductA1::stepA()
    {
        cout << "Product A1's step !" << endl;
    }
    
    //ProductA2
    ProductA2::ProductA2() {}
    
    ProductA2::~ProductA2() {}
    
    void ProductA2::stepA()
    {
        cout << "Product A2's step !" << endl;
    }

AbstractProductB抽象类以及1系列和2系列的具体实现类：


    //file: AbstractProductB.h
    #pragma once
    class AbstractProductB
    {
    public:
        AbstractProductB();
        virtual ~AbstractProductB();
    
        virtual void stepB() = 0;
    };
    
    class ProductB1 : public AbstractProductB
    {
    public:
        ProductB1();
        virtual ~ProductB1();
    
        void stepB();
    };
    
    class ProductB2 : public AbstractProductB
    {
    public:
        ProductB2();
        virtual ~ProductB2();
    
        void stepB();
    };


    //file: AbstractProductB.cpp
    #include "pch.h"
    #include "AbstractProductB.h"
    #include <iostream>
    using namespace std;
    
    //AbstractProductB
    AbstractProductB::AbstractProductB() {}
    
    AbstractProductB::~AbstractProductB() {}
    
    //ProductB1
    ProductB1::ProductB1() {}
    
    ProductB1::~ProductB1() {}
    
    void ProductB1::stepB()
    {
        cout << "Product B1's step ! " << endl;
    }
    
    //ProductB2
    ProductB2::ProductB2() {}
    
    ProductB2::~ProductB2() {}
    
    void ProductB2::stepB()
    {
        cout << "Product B2's step ! " << endl;
    }

AbstractFractory以及1系列和2系列的ConcreteFractory：


    //file: AbstractFactory.h
    #pragma once
    #include "AbstractProductA.h"
    #include "AbstractProductB.h"
    
    class AbstractFactory
    {
    public:
        AbstractFactory();
        virtual ~AbstractFactory();
    
        virtual AbstractProductA* createProductA() = 0;
        virtual AbstractProductB* createProductB() = 0;
    };
    
    class ConcreteFactory1 : public AbstractFactory
    {
    public:
        ConcreteFactory1();
        virtual ~ConcreteFactory1();
    
        virtual AbstractProductA* createProductA();
        virtual AbstractProductB* createProductB();
    };
    
    class ConcreteFactory2 : public AbstractFactory
    {
    public:
        ConcreteFactory2();
        virtual ~ConcreteFactory2();
    
        virtual AbstractProductA* createProductA();
        virtual AbstractProductB* createProductB();
    };


    //file: AbstractFractory.cpp
    #include "pch.h"
    #include "AbstractFactory.h"
    
    //AbstractFactory
    AbstractFactory::AbstractFactory() {}
    
    AbstractFactory::~AbstractFactory() {}
    
    //ConcreteFactory1
    ConcreteFactory1::ConcreteFactory1() {}
    
    ConcreteFactory1::~ConcreteFactory1() {}
    
    AbstractProductA* ConcreteFactory1::createProductA()
    {
        return new ProductA1();
    }
    
    AbstractProductB* ConcreteFactory1::createProductB()
    {
        return new ProductB1();
    }
    
    //ConcreteFactory2
    ConcreteFactory2::ConcreteFactory2() {}
    
    ConcreteFactory2::~ConcreteFactory2() {}
    
    AbstractProductA* ConcreteFactory2::createProductA()
    {
        return new ProductA2();
    }

客户端调用代码：


    // AbstractFactoryPattern.cpp : This file contains the 'main' function. Program execution begins and ends there.
    #include "pch.h"
    #include "AbstractFactory.h"
    #include <iostream>
    using namespace std;
    
    int main()
    {
        AbstractFactory* frac = new ConcreteFactory1();
        //AbstractFactory* frac = new ConcreteFactory2();
        AbstractProductA* pa = frac->createProductA();
        AbstractProductB* pb = frac->createProductB();
    
        pa->stepA();
        pb->stepB();
    
        delete frac;
        delete pa;
        delete pb;
        
        char c;
        cin >> c;
        return 0;
    }

C#代码

AbstractProductA抽象类以及1系列和2系列的具体实现类：


    public abstract class AbstractProductA
    {
        public abstract void StepA();
    }

    public class ProductA1 : AbstractProductA
    {
        public override void StepA()
        {
            Console.WriteLine("Product A1's Step !");
        }
    }

    public class ProductA2 : AbstractProductA
    {
        public override void StepA()
        {
            Console.WriteLine("Product A2's Step !");
        }
    }

AbstractProductB抽象类以及1系列和2系列的具体实现类：


    public abstract class AbstractProductB
    {
        public abstract void StepB();
    }

    public class ProductB1 : AbstractProductB
    {
        public override void StepB()
        {
            Console.WriteLine("Product B1's Step ！");
        }
    }

    public class ProductB2 : AbstractProductB
    {
        public override void StepB()
        {
            Console.WriteLine("Product B2's Step !");
        }
    }

AbstractFractory以及1系列和2系列的ConcreteFractory：


    public abstract class AbstractFactory
    {
        public abstract AbstractProductA CreatProductA();
        public abstract AbstractProductB CreatProductB();
    }

    public class ConcreteFactory1 : AbstractFactory
    {
        public override AbstractProductA CreatProductA()
        {
            return new ProductA1();
        }

        public override AbstractProductB CreatProductB()
        {
            return new ProductB1();
        }
    }

    public class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreatProductA()
        {
            return new ProductA2();
        }

        public override AbstractProductB CreatProductB()
        {
            return new ProductB2();
        }
    }

客户端代码：：


    AbstractFactory frac = new ConcreteFactory1();
    //AbstractFactory frac = new ConcreteFactory2();

    AbstractProductA pa = frac.CreatProductA();
    AbstractProductB pb = frac.CreatProductB();
    pa.StepA();
    pb.StepB();