设计模式C#实现（九）——工厂方法模式和简单工厂

工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

 构成：

1.Product工厂方法创建的对象的接口

2.ConcreteProduct具体的产品，实现Product接口

3.Creator声明工厂方法，返回Product

4.ConcreteCreator实现/重写Creator的工厂方法，返回ConcreteProduct实例

UML类图：

实现

要生产的产品都实现一个接口

interface Product
    {
        string getName();
    }

具体产品实现

  class Phone : Product
    {
        private string name = "MyPhone";
        public string getName()
        {
            return name;
        }
    }

工厂接口

  interface Creator
    {
        Product createProduct();
    }

具体工厂

   class PhoneCreator : Creator
    {
        public Product createProduct()
        {
            return new Phone();
        }
    }

使用

   class Program
    {
        static void Main(string[] args)
        {
            Creator creator = new PhoneCreator();
            Product phone= creator.createProduct();
            Console.WriteLine(phone.getName());
            Console.ReadKey();
        }
    }

效果：

1.客户仅需处理Product接口，而不用知道它的具体实现是什么，符合针对接口编程的OO原则

2.要创建一个ConcreteProduct，就不得不创建一个ConcreteCreator

简单工厂：提供一个类，由它负责根据一定的条件创建某一具体类的实例，简单工厂不是一个设计模式（GOF没提，《HeadFirst设计模式》说像一种编程习惯）

UML类图：

构成：

1.SimpleFactory简单工厂，根据条件（参数）创建并返回一个实例

2. Product产品接口

3.ConcreteProduct具体产品，实现Product接口

以生产披萨为例，因为Pizza有许多不同口味，SimpleFactory根据客户的口味生产不同Pizza

  class SimpleFactory
    {
        public Pizza getPizza(string type)
        {
            switch (type.Trim().ToLower())
            {
                case "cheesepizza":
                    return new CheesePizaa();
                    break;
                case "clampizza":
                    return new ClamPizza();
                    break;
                default:
                    return new NormalPizza();
                    break;
            }
        }

    }

Pizza接口

 abstract class Pizza
    {
        virtual public string getName()
        {
            return "NormalPizza";
        } 
    }

不同口味的Pizza

  class CheesePizaa : Pizza
    {
        override public string getName()
        {
            return "CheesePizaa";
        }
    }

 class ClamPizza : Pizza
    {
        override public string getName()
        {
            return "ClamPizza";
        }
    }

class NormalPizza:Pizza
    {

    }

客户选择可以提供条件来获得不同的实例

  class Program
    {
        static void Main(string[] args)
        {
            SimpleFactory factory = new SimpleFactory();
            Pizza cheesePiz = factory.getPizza("CheesePizza");
            Pizza clamPiz = factory.getPizza("ClamPizza");
            Pizza NormalPiz = factory.getPizza("");
            Console.WriteLine(cheesePiz.getName());
            Console.WriteLine(clamPiz.getName());
            Console.WriteLine(NormalPiz.getName());
            Console.ReadKey();
        }
    }

效果：

1.客户不再控制实例的创建，只需要使用，减少了客户的责任（单一责任原则?）

2.多个客户可以使用一个工厂，实现了代码复用

3.当实例的创建方法改变，并不影响客户（封装变化？）

4.当要添加产品就必须修改工厂，工厂方法模式一定程度上弥补了这个缺陷