转载请注明出处！！！http://blog.csdn.net/zhonghuan1992 
所有配套代码均在github上：https://github.com/ZHONGHuanGit/DesignPattern
 

 
 
 
跟着ZHONGHuan学习设计模式
 
简单工厂
 
简介：
 
         从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
 
 
 
类图：
 
        
 
         从UML类图中，可以看出，简单工厂模式的意思，就是把一个类内部，需要生成的部分，提取出来，变为一个工厂，通过工厂来new对象。
 
         假设我们要吃苹果了，我们可以在代码中new一个苹果出来；当我们需要吃香蕉了，我们在代码中new一个香蕉出来。这种做法你会不会觉得麻烦，new的事情都要自己做。所以可以把new的事情交给一个工厂来做（顾名思义，工厂是生产东西的地方）。而简单工厂通过传进来的参数，决定生产什么产品。
 
言语表达不清，请看下面的代码：
 
 
 
代码：
 
当我们一开始没有使用简单工厂模式，可能，我们会这样做，看下面的代码
 
 
class apple{
         public apple(){
                   System.out.println("生产了一个苹果");
         }
}
 
class banana{
         public banana(){
                   System.out.println("生产了一个香蕉");
         }
}
 
public class Main{
         public static void main(String[] args){
                   applea=new apple();
                   bananab=new banana();
         }
}

 

 
 
我们需要什么，则自己在代码中new出来，这样有时候是很方便的，但有时候，我们想想这样的情况，代码比较复杂，我们希望很多事情不是交给主程序来做，而是把new这样的事情交给一个工厂来做，这样，在后面更改的时候，我就不用一个一个在主程序代码中去审查，而是在工厂代码中统一更改。
 
看简单工厂模式的代码：
 
 
class fruit{
        
}
class apple extends fruit{
         public apple(){
                   System.out.println("生产了一个苹果");
         }
}
 
class banana extends fruit{
         public banana(){
                   System.out.println("生产了一个香蕉");
         }
}
 
class Factory{
         //通过传进来的参数str，来决定生产什么产品
         public fruit create(String str){
                   if(str.equals("apple"))
                            return new apple();
                   if(str.equals("banana"))
                            return new banana();
                   return null;
         }
}
 
public class Main{
         public static void main(String[] args){
                   Factory fac=new Factory();
                   apple a=(apple)fac.create("apple");//传进apple，生产apple
                   banana b=(banana)fac.create("banana");
         }
}

 

 
 
希望上述代码能够表述清楚。
 
 
 
为什么要简单工厂模式？看下面简单工厂模式的优点：
 
         这个模式的核心是工厂，这个工厂类有自己的逻辑，就是他懂得根据传进来的参数决定创造什么样的产品，客户端（就是调用工厂类方法的）不用管创建对象的事情，仅仅是知道告诉工厂类，他要什么，然后得到什么。这样实现了创建对象责任的分割。
 
 
 
简单工厂模式的缺点：
 
         没有完美的东西嘛，而且简单工厂离完美还差得远呢！这个模式关键缺点就是，工厂类好像是一个上帝一样，创造了所有。从科学的角度上说，上帝是不存在的。所以，当所有的创造对象都放在一个工厂类的时候，可想而知，这个工厂类是多么的复杂。所以，当产品多的时候，慎重考虑是否使用该模式。
 
 
 
遵循的原则：
 
         讨论一下简单工厂遵循的原则，顺便回顾一下。
 
         比较明显的，简单工厂遵循了开闭原则。（对开闭原则忘了，请看这里http://blog.csdn.net/zhonghuan1992/article/details/37391441）设想一下，当我们需要新的产品的时候，比如客人想吃西瓜了（夏天嘛，吃西瓜解暑），该模式不用更改原来的代码，仅仅是写一个新的类继承自fruit，然后，共产类中增加代码。这样就是满足了对拓展开放，对修改关闭的开闭原则。
 
 
 
 
 
 
 
 
 
 

1 简单工厂
 
根据参数由工厂类来创建对象
 
/**
 * 简单工厂
 * 目的：根据参数获取对象
 * 缺点：新增实现类时，需要修改代码，不好动态扩展（可参考工厂方法）
 */
public class SimpleFactoryDP {

    public final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
    }

    //抽象产品
    public interface Product {
        void show();
    }

    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }

    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    public static class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }

    void test(){
        Product product = SimpleFactory.makeProduct(1);
        product.show();
    }

}
 
2 工厂方法
 
解决简单工厂不能动态扩展实现类（开闭原则）
 
