简单工厂,工厂方法,抽象工厂

一,简单工厂

描述:是由一个工厂对象根据接收到的消息去决定返回的实例,可以用if,switch判断

优点:客户端只需要去告诉工厂需要什么对象就行,不需要关心怎么创建的,当引入新的产品不需要改变代码,只需添加一个产品类即可.并加以修改工厂类.

从产品角度去看,符合开闭原则.

缺点:当产品较多时,就要频繁修改工厂类,逻辑比较复杂.不利于扩展和维护,从工厂角度来看,不符合开闭原则.

      static void Main(string[] args)
                {
                    Product fac = Factory.Create("雷神电脑");
                    fac.DianNao();
                    Console.ReadKey();
                

                }
//工厂类
public  class Factory
    {
        public static Product Create(string Name)
        {
            switch (Name)
            {
                case "惠普电脑":return new ConcreteProductA();
                case "雷神电脑": return new ConcreteProductB();
                default:return null;
            }
        }
    }

//抽象产品
public interface Product
    {
          void DianNao();
    }
//产品A
public class ConcreteProductA:Product
    {
        public  void DianNao()
        {
            Console.WriteLine("惠普电脑");
        }
    }
//产品B
 public  class ConcreteProductB:Product
    {
   

        public  void DianNao()
        {
            Console.WriteLine("雷神电脑");
        }
    }

二,工厂方法

1.描述:创建一个工厂接口,由子工厂去创建实例,把创建实例推迟到子工厂中,

2.优点:

把简单的逻辑放到客户端,不用去修改工厂代码,克服了简单工厂违背的开闭原则,便于维护,扩展,添加新产品,只需添加一个工厂类即可.

 class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory abs = new ConcreteFactoryA();
            abs.ConcreteFactory().DianNao();
            AbstractFactory ab = new ConcreteFactoryB();
            abs.ConcreteFactory().DianNao();
            Console.ReadKey();
        }
    }

//工厂接口
 public  interface   AbstractFactory
    {
      
          AbstractProduct ConcreteFactory();

    }
//抽象产品
  public interface  AbstractProduct
    {
        void DianNao();
     
    }
//实际产品A
public class ConcreteFactoryA:AbstractFactory
    {
        public   AbstractProduct ConcreteFactory()
        {
            return new ProductA();
        }

      
    }
//实际产品B
 public  class ConcreteFactoryB:AbstractFactory
    {
        public  AbstractProduct ConcreteFactory()
        {
            return new ProductB();
        }
    }

三,抽象工厂

1：描述：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

　　2：优点：（1）：当一个产品族中的多个对象被设计在一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

　　　　　　  （2）：具有工厂方法模式解耦的优点。

　　　　　　  （3）：工厂方法模式针对的是一个产品等级结构，抽象工厂模式针对的是面向多个产品等级结构，最主要的是可以在类的内部对产品族的关联关系进行定义和描述。

　　3：例子：以生产两款车子为例，一个工厂生产宝马和比亚迪两款汽车，同时生产国产和进口两种发动机。

 class Program
    {
        static void Main(string[] args)
        {
            IFactory carAFactory = new CarA();
            carAFactory.ProductCar().ProductCar();
            carAFactory.ProductEngine().ProductEngine();

            IFactory carBFactory = new CarB();
            carBFactory.ProductCar().ProductCar();
            carBFactory.ProductEngine().ProductEngine();

            Console.ReadKey();

        }
    }
    public interface ICarProduct
    {
        void ProductCar();
    }
    public class BMWCar : ICarProduct
    {
        public void ProductCar()
        {
            Console.Write("宝马汽车:");
        }
    }
    public class BYDCar : ICarProduct
    {
        public void ProductCar()
        {
            Console.Write("比亚迪汽车:");
        }
    }
    public interface IEngineProduct
    {
        void ProductEngine();
    }
    public class DomesticEngine : IEngineProduct
    {
        public void ProductEngine()
        {
            Console.WriteLine("国产发动机");
        }
    }
    public class ImportEngine : IEngineProduct
    {
        public void ProductEngine()
        {
            Console.WriteLine("进口发动机");
        }
    }
    public interface IFactory
    {
        ICarProduct ProductCar();
        IEngineProduct ProductEngine();
    }
    public class CarA : IFactory//宝马汽车，进口发电机
    {
        public ICarProduct ProductCar()
        {
            return new BMWCar();
        }
        public IEngineProduct ProductEngine()
        {
            return new ImportEngine();
        }
    }
    public class CarB : IFactory//比亚迪汽车，国产发电机
    {
        public ICarProduct ProductCar()
        {
            return new BYDCar();
        }
        public IEngineProduct ProductEngine()
        {
            return new DomesticEngine();
        }
    }