设计模式之如何理解工厂模式？

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。这种模式将对象的实例化过程封装在工厂类中，通过使用工厂类来创建对象，而不是直接使用 new 操作符。这样可以将对象的创建与使用代码分离，提供一种统一的接口来创建不同类型的的对象。

从工厂模式定义中，可以看出这种方式，隐藏了对象的创建。主要有以下几种模式：

简单工厂

定义了一个工厂方法，由其决定创建出哪种类型的对象

工厂模式

定义一个抽象产品类，其子类可以决定生产出哪种类型的产品对象

抽象工厂

它提供了创建一系列相关对象的接口，而不需要指定它们的具体类

以上为常见的三种工厂模式，最大的特点就是对象的创建，使用工厂类来创建。这三种工厂模式的区别在于工厂和产品的对应关系上：

模式	工厂	产品
简单工厂	1	n（同一类别）
工厂	n	n（同一类别）
抽象工厂	n	n（不同类别）

由此可见，使用工厂模式，在进行对象创建的时候。主要看工厂和产品之间的关系。而扩展的关键，在于抽象类的使用。

javascript实践

由于javascript中，不存在抽象类，通过原型链的方式，实现一个抽象类继承。下面，通过原生javascript实现三种工厂模式

简单工厂

 // 抽象产品  
    var AbstractProduct = function () {};

    AbstractProduct.prototype.operation = function () {
        throw new Error("子类必须实现此方法");
    };

    // 具体产品类A  
    var ConcreteProductA = function () {};

    ConcreteProductA.prototype = Object.create(AbstractProduct.prototype);
    ConcreteProductA.prototype.constructor = ConcreteProductA;

    ConcreteProductA.prototype.operation = function () {
        console.log("执行产品A的操作");
    };

    // 具体产品类B  
    var ConcreteProductB = function () {};
    ConcreteProductB.prototype = Object.create(AbstractProduct.prototype);
    ConcreteProductB.prototype.constructor = ConcreteProductB;

    ConcreteProductB.prototype.operation = function () {
        console.log("执行产品B的操作");
    };

    
    // 具体工厂类A  
    var ConcreteFactory = function () {};
    ConcreteFactory.prototype.createProduct = function (type) {

        if (type == "A") {
            return new ConcreteProductA();
        }
        else if (type == "B")
        {
            return new ConcreteProductB();
        }
    };

    // 使用工厂创建产品实例  
    var factory = new ConcreteFactory();
    var productA = factory.createProduct("A")
    productA.operation() // 执行产品A的操作

    var productB = factory.createProduct("B")
    productB.operation() // 执行产品B的操作

工厂模式

// 抽象产品  
var AbstractProduct = function() {};  
  
AbstractProduct.prototype.operation = function() {  
  throw new Error("子类必须实现此方法");  
};  
  
// 具体产品类A  
var ConcreteProductA = function() {};  
ConcreteProductA.prototype = Object.create(AbstractProduct.prototype);  
ConcreteProductA.prototype.constructor = ConcreteProductA;  
  
ConcreteProductA.prototype.operation = function() {  
  console.log("执行产品A的操作");  
};  
  
// 具体产品类B  
var ConcreteProductB = function() {};  
ConcreteProductB.prototype = Object.create(AbstractProduct.prototype);  
ConcreteProductB.prototype.constructor = ConcreteProductB;  
  
ConcreteProductB.prototype.operation = function() {  
  console.log("执行产品B的操作");  
};  
  
// 抽象工厂类  
var AbstractFactory = function() {};  
  
AbstractFactory.prototype.createProduct = function() {  
  throw new Error("子类必须实现此方法");  
};  
  
// 具体工厂类A  
var ConcreteFactoryA = function() {};  
ConcreteFactoryA.prototype = Object.create(AbstractFactory.prototype);  
ConcreteFactoryA.prototype.constructor = ConcreteFactoryA;  
  
ConcreteFactoryA.prototype.createProduct = function() {  
  return new ConcreteProductA();  
};  
  