/**
 *  工厂方法
 *  单个工厂提供单个实现类，方便扩展更多实现类
 *  目的：优化简单工厂不好扩展新的类。这里只需要新增工厂类既能扩展
 *  缺点：有时需要工厂类能够同时提供多个不同对象（可参考抽象工厂）
 */
public class FactoryMethodDP {
    //抽象产品：提供了产品的接口
    interface Product {
        public void show();
    }
    //具体产品1：实现抽象产品中的抽象方法
    class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }
    //具体产品2：实现抽象产品中的抽象方法
    class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    //抽象工厂：提供了厂品的生成方法
    interface AbstractFactory {
        public Product newProduct();
    }
    //具体工厂1：实现了厂品的生成方法
    class ConcreteFactory1 implements AbstractFactory {
        public Product newProduct() {
            System.out.println("具体工厂1生成-->具体产品1...");
            return new ConcreteProduct1();
        }
    }
    //具体工厂2：实现了厂品的生成方法
    class ConcreteFactory2 implements AbstractFactory {
        public Product newProduct() {
            System.out.println("具体工厂2生成-->具体产品2...");
            return new ConcreteProduct2();
        }
    }

    void test() {
        AbstractFactory abstractFactory = new  ConcreteFactory1();
        abstractFactory.newProduct().show();
    }


}
 
3 抽象工厂
 
解决工厂方法 单个工厂不能同时创建多个不同的实现类
 
/**
 * 抽象工厂
 * 工厂可以产生多个不同对象，实现对象可以扩展，工厂类也可以动态组装
 */
public class AbstractFactoryDP {

    interface ProductA{
        void aEat();
    }
    class Aimpl1 implements ProductA{
        @Override
        public void aEat() {
            System.out.println("class is Aimpl1");
        }
    }
    class Aimpl2 implements ProductA{
        @Override
        public void aEat() {
            System.out.println("class is Aimpl2");
        }
    }

    interface ProductB{
        void bUse();
    }
    class Bimpl1 implements ProductB{
        @Override
        public void bUse() {
            System.out.println("class is Bimpl1");
        }
    }
    class Bimpl2 implements ProductB{
        @Override
        public void bUse() {
            System.out.println("class is Bimpl2");
        }
    }

    interface AbstractProductFactory{
        ProductA createA();
        ProductB createB();
    }

    class ProductFactoryImplA implements  AbstractProductFactory{
        @Override
        public ProductA createA() {
            return new Aimpl1();
        }
        @Override
        public ProductB createB() {
            return new Bimpl1();
        }
    }

    class ProductFactoryImplB implements  AbstractProductFactory{
        @Override
        public ProductA createA() {
            return new Aimpl2();
        }
        @Override
        public ProductB createB() {
            return new Bimpl2();
        }
    }

    void test(){
        AbstractProductFactory productFactory = new ProductFactoryImplA();
        ProductA productA = productFactory.createA();
        productA.aEat();
        ProductB productB = productFactory.createB();
        productB.bUse();
    }

}
 
 

引言
 
        工厂模式是比较常用的设计模式，主要用于返回实例对象，将多种类型的创建集中放在一个地方创建。工厂模式一般分为简单工厂模式，工厂方法模式，抽象工厂模式。各有优缺点，今天这里还加入了简单工厂模式的另一种实现，添加反射实现简单工厂。
 
例子
 
         一个很简单的例子：有个富豪想买奔驰，宝马，福特汽车，开出去玩。
 
代码：
 
什么模式都不用
 
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Client : MonoBehaviour {
    public abstract class Car
    {
        public abstract void Dirve();
    }
    public class Benz : Car
    {
        public override void Dirve()
        {
            Debug.Log("Dirve a Benz");
        }
    }
    public class BMW : Car
    {
        public override void Dirve()
        {
            Debug.Log("Dirve a BMW");
        }
    }
    public class Ford : Car
    {
        public override void Dirve()
        {
            Debug.Log("Dirve a Ford");
        }
    }

    void Start () {
        Car car1 = new Benz();
        car1.Dirve();
        Car car2 = new BMW();
        car2.Dirve();
        Car car3 = new Ford();
        car3.Dirve();
    }
}
 
上述代码已实现功能，但是上述代码有一些这样的情况：
 
1.如果有另一个富豪他也想买这三种车来开，那么在他的类里面也要写这三个类然后new3辆车——代码重复
 
2.一个富豪，他里面有三种汽车如何制造出来的代码，作为一个客户，他却要懂生产——职责混淆
 
但是，聪明的你肯定马上就想到，直接把这三个汽车类单独抽出来，这样，客户直接new出来就可以了，职责也不混淆，别的富豪要车也可以直接new出来，代码也不重复。
 
