【设计模式-手写源码-3】-抽象工厂模式-基于三国杀场景

本文链接：https://blog.csdn.net/chongfa2008/article/details/120060886

1：主题拆解

①基本介绍

②三国杀场景分析

③抽象工厂优缺点

④使用场景分析

⑤三大工厂对比总结

2：基本介绍

创建相关或依赖对象的家族，而无需明确指定具体类。

①为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

②抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品

③使用抽象工厂模式一般要满足以下条件：

系统中有多个产品族，每个具体工厂创建同族但属于不同等级的产品

系统一次只可能消费其中某一族产品，即同族的产品一起使用。

3：三国杀场景分析

咱们基于一款比较热门的手游三国杀来拆解抽象工厂模式

1：基础版

①定义主公与武将接口，都包括一下显示自己名字的show方法

    public interface IGroup
    {
        void ShowGroup();
    }
    public interface IGenerals
    {
        void ShowGenerals();
    }

②定义主公与武将实现。我们预备三个势力，魏蜀吴

魏

    public class GroupWei : IGroup
    {
        public void ShowGroup()
        {
            Console.WriteLine($"{this.GetType().Name} is 曹操");
        }
    }
    public class GeneralsWei : IGenerals
    {
        public void ShowGenerals()
        {
            Console.WriteLine($"武将：许诸，徐晃，张辽，夏侯渊，典韦");
        }
    }

蜀

    public class GroupShu : IGroup
    {
        public void ShowGroup()
        {
            Console.WriteLine($"{this.GetType().Name} is 刘备");
        }
    }
    public class GeneralsShu : IGenerals
    {
        public void ShowGenerals()
        {
            Console.WriteLine($"武将：关羽，张飞，赵云，马超，黄忠");
        }
    }

吴

    public class GroupWu : IGroup
    {
        public void ShowGroup()
        {
            Console.WriteLine($"{this.GetType().Name} is 孙权");
        }
    }
    public class GeneralsWu : IGenerals
    {
        public void ShowGenerals()
        {
            Console.WriteLine($"武将：黄盖，程普，祖茂，甘宁，吕蒙");
        }
    }

③上端调用游戏开战

IGroup groupWei = new GroupWei();
IGenerals generalsWei = new GeneralsWei();
groupWei.ShowGroup();
generalsWei.ShowGenerals();


IGroup groupShu = new GroupShu();
IGenerals generalsShu = new GeneralsShu();
groupShu.ShowGroup();
generalsShu.ShowGenerals();


IGroup groupWu = new GroupWu();
IGenerals generalsWu = new GeneralsWu();
groupWu.ShowGroup();
generalsWu.ShowGenerals();

分析：从上端的调用可以知道我们照样是在面向细节编程，基于抽象的处理，我进行第二版本的升级

2：升级版

基于简单工厂模式对细节进行抽象

①三方势力简单工厂封装

public class FactoryWei
{
    public IGroup CreateGroup()
    {
        return new GroupWei();
    }
    public IGenerals CreateGenerals()
    {
        return new GeneralsWei();
    }
}
public class FactoryShu
{
    public IGroup CreateGroup()
    {
        return new GroupShu();
    }
    public IGenerals CreateGenerals()
    {
        return new GeneralsShu();
    }
}
public class FactoryWu
{
    public IGroup CreateGroup()
    {
        return new GroupWu();
    }


    public IGenerals CreateGenerals()
    {
        return new GeneralsWu();
    }
}

②上端面向抽象编程，继续开战

FactoryWei factoryWei = new FactoryWei();
IGroup groupWei = factoryWei.CreateGroup();
IGenerals generalsWei = factoryWei.CreateGenerals();
groupWei.ShowGroup();
generalsWei.ShowGenerals();

FactoryShu factoryShu = new FactoryShu();
IGroup groupShu = factoryShu.CreateGroup();
IGenerals generalsShu = factoryShu.CreateGenerals();
groupShu.ShowGroup();
generalsShu.ShowGenerals();

FactoryWu factoryWu = new FactoryWu();
IGroup groupWu = factoryShu.CreateGroup();
IGenerals generalsWu = factoryWu.CreateGenerals();
groupWu.ShowGroup();
generalsWu.ShowGenerals();

分析：我们从业务场景中进行挖掘，可以发现每一方势力，都有ShowGroup和ShowGenerals方法，因此我们基于抽象可以进一步进行升级

3：最终版

对每个工厂的相同点进行抽象

①添加抽象工厂类，包含了ShowGroup和ShowGenerals两个抽象方法

    public abstract class AbstractFactory
    {
        public abstract IGroup CreateGroup();


        public abstract IGenerals CreateGenerals();
        
    }

②工厂类进行调整

public class FactoryWei: AbstractFactory
{
    public override IGroup CreateGroup()
    {
        return new GroupWei();
    }
    public override IGenerals CreateGenerals()
    {
        return new GeneralsWei();
    }
}
public class FactoryShu: AbstractFactory
{
    public override IGroup CreateGroup()
    {
        return new GroupShu();
    }
    public override IGenerals CreateGenerals()
    {
        return new GeneralsShu();
    }
}
public class FactoryWu: AbstractFactory
{
    public override IGroup CreateGroup()
    {
        return new GroupWu();
    }
    public override IGenerals CreateGenerals()
    {
        return new GeneralsWu();
    }
}

分析：至此为止，抽象工厂模式已经成型。

4：可扩展

如果游戏在三方势力之外，又添加第四方势力，例如群雄。此时基于抽象工厂模式是如何实现程序的可扩展性呢？咱们继续拆解

①添加群雄的公主类和武将类，基础自对应的接口，并且实现

public class GroupQun : IGroup
    {
        public void ShowGroup()
        {
            Console.WriteLine($"{this.GetType().Name} is 张角");
        }
    }
    public class GeneralsQun : IGenerals
    {
        public void ShowGenerals()
        {
            Console.WriteLine($"武将：吕布，颜良，文丑，华雄");
        }
    }

②添加群雄工厂类，继承抽象工厂并且对其中的方法进行重写

public class FactoryQun: AbstractFactory
    {
        public override IGroup CreateGroup()
        {
            return new GroupQun();
        }
        public override IGenerals CreateGenerals()
        {
            return new GeneralsQun();
        }
    }

分析：此时我们在不改任何代码的情况下，为整个产品族添加了新的功能。