// 具体工厂类B  
var ConcreteFactoryB = function() {};  
ConcreteFactoryB.prototype = Object.create(AbstractFactory.prototype);  
ConcreteFactoryB.prototype.constructor = ConcreteFactoryB;  
  
ConcreteFactoryB.prototype.createProduct = function() {  
  return new ConcreteProductB();  
};  
  
// 使用具体工厂创建产品实例  
var factoryA = new ConcreteFactoryA();  
var productA = factoryA.createProduct();  
productA.operation(); // 输出 "执行产品A的操作"  
  
var factoryB = new ConcreteFactoryB();  
var productB = factoryB.createProduct();  
productB.operation(); // 输出 "执行产品B的操作"

抽象工厂

 // 抽象产品 A  
    var AbstractProductA = function () {};

    AbstractProductA.prototype.operation = function () {
        throw new Error("子类必须实现此方法");
    };

    // 具体产品类A  
    var ConcreteProductA1 = function () {};
    ConcreteProductA1.prototype = Object.create(AbstractProductA.prototype);
    ConcreteProductA1.prototype.constructor = ConcreteProductA1;

    ConcreteProductA1.prototype.operation = function () {
        console.log("执行产品A1的操作");
    };

    // 具体产品类B  
    var ConcreteProductA2 = function () {};
    ConcreteProductA2.prototype = Object.create(AbstractProductA.prototype);
    ConcreteProductA2.prototype.constructor = ConcreteProductA2;

    ConcreteProductA2.prototype.operation = function () {
        console.log("执行产品A2的操作");
    };

    // 抽象产品  B
    var AbstractProductB = function () {};

    AbstractProductB.prototype.operation = function () {
        throw new Error("子类必须实现此方法");
    };

    // 具体产品类A  
    var ConcreteProductB1 = function () {};
    ConcreteProductB1.prototype = Object.create(AbstractProductB.prototype);
    ConcreteProductB1.prototype.constructor = ConcreteProductB1;

    ConcreteProductB1.prototype.operation = function () {
        console.log("执行产品B1的操作");
    };

    // 具体产品类B  
    var ConcreteProductB2 = function () {};
    ConcreteProductB2.prototype = Object.create(AbstractProductB.prototype);
    ConcreteProductB2.prototype.constructor = ConcreteProductB2;

    ConcreteProductB2.prototype.operation = function () {
        console.log("执行产品B2的操作");
    };


    // 抽象工厂类  
    var AbstractFactory = function () {};

    AbstractFactory.prototype.createProduct = function () {
        throw new Error("子类必须实现此方法");
    };

    // 具体工厂类A  
    var ConcreteFactoryA = function () {};
    ConcreteFactoryA.prototype = Object.create(AbstractFactory.prototype);
    ConcreteFactoryA.prototype.constructor = ConcreteFactoryA;

    ConcreteFactoryA.prototype.createProduct = function (type) {
        if (type == "A1") {
            return new ConcreteProductA1();
        } else if (type == "A2") {
            return new ConcreteProductA2();
        }

    };

    // 具体工厂类B  
    var ConcreteFactoryB = function () {};
    ConcreteFactoryB.prototype = Object.create(AbstractFactory.prototype);
    ConcreteFactoryB.prototype.constructor = ConcreteFactoryB;

    ConcreteFactoryB.prototype.createProduct = function (type) {

        if (type == "B1") {
            return new ConcreteProductB1();
        } else if (type == "B2") {
            return new ConcreteProductB2();
        }
    };

    // 使用具体工厂创建产品实例  
    var factoryA = new ConcreteFactoryA();
    var productA1 = factoryA.createProduct("A1");
    productA1.operation(); // 输出 "执行产品A1的操作"  

    var productA2 = factoryA.createProduct("A2");
    productA2.operation(); // 输出 "执行产品A1的操作" 

    var factoryB = new ConcreteFactoryB();
    var productB1 = factoryB.createProduct('B1');
    productB1.operation(); // 输出 "执行产品B1的操作"

    var productB2 = factoryB.createProduct('B2');
    productB2.operation(); // 输出 "执行产品B2的操作"