那我们接下来看，假设我的汽车抽象类，稍微复杂那么一丢丢，如下：
 
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public abstract class Car {
    public float Length;
    public float Width;
    public float High;
    public float MaxSpeed;
    public abstract void Dirve();
    public abstract void Test(); //出厂测试
}
 
1.new一辆奔驰车出来，这些字段都需要赋值，还要运行一个出厂测试方法，如果这些赋值，方法在客户client类里面写，那么其他所有客户都要写这些代码，代码重复。
 
但是你肯定马上说：“不对，我可以写在汽车类的构造函数里面”，当然可以，不过，如果要干的事情特别多，几十行上百行的代码，全放构造函数里面，有点违背设计原则，在构造函数做太复杂的操作，当出错时发现错误有时会很困难。特别是定义为全局变量时，程序还没有运行、就出错了。构造函数应该尽量简单，一眼望穿，最好能保证永不出现构造失败的情况。
 
2.如果Benz(奔驰车)多了一个子类，奔驰二代Benz2,现在买奔驰车返回这个类的对象，那么所有客户端的new Benz()，都要换成new Benz2()，而如果做成工厂模式，直接在返回奔驰车的代码哪里更改一下返回Benz2类的对象就可以了，反正返回的都是Car（抽象父类）——方便维护。
 
3.如果所有的汽车类，在返回对象之前，又要添加新的逻辑了，那么需要一个个类的找，修改，如果全集中在工厂类中，直接在工厂类中修改即可，避免遗漏，还是——方便维护。
 
所以工厂模式主要是有代码重用，分割职责解耦，便于维护的特点。
 
 
 
那么接下来来看看工厂模式：
 
还是上面的例子：有个富豪想买奔驰，宝马，福特汽车，开出去玩。
 
一、简单工厂
 
汽车类
 
public abstract class Car {
    public abstract void Dirve();
}
 
奔驰
 
public class Benz : Car{

    public override void Dirve()
    {
        Debug.Log("Dirve a Benz");
    }
}
 
宝马
 
public class BMW : Car {
    public override void Dirve()
    {
        Debug.Log("Dirve a BMW");
    }
}
 
福特
 
public class Ford : Car {
    public override void Dirve()
    {
        Debug.Log("Dirve a Ford");
    }
}
 
简单工厂类
 
public class SimpleFactory {
    public static Car CreatCar(string car)
    {
        Car newCar = null;
        if (car == "Benz")
        {
            newCar = new Benz();
        }
        else if (car == "BMW")
        {
            newCar = new BMW();
        }
        else if (car == "Ford")
        {
            newCar = new Ford();
        }
        return newCar;
    }
}
 
客户类
 
public class ClientSimple : MonoBehaviour {

	void Start () {
        //简单工厂
        Car car1 = SimpleFactory.CreatCar("Benz");
        car1.Dirve();
        Car car2 = SimpleFactory.CreatCar("BMW");
        car2.Dirve();
        Car car3 = SimpleFactory.CreatCar("Ford"); ;
        car3.Dirve();
    }
}
 
上述代码，客户不需要知道怎么生产汽车（解耦），多个客户要车都可以调用工厂得到汽车，如果汽车初始要做很多事情，都可以在工厂类里面newcar之后调各自类的方法，赋值，如果什么模式都不用，直接new的方式，就要写在类的构造函数里面或者直接在客户类写，不太好(重复)。
 
上述代码也会有一些情况，如果我需要新增一种车，比如莱斯莱斯，那么我就要在工厂类里面多加一个else if条件判断。工厂类就要进行修改——扩展性不强，这个工厂类包含类所有类的创建，很重要，频繁改动如果出错影响面广。
 
如果种类不多，简单工厂用起来还是不错的。
 
 
 
二、工厂方法
 
汽车类同上，
 
抽象工厂类：
 
public abstract class Factory {
    public abstract Car CreatCar();
}
 
奔驰工厂
 
public class BenzFactory : Factory {
    public override Car CreatCar()
    {
        return new Benz();
    }
}
 
宝马工厂
 
public class BMWFactory : Factory {
    public override Car CreatCar()
    {
        return new BMW();
    }
}
 
福特工厂
 
public class FordFactory : Factory {
    public override Car CreatCar()
    {
        return new Ford();
    }
}
 
客户类
 
public class ClientSimple : MonoBehaviour {

	void Start () {
        //工厂方法
        Car car1 = new BenzFactory().CreatCar();
        car1.Dirve();
        Car car2 = new BMWFactory().CreatCar();
        car2.Dirve();
        Car car3 = new FordFactory().CreatCar();
        car3.Dirve();
    }
}
 
