设计模式——8.工厂方法

工厂方法（Factory Method）

Factory Method模式简介：

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

Factory Method模式结构：

C++代码

Product抽象类：

    //file: Product.h
    #pragma once
    class Product
    {
    public:
        Product();
        virtual ~Product();
    
        virtual void func();
    };

    //file: product.cpp
    #include "pch.h"
    #include "Product.h"
    
    Product::Product() {}
    
    Product::~Product() {}
    
    void Product::func() {}

Factory抽象类：

    //file: Factory.h
    #pragma once
    #include "Product.h"
    
    class Factory
    {
    public:
        Factory();
        virtual ~Factory();
        
        virtual Product* factoryMethod();
    };

    //file: Factory.cpp
    #include "pch.h"
    #include "Factory.h"
    
    Factory::Factory() {}
    
    Factory::~Factory() {}
    
    Product* Factory::factoryMethod() 
    {
        return nullptr;
    }

ConcreteProduct具体实现类：

    //file: ConcreteProduct.h
    #pragma once
    #include "Product.h"
    
    class ConcreteProduct : public Product
    {
    public:
        ConcreteProduct();
        virtual ~ConcreteProduct();
        
        virtual void func();
    };

    //file: ConcreteProduct.cpp
    #include "pch.h"
    #include "ConcreteProduct.h"
    #include <iostream>
    
    ConcreteProduct::ConcreteProduct() {}
    
    ConcreteProduct::~ConcreteProduct() {}
    
    void ConcreteProduct::func()
    {
        std::cout << "Concrete Product's Func ." << std::endl;
    }

ConcreteFactory具体实现类：

    //file: ConcreteFactory.h
    #pragma once
    #include "Factory.h"
    
    class ConcreteFactory : public Factory
    {
    public:
        ConcreteFactory();
        virtual ~ConcreteFactory();
    
        virtual Product* factoryMethod();
    };

    //file: ConcreteFactory.cpp
    #include "pch.h"
    #include "ConcreteFactory.h"
    #include "ConcreteProduct.h"
    
    ConcreteFactory::ConcreteFactory() {}
    
    ConcreteFactory::~ConcreteFactory() {}
    
    Product* ConcreteFactory::factoryMethod()
    {
        return new ConcreteProduct;
    }

客户端代码：

    //file: FactoryMethodPattern.cpp : This file contains the 'main' function. Program execution begins and ends there.
    
    #include "pch.h"
    #include <iostream>
    #include "ConcreteProduct.h"
    #include "ConcreteFactory.h"
    using namespace std;
    
    int main()
    {
        Factory* fc = new ConcreteFactory();
        Product* prod = fc->factoryMethod();
        prod->func();
    
        delete fc;
        delete prod;
    
        char c;
        cin >> c;
        return 0;
    }

C#代码

Product抽象类以及ConcreteProduct具体实现类：

    public abstract class Product
    {
        public virtual void Func()
        {
            Console.WriteLine("Basic Func Of The Product .");
        }
    }

    public class ConcreteProduct : Product
    {
        public override void Func()
        {
            base.Func();
            Console.WriteLine("The Concrete Product's External Func .");
        }
    }

Factory抽象类以及ConcreteFactory具体实现类：

    public abstract class Factory
    {
        public abstract Product FactoryMethod();
    }

    public class ConcreteFactory : Factory
    {
        public override Product FactoryMethod()
        {
            return new ConcreteProduct();
        }
    }

客户端代码：

    using System;
    
    namespace FactoryMethodPattern
    {
        class Program
        {
            static void Main(string[] args)
            {
                Factory fc = new ConcreteFactory();
                Product prod = fc.FactoryMethod();
                prod.Func();
                Console.ReadKey(false);
            }
        }
    }

REF

书籍：

设计模式与游戏开发、大话设计模式

GitHub：

https://github.com/me115/design_patterns