JavaScript-工厂模式

• 简单工厂模式
• 工厂模式
• 抽象工厂模式

简单工厂模式

专门定义一个工厂类,根据不同的参数值来创建其他类的实例,被创建的类通常具有相同的父类,也就是有相同的接口,如该工厂根据不同的参数来选择实例化戴尔鼠标或者惠普鼠标,MouseFacotry.createMouse(),可以解除对象的耦合

工厂模式

定义一个用于创建对象的接口,让子类决定实例化哪一个类,使类的实例化延迟到子类中,如有一个鼠标工厂MouseFactory抽象类,其子类惠普鼠标工厂HpMouseFactory和戴尔鼠标工厂DellMouseFacotry负责创建惠普鼠标和戴尔鼠标,HpMouseFactory.createMouse()

抽象工厂模式

提供一个创建一系列相关或者互相依赖对象的接口,而无需指定他们具体的类,当产品只有一个时,抽象工厂模式就是工厂模式,当工厂模式的产品变为多个时,工厂模式就变成抽象工厂模式,也就是抽象工厂模式是根据不同参数返回某一个工厂,再又该工厂创建对象

// 模拟接口类 Shape,Color
class Shape {
  draw() {
    throw new Error(
      `${this.__proto__.constructor.name} must overwrite draw method`
    );
  }
}

// 产品族 Circle,Square,Rectangle
class Circle extends Shape {
  draw() {
    console.log(`circle draw`);
  }
}
class Square extends Shape {
  draw() {
    console.log("square draw");
  }
}
class Rectangle extends Shape {
  draw() {
    console.log(`rectangle draw`);
  }
}

class Color {
  fill() {
    throw new Error(
      `${this.__proto__.constructor.name} must overwrite fill method`
    );
  }
}

class Red extends Color {
  fill() {
    console.log(`red fill`);
  }
}
class Green extends Color {
  fill() {
    console.log(`green fill`);
  }
}
class Blue extends Color {
  fill() {
    console.log(`blue fill`);
  }
}

// 抽象工厂类
class AbstractFactory {
  getShape() {
    throw new Error("必须实现getShape方法");
  }
  getColor() {
    throw new Error("必须实现getColor方法");
  }
}

// 实际工厂类 ShapeFactory ColorFactory
class ShapeFactory extends AbstractFactory {
  getShape(shapeType) {
    if (shapeType == null) {
      return null;
    }
    if (shapeType === "circle") {
      return new Circle();
    } else if (shapeType == "rectangle") {
      return new Rectangle();
    } else if (shapeType == "square") {
      return new Square();
    }
  }
  getColor(color) {
    return null;
  }
}

class ColorFactory extends AbstractFactory {
  getShape(shapeType) {
    return null;
  }
  getColor(color) {
    if (color == null) {
      return null;
    }
    if (color == "red") {
      return new Red();
    } else if (color == "blue") {
      return new Blue();
    } else if (color == "green") {
      return new Green();
    }
  }
}

// 抽象工厂模式,返回的是某一个工厂,该工厂产生某一个产品族,如Shape类里的Circle,Square,Rectangle
class FactoryProducer {
  static getFactory(factoryType) {
    if (factoryType == "shape") {
      return new ShapeFactory();
    } else if (factoryType == "color") {
      return new ColorFactory();
    }
    return null;
  }
}

class Demo {
  constructor() {
    this.main();
  }
  main() {
    // 获取shape工厂
    const shapeFactory = FactoryProducer.getFactory("shape");
    // 从shape工厂依次获取circle形状对象,square对象,rectangle对象
    const circle = shapeFactory.getShape("circle");
    const square = shapeFactory.getShape("square");
    const rectangle = shapeFactory.getShape("rectangle");
    circle.draw();
    square.draw();
    rectangle.draw();

    // 获取color工厂
    const colorFactory = FactoryProducer.getFactory("color");
    const red = colorFactory.getColor("red");
    const blue = colorFactory.getColor("blue");
    const green = colorFactory.getColor("green");
    red.fill();
    blue.fill();
    green.fill();
  }
}

new Demo();