上述代码，添加新类型的莱斯莱斯车，需要新增莱斯莱斯车类和莱斯莱斯工厂类，工厂父类Factory不需要修改，这样对于已有的工厂不会产生任何潜在的改动影响——便于扩展。
 
对于这种方式，和直接new Benz(), new BMW(), new Ford()有点像，每一种车有一个工厂类，不过还是上面讲的，如果返回一个实例要做很多事情，不好直接写在构造函数里面，可以写在具体的工厂类里面，而且如果工厂父类要添加新的逻辑，所有工厂同时享有。
 
工厂方法就是每加一种类型，要添加汽车类，还要添加具体工厂类，增加开销。
 
 
 
三、抽象工厂
 
抽象工厂其实就是工厂方法的扩展，以前工厂方法父类，只生产汽车，现在工厂作死新开了一条火箭生产流水线，要可以制作火箭了，那么工厂父类就变成这样：
 
public abstract class Factory {
    public abstract Car CreatCar();
    public abstract Rocket CreatRocket();
}
 
那么奔驰工厂，宝马工厂，福特工厂类都要添加生产火箭的方法，奔驰牌火箭，宝马牌火箭，福特牌火箭都属于继承自抽象火箭类Rocket,和之前的Car是一模一样的逻辑。代码就不放了，看这个工厂父类就知道了，这就是抽象工厂和工厂方法的区别。
 
这个抽象工厂，如果增加一种新产品种类，工厂父类和所有子类工厂，都需要改动。
 
是否使用看自己项目需求了。
 
 
 
四、反射+简单工厂
 
public class SimpleFactory {
    public static Car CreatCar(string car)
    {
        Car newCar = null;
        if (car == "Benz")
        {
            newCar = new Benz();
        }
        else if (car == "BMW")
        {
            newCar = new BMW();
        }
        else if (car == "Ford")
        {
            newCar = new Ford();
        }
        return newCar;
    }
}
 
上面的是之前的简单工厂，主要就是不便于扩展，新增一种车，就要在工厂类里面多加一个条件判断。
 
现在添加反射实现简单工厂，代码如下：
 
public class ReflectionSimpleFactory {

    public static Car CreatCar(string carClass)
    {
        //获取当前程序集
        Assembly ass = Assembly.GetCallingAssembly();
        //获取程序集中的类
        Type t = ass.GetType(carClass);
        //创建类的实例对象
        Car o = (Car)Activator.CreateInstance(t);
        return o;
    }	
}
 
客户类还是和之前简单工厂一样调用
 
public class ClientSimple : MonoBehaviour {

	void Start () {
        //反射+简单工厂
        Car car1 = ReflectionSimpleFactory.CreatCar("Benz");
        car1.Dirve();
        Car car2 = ReflectionSimpleFactory.CreatCar("BMW");
        car2.Dirve();
        Car car3 = ReflectionSimpleFactory.CreatCar("Ford");
        car3.Dirve();
    }
}
 
 
 
 
如果新增一种劳斯莱斯车型，只需要添加新类RR这一个类就可以，工厂类不用做其他改动，解决了简单工厂的扩展性问题。
 
public class RR : Car {
    public override void Dirve()
    {
        Debug.Log("Dirve a RR");
    }   
}
 
public class ClientSimple : MonoBehaviour {
	void Start () {
        //反射+简单工厂
        Car car1 = ReflectionSimpleFactory.CreatCar("Benz");
        car1.Dirve();
        Car car2 = ReflectionSimpleFactory.CreatCar("BMW");
        car2.Dirve();
        Car car3 = ReflectionSimpleFactory.CreatCar("Ford");
        car3.Dirve();
        Car car4 = ReflectionSimpleFactory.CreatCar("RR");
        car4.Dirve();
    }
}
 
 
 
 
反射也存在效率问题，我这里创建基本什么都没干，循环创建3辆车，100万次试了一下，测试代码如下：
 
using System.Diagnostics;
using UnityEngine;

public class Client_Factory : MonoBehaviour {

