抽象工厂

接上一篇的工厂方法继续工厂模式的练习。

先看一下抽象工厂的结构图

抽象工厂

产品族:

在上面的产品列表中呢,有两个产品族,一个是“具体产品A--1”和”具体产品B--1“组成的一个族,

还有一个是“具体产品A--2”和“具体产品B--2”组成的一个族。

产品族就是在不同产品等级结构中,功能相关联的产品组成的家族。

抽象工厂的定义:

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

这副类图中可以看出,每一个具体的工厂,它都只负责创建一个产品族中的产品的实例,

从抽象工厂中派生出的具体工厂,这些具体工厂产生相同的产品(这些产品都继承自同一父类),

比如,ConcreteFactory1 和 ConcreteFactory2 中的 CreateProductA 这个方法都是产生 AbstractProductA 这种类型的产品,

但是产品的实现却是不同的,比如 ConcreteFactory1 中的 CreateProductA 实现的是产生一个 ConcreteProductA—1 产品,

而 ConcreteFactory2 中的 CreateProductA 实现的是产生一个 ConcreteProductA—2 产品,

总的来说就是不同的具体工厂产生不同的产品族,

而抽象工厂则是定义一个负责创建一组产品(也就是一个产品族)的接口,

比如上面的类图中只存在两个产品族,所以在抽象工厂中便只需要定义两个接口就可以了。

实现思路:

这里我们以支付宝和微信举例:

支付宝和微信属于两个产品,这两个产品有两个共有的功能是:聊天和支付。

但两个产品的这两个功能实现机制不同,所以这里用抽象工厂模式实现这个场景。

工厂:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractFactory
{
    /// <summary>
    /// 支付;支付产品族
    /// </summary>
    public abstract class Pay
    {
        public abstract void PayWay();
    }

    /// <summary>
    /// 聊天;聊天产品族
    /// </summary>
    public abstract class Talk
    {
        public abstract void TalkWay();
    }

    /// <summary>
    /// 抽象工厂,应该包含所有共有方法,提供被其他子工厂继承
    /// </summary>
    public abstract class AbstractFactory
    {
        public abstract Pay CreatePay();
        public abstract Talk CreakTalk();
    }

    /// <summary>
    /// 阿里支付实现
    /// </summary>
    public class AliPay : Pay
    {
        public override void PayWay()
        {
            Console.WriteLine("我使用的支付产品是支付宝:{0}",this.GetType()); 
        }
    }

    /// <summary>
    /// 微信支付实现
    /// </summary>
    public class WeChatPay : Pay
    {
        public override void PayWay()
        {
            Console.WriteLine("我使用的支付产品是微信:{0}",this.GetType()); 
        }
    }

    /// <summary>
    /// 阿里聊天实现
    /// </summary>
    public class AliTalk : Talk
    {
        public override void TalkWay()
        {
            Console.WriteLine("我使用的聊天产品是支付宝:{0}", this.GetType()); 
        }
    }

    /// <summary>
    /// 微信聊天实现
    /// </summary>
    public class WeChatTalk : Talk
    {
        public override void TalkWay()
        {
            Console.WriteLine("我使用的聊天产品是微信:{0}", this.GetType()); 
        }
    }

    /// <summary>
    /// 支付宝工厂实现
    /// </summary>
    public class AliFactory : AbstractFactory
    {
        public override Pay CreatePay()
        {
            return new AliPay();
        }

        public override Talk CreakTalk()
        {
            return new AliTalk();
        }
    }

    /// <summary>
    /// 微信工厂实现
    /// </summary>
    public class WeChatFactory : AbstractFactory
    {
        public override Pay CreatePay()
        {
            return new WeChatPay();
        }

        public override Talk CreakTalk()
        {
            return new WeChatTalk();
        }
    }
}

 客户端:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractFactory
{
    class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory abstractFactory;
            Pay pay;
            Talk talk;
            //*****************阿里产品
            abstractFactory = new AliFactory();
            pay = abstractFactory.CreatePay();
            pay.PayWay();

            talk = abstractFactory.CreakTalk();
            talk.TalkWay();
            //*****************微信产品
            Console.WriteLine();
            abstractFactory = new WeChatFactory();
            pay = abstractFactory.CreatePay();
            pay.PayWay();

            talk = abstractFactory.CreakTalk();
            talk.TalkWay();
            Console.ReadLine();
        }
    }
}

效果:

抽象工厂

在现实的业务中,如果用到工厂方法,大大能增加业务的弹性。

相关推荐