32种设计模式-抽象工厂模式（AbstractFactory）

介绍：

提供了一个接口，无需指定它们具体的类，就可以创建一组密不可分的对象

主要解决：

 主要解决接口选择的问题

何时使用：

  系统的产品有多于一个的产品族，而系统只消费其中某一族产品。

如何解决：

 在一个产品族里面，定义多个产品。

优点：

 1、当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

 1、产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的Creator里加代码，又要在具体的里面加代码

使用场景：

  1、qq换皮肤，一整套一起换。

如何实现：

步骤一：创建接口类IColor、IShape

public interface IColor
    {
        void fill();
    }

 public interface IShape
    {
        void draw();
    }

步骤二：创建实体类Rectangle、Square、Circle、Red、Green、Blue

 public class Rectangle : IShape
    {
        public void draw()
        {
            Console.WriteLine("这是Rectangle中的draw方法");
        }
    }

public class Square : IShape
    {
        public void draw()
        {
            Console.WriteLine("这是Square中的draw方法");
        }
    }

 public class Circle : IShape
    {
        public void draw()
        {
            Console.WriteLine("这是Circle中的draw方法");
        }
    }

public class Red : IColor
    {
        public void fill()
        {
            Console.WriteLine("这是Red中的fill方法");
        }
    }

public class Green : IColor
    {
        public void fill()
        {
            Console.WriteLine("这是Green中的fill方法");
        }
    }

public class Blue : IColor
    {
        public void fill()
        {
            Console.WriteLine("这是Blue中的fill方法");
        }
    }

步骤三：创建IAbstractFactory，为IColor和IShape对象创建接口来获取工厂

 public interface IAbstractFactory
    {
        IColor GetColor(string color);

        IShape GetShape(string shape);
    }

步骤四：创建AbstractFactory，基于给定的信息生成实体类的对象。

public class AbstractFactory : IAbstractFactory
    {
        public IColor GetColor(string colorType)
        {
            if (colorType.Equals("Red")) {
                return new Red();
            } else if (colorType.Equals("Green")) {
                return new Green();
            } else if (colorType.Equals("Blue")) {
                return new Blue();
            }
            return null;
        }

        public IShape GetShape(string shapeType)
        {
            if (shapeType.Equals("Circle")) {
                return new Circle();
            } else if (shapeType.Equals("Rectangle")) {
                return new Rectangle();
            } else if (shapeType.Equals("Square")) {
                return new Square();
            }
            return null;
        }
    }

步骤五：创建一个工厂创造器/生成器类FactoryProducer

public class FactoryProducer
    {
        public static IAbstractFactory GetFactory() {

            return new AbstractFactory();
        }
    }

步骤六：使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

static void Main(string[] args)
        {
            #region 单例模式
            {
                //单例模式 Singleton
                Console.WriteLine("========================单例模式========================");
                //饿汉式，不用加锁，执行效率高，但很容易产生垃圾对象
                SingleObjectA singletonA = SingleObjectA.getInstance();
                singletonA.showMessage();
                //懒汉式，线程不安全
                SingleObjectB singleObjectB = SingleObjectB.getInstance();
                singleObjectB.showMessage();
                //懒汉式，线程安全 双重加锁
                SingleObjectC singleObjectC = SingleObjectC.GetSingleObjectC();
                singleObjectC.showMessage();
            }
            #endregion


            #region 抽象工厂模式
            {
                //抽象工厂模式
                Console.WriteLine("========================抽象工厂模式========================");

                IAbstractFactory abstractFactory = FactoryProducer.GetFactory();
                //获取Circle的对象
                IShape shape1 = abstractFactory.GetShape("Circle");
                //调用方法
                shape1.draw();
                //获取Rectangle对象
                IShape shape2 = abstractFactory.GetShape("Rectangle");
                //调用方法
                shape2.draw();
                //获取Square对象
                IShape shape3 = abstractFactory.GetShape("Square");
                //调用方法
                shape3.draw();

                //获取Red对象
                IColor shape4 = abstractFactory.GetColor("Red");
                //调用对象
                shape4.fill();
                //获取Green对象
                IColor shape5 = abstractFactory.GetColor("Green");
                //调用对象
                shape5.fill();
                //获取Blue对象
                IColor shape6 = abstractFactory.GetColor("Blue");
                //调用对象
                shape6.fill();
            }
            #endregion

            Console.ReadLine();
        }

运行结果为：