	void Start () {
        Stopwatch st = new Stopwatch();
        st.Reset();
        st.Start();
        for (int i = 0; i < 1000000; i++)
        {
            简单工厂
            //Car car1 = SimpleFactory.CreatCar("Benz");
            car1.Dirve();
            //Car car2 = SimpleFactory.CreatCar("BMW");
            car2.Dirve();
            //Car car3 = SimpleFactory.CreatCar("Ford"); ;
            car3.Dirve();

            工厂方法
            //Car car1 = new BenzFactory().CreatCar();
            car1.Dirve();
            //Car car2 = new BMWFactory().CreatCar();
            car2.Dirve();
            //Car car3 = new FordFactory().CreatCar();
            car3.Dirve();

            //反射+简单工厂
            Car car1 = ReflectionSimpleFactory.CreatCar("Benz");
            //car1.Dirve();
            Car car2 = ReflectionSimpleFactory.CreatCar("BMW");
            //car2.Dirve();
            Car car3 = ReflectionSimpleFactory.CreatCar("Ford");
            //car3.Dirve();
        }
        st.Stop();
        UnityEngine.Debug.Log(st.ElapsedMilliseconds.ToString()+ " ms");
    }
}
 
用时分别是简单工厂：237ms，工厂方法：326ms，反射+简单工厂：10305ms，前两种基本差别不大，反射之后差了几十倍。这个类创建很简单，如果类复杂，反射可能更耗时，不过这是100万次，日常开发基本也不太可能调用这么多次，具体是否用，自己项目衡量。
 
 
 

工厂模式,简单工厂模式,抽象工厂模式三者有什么区别
 
工厂模式，也叫做说虚构造器，在简单工厂中间插入了一个具体产品工厂，这个工厂知道产品构造时候的具体细节，而简单工厂模式的产品具体构造细节是在一个个if/else分支，或者在switch/case分支里面的。工厂模式的好处就在于将工厂和产品之间的耦合降低，将具体产品的构造过程放在了具体工厂类里面。在以后扩展产品的时候方便很多，只需要添加一个工厂类，一个产品类，就能方便的添加产品，而不需要修改原有的代码。而在简单工厂中，如果要增加一个产品，则需要修改工厂类，增加if/else分支，或者增加一个case分支，工厂模式符合软件开发中的OCP原则（open close principle），对扩展开放，对修改关闭。
 抽象工厂模式：这个模式我总是感觉和builder模式非常相似。
 工厂方法模式提供的是对一个产品的等级模式，，而抽象工厂方法提供的是对多个产品的等级模式，注意，这里的多个具体产品之间是相互耦合的，也就是说这里的抽象工厂提供的产品之间是存在某种联系的。
 有人做如下的比较：
 工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。
 一个抽象工厂类，可以派生出多个具体工厂类。
 每个具体工厂类只能创建一个具体产品类的实例。
 抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
 一个抽象工厂类，可以派生出多个具体工厂类。
 每个具体工厂类可以创建多个具体产品类的实例。
 区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
 工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
 下面是一个形象的比喻：
 无论是简单工厂模式、工厂模式还是抽象工厂模式，它们本质上都是将不变的部分提取出来，将可变的部分留作接口，以达到最大程度上的复用。拿一个生产水杯（cup）的工厂举例：起初，不用工厂模式，我必须在生产水杯之前知道水杯的材料和形状等水杯的所有特征才能生产，这就是我们的new Cup();这个Cup必须是具体的。厂主发现同一形状的被子，只是材料不同,如一个是玻璃(glass)的，一个是瓷(china)的,但是确要两条生产线，显然有资源浪费的嫌疑。现在厂主生产杯子时先不让生产线知道我要产的是玻璃的还是瓷的，而是让它在不知道具体材料的情况下先做它能做的，等到它把模具做好，只需要向其中填充玻璃原料或者瓷原料就可以造出同一形状的具体杯子了。但是很可惜，java并不能new一个抽象的Cup，所以就有了简单工厂模式。原来是Cup cup=new Cup;现在是SimpleCupFactory.createCup(String cupName),根据cup的名字生产Cup,而createCup返回的是一个实现了 Cup接口或抽象类的具体Cup。简单抽象工厂模式有一个问题，就是当我现在想生产一个同样形状的铁杯时，工厂里并没有定义相应的处理流程，只能更改createCup方法，这就不合理了。我现在只是想生产铁杯，你只要在最后的时候把玻璃原料换成铁的不就行了吗，干嘛还要更改整条生产线呢？于是就有了工厂模式。原来生产线在生产模具的时候还要考虑是为玻璃杯生产的模具还是为铁杯生产的模具，现在它不用管了。CupFactory.createCup()创建Cup.CupFactory是接口或抽象类。实现它的具体子类会创建符合Cup接口的具体Cup。那么现在厂主想要生产水壶(kettle)，用工厂模式就不得不再造一条水壶生产线，能不能在水杯生产线同时生产水壶呢？这就是抽象工厂模式。在原CupFactory中加一个createKettle()方法，用来生产水壶