1.简单工厂模式（静态工厂方法，由工厂对象决定创建某一种产品对象类的实例）

//根据不同的type创建不同的类的实例
var BasketBall = function(){
    this.into = "wtf";
}
BasketBall.prototype = {
    getMember : function(){
        console.log('123')
    },
    getBallSize : function(){
        console.log('big');
    },
        getBasket : function(){}
}
var FootBall = function(){
    this.into = "love";
}
FootBall.prototype = {
    getMember : function(){
        console.log('asf')
    },
    getBallSize : function(){
        console.log('small');
    },
        getFootBall : function(){}
}
var SportsFactory = function(name){
    switch(name){
        case 'NBA':
                    return new BasketBall();
            case 'wordCup':
            return new FootBall();
    }
}
//但是上面的方法基本都是重复的代码，这个时候可以用创建一个对象来代替不同的类
function createSprots(name,context){
      var o = new Object();
      o.into = context;
      o.getMember = function(){};
      o.getBallSize = function(){};
      if(name == 'basket'){
            o.getBasket = function(){}
      }
      if(name == 'football'){
            o.getFootBall = function(){}
      }
      return o;
}

/**
  *注:  第一种方法是通过实例化的方式创建，如果这些类继承于同一个父类，则可以共享原型上面的方法
  *     第二种方法是通过构建对象的方法创建，无法共享方法；
  */

2.工厂方法模式(通过对产品类的抽象使其创建业务主要负责于创建多类产品的实例)

//安全的工厂方法
var Factory = function(type,content){
  if(this instanceof Factory){
    var s = new this[type](content)
    return s;
  }else{
    return new Factory(type,content);
  }
}
//工厂原型中设置创建所有类型数据对象的基类
Factory.prototype = {
  Java : function(){

  },
  Javascript : function(){
    
  },
  ...
};
//后续有新的功能只需要在原型中添加即可

3.抽象工厂模式(用于对产品类簇的创建)

  var Person = function(){};
  Person.prototype = {
    getName : function(){
       return new Error('抽象方法不能实例');//通过手动跑出异常来表明这是一个抽象方法并不能给与实例化
    }
  }
  //上面的代码如果(new Person()).getName() //就会报错 用于模拟抽象类
  //具体效果，就是如果子类继承了这个抽象类，那么必须要重写抽象类里面的方法，不然直接调用原型上面的方法就会报错

//抽象工厂方法
var VehicleFactory = function(subType,superType){
  //判断抽象工厂中是否有该抽象类
  if(typeof VehicleFactory [superType] === 'function'){
    //缓存类
    function F(){};
    F.prototype = new VehicleFactory [superType](); //寄生式继承
    subType.constructor = subType; //修正子类的constructor
    subType.prototype = new F(); // new F()是因为不仅要继承F的原型 还要继承F的属性；
  }else{
    return new Error('未创建该抽象类.')
  }
}
//Person 抽象类
VehicleFactory .Person = function(){
  this.type = 'person'
}
VehicleFactory .Person.prototype = {
  getName: function(){}
}
//Animal 抽象类
VehicleFactory .Animal = function(){
  this.type = 'animal '
}
VehicleFactory .Animal .prototype = {
  getName: function(){}
}