工厂模式 // RocketTurtle

简单工厂模式

let Basketball = function () {
  this.intro = '篮球';
}
Basketball.prototype = {
  getMember: function () {
    console.log('每个队伍需要5名队员');
  }
}

let Football = function () {
  this.intro = '足球';
}
Basketball.prototype = {
  getMember: function () {
    console.log('每个队伍需要11名队员');
  }
}

function sportsFactory(name) {
  switch (name) {
    case: 'basketball'
      return new Basketball();
    case: 'football'
      return new Football();
  }
}

function createBook(name, time, type) {
  let o = new Object();
  o.name = name;
  o.time = time;
  o.type = type;
  o.getName = function () {
    console.log(this.name);
  }
  return o;
}

第一种工厂模式，所有的类实例都会共享原型上共有的方法和属性
第二种工厂模式每次返回的都是独立的个体，不存在相互影响

工厂方法模式

安全模式类

在类中判断this指向，若是指向全局对象，就返回一个Demo类的实例

let Demo = function () {
  if (!(this instanceof Demo)) {
    return new Demo();
  }
 }
Demo.prototype = {
  say: function () {
    console.log('hello world');
  }
}

let demo = Demo();
demo.say();//hello world

安全的工厂方法

若以后还有新的需求，可以在Factory的原型对象上添加方法
同时，这也是安全的工厂模式

function Factory(type, content) {
  if (!(this instanceof Factory)) {
    return new Factory[type](content);
  } else {
    return new Factory(type, content);
  }
}

Factory.prototype = {
  Java: function (content) { },
  JavaScript: function (content) { }
}

抽象工厂模式

function CarFactory(SubClass, name) {
  if (typeof this[name] === 'function') {
    function F() { }
    F.prototype = new CarFactory[name]();
    SubClass.contructor = SubClass;
    SubClass.prototype = new F();
  } else {
    throw new Error('不是抽象类');
  }
}

CarFactory.Car = function () {
  this.type = 'Car';
}

CarFactory.Car.prototype = {
  getSpeed: function() {
    return new Error('抽象方法');
  }
}

function BWW(speed) {
  this.speed = speed;
}

CarFactory(BWM, 'Car');

BWM.prototype.getSpeed = function () {
  console.log(this.speed);
}