简单工厂 工厂模式 抽象工厂 之c#

前面介绍了策略和单例模式，这篇文章说一下简单工厂，工厂，抽象工厂的概念和应该场景

首先，从简单工厂开始:

见上图，可以看出来，最核心的部分就是工厂类了，所有的变化都封装在这个工厂类里面，Client不用关心类的实例化

但是，可谓成也工厂类，败也工厂类

如果，实例化的对应有所变化，就需要修改核心工厂类，违背了开放-封闭原则(对修改封闭，对扩展开放)

C#版本代码实现

   public abstract class  Simplyfactory
    {
         public  abstract   string CreateFactory();

    }
    public class SimplyA : Simplyfactory
    {
        public override string CreateFactory()
        {
            return "FactoryA";
        }
    }

    public class SimplyB : Simplyfactory
    {
        public override  string CreateFactory()
        {
            return "FactoryB";
        }
    }

    class Factory
    {
        public static Simplyfactory Create(string Type)//核心工厂类负责所有对象的创建，属于创建型模式
        {
            Simplyfactory s = null;
            switch (Type)
            {
                case "A":
                    s = new SimplyA();
                    break;
                case "B":
                    s = new SimplyB();
                    break;
                default:
                    break;
            }
            return s;
        }
    }

    class Client
    {
        static void GetSimplyFactory()
        {
            Simplyfactory simplyfactory = Factory.Create("A");
            Console.Write(simplyfactory.CreateFactory());
            Console.Read();
        }
    }

输出结果:FactoryA

简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式（Static FactoryMethod Pattern）,是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类

简单工厂模式解决的问题是如何去实例化一个合适的对象。

简单工厂模式的核心思想就是：有一个专门的类来负责创建实例的过程。

好的，下面介绍下工厂模式

先来图

 

 

定义一个创建对象的抽象类,有子类来决定具体实例化哪个类,使一个类的创建延迟到子类中

创建的对象Product不会变，但是对象的具体实现经常变换，如果发生变化，增加新的FacotoryMethods子类就可以了

满足对开放--封闭原则

 C#版本代码:

 public abstract class Product
    {
        public abstract void work();
    }
    public class ProductA : Product
    {
        public override void work()
        {
            Console.Write("ProductA");
        }
    }
    public class ProductB : Product
    {
        public override void work()
        {
            Console.Write("ProductB");
        }
    }

    public abstract class FactoryMethods
    {
        public abstract Product newproduct();
    }
    //对不同产品的实例化，由不同的工厂来具体实现,每一个工厂生产具体的商品
    public class FactoryMethodA : FactoryMethods//具体工厂
    {
        public override Product newproduct()
        {
            return new ProductA();//实现具体的实例化
        }
    }
    public class FactoryMethodB : FactoryMethods//具体工厂
    {
        public override Product newproduct()
        {
            return new ProductB();//实现具体的实例化
        }
    }

    public class FactoryMethodClient
    {
        public static void GetFactoryMethod()
        {
            //产品种类是变化的，如果发生变化，新增一个工厂就可以了,在调用的地方掉用新的方法
            //体现出对修改封闭，对扩展开放，新增新的功能对原来的没有影响
            FactoryMethods factorysubA = new FactoryMethodA();
            FactoryMethods factorysubB = new FactoryMethodB();

            Product pruductA = factorysubA.newproduct();
            Product pruductB = factorysubB.newproduct();

            pruductA.work();
            pruductB.work();
        }
    }

可以看出来，工厂模式的工厂，实例化的对象只有一个，如果实例化的对象是多个，就成了抽象工厂模式，其实工厂模式和抽象工厂也就这点区别

先来看看抽象工厂的UML图

看到了吧，唯一的区别就是工厂创建了多个对象，当然，还是在工厂子类中创建的，这一点和工厂模式是一致的

C#版本代码

   

/*其实工厂和抽象工厂没有多大区别，只不过是抽象工厂生产的商品是多个而已
    通俗的说，就是抽象工厂模式的具体工厂里面会有多个实例具体对象的方法
    更直观的就是，抽象工厂模式每个工厂一次造多个玩意,而工厂模式的每个工厂只造一个玩意*/
    public abstract class Product
    {
        public abstract void work();
    }
    public class ProductA : Product
    {
        public override void work()
        {
            Console.Write("ProductA");
        }
    }
    public class ProductB : Product
    {
        public override void work()
        {
            Console.Write("ProductB");
        }
    }
    public abstract class Car
    {
        public abstract void Build();
    }
    public class CarA : Car
    {
        public override void Build()
        {
            Console.Write("Build CarA");
        }
    }
    public class CarB : Car
    {
        public override void Build()
        {
            Console.Write("Build CarB");
        }
    }
    public abstract class AbstractFactory
    {
        //工厂生产多个对象
        public abstract Product newproduct();
        public abstract Car newCar();
    }
    public class AbstractFactoryA : AbstractFactory
    {
        public override Product newproduct()
        {
            return new ProductA();//子类里面实现具体的实例化
        }
        public override Car newCar()
        {
            return new CarA();
        }
    }
    public class AbstractFactoryB : AbstractFactory
    {
        public override Product newproduct()
        {
            return new ProductB();//子类里面实现具体的实例化
        }
        public override Car newCar()
        {
            return new CarB();
        }
    }

    public class AbstractFactoryClient
    {
        public static void GetFactoryMethod()
        {
            AbstractFactory factorysubA = new AbstractFactoryA();
            AbstractFactory factorysubB = new AbstractFactoryA();

            Product pruductA = factorysubA.newproduct();
            Product pruductB = factorysubB.newproduct();
            Car factorycarA = factorysubA.newCar();

            factorycarA.Build();

            pruductA.work();
            pruductB.work();
        }
    }

应用场景：封装变化点。创建一系列相互依赖的对象。

好了，到这里就把简单工厂，工厂，抽象工厂都介绍完了，抽象工厂的问题是如果有创建对象变化的时候，还是要变化代码，重新生成，后面会介绍用反射解决这个问题