// 定义不同类型的产品类 --- 具体产品
class ProductA {
  constructor() {
    this.type = "productA";
  }
  showInfo() { // 产品接口
    console.log(`我是${this.type}`);
  }
}

class ProductB {
  constructor() {
    this.type = "productB";
  }
  showInfo() {
    console.log(`我是${this.type}`);
  }
}

// 简单工厂函数 --- 工厂接口
function createProduct(type) {
  switch (type) { // 根据传入的参数返回具体的产品实例
    case "A":  // 具体工厂：switch 中的 case
      return new ProductA();
    case "B":
      return new ProductB();
    default:
      throw new Error("no this type");
  }
}

// 使用简单工厂创建对象
const productA = createProduct("A");
productA.showInfo(); // 输出：我是productA

const productB = createProduct("B");
productB.showInfo(); // 输出：我是productB

// 定义不同类型的产品类 --- 具体产品
class ProductA {
  constructor() {
    this.type = "productA";
  }
  showInfo() { // 产品接口
    console.log(`我是${this.type}`);
  }
}
class ProductB {
  constructor() {
    this.type = "productB";
  }
  showInfo() {
    console.log(`我是${this.type}`);
  }
}

// 抽象工厂类 --- 工厂接口Factory：定义了创建产品的接口(方法)，但本身不实现具体的逻辑
class Factory { 
    createProduct(){ // 定义一个抽象方法
        throw new Error('必须重写该方法！');
    }
}

// 具体工厂类 ConcreteFactoryA/B --- 具体工厂 --- 具体工厂子类
// 继承自抽象工厂类Factory的具体工厂类，实现createProduct方法以返回具体的产品实例
class ConcreteFactoryA extends Factory {
    createProduct() {
        return new ProductA();
    }
}
class ConcreteFactoryB extends Factory {
    createProduct() {
        return new ProductB();
    }
}

// 使用工厂方法创建对象
const factoryA = new ConcreteFactoryA();
const productA = factoryA.createProduct();
productA.showInfo(); // 输出: 我是productA

const factoryB = new ConcreteFactoryB();
const productB = factoryB.createProduct();
productB.showInfo(); // 输出: 我是productB

// 抽象产品类A
class AbstractProductA {
  use(){ // 创建产品接口，但本身不实现具体逻辑
    throw new Error('抽象产品A的use方法必须被重写')
  }
}
// 具体产品A1 --- 具体产品
class ProductA1 extends AbstractProductA {
  use(){ // 实现产品接口
    console.log('使用产品A1')
  }
}
class ProductA2 extends AbstractProductA {
  use(){
    console.log('使用产品A2')
  }
}


// 抽象产品类B --- 具体产品
class AbstractProductB {
  operate(){ // 创建产品接口但本身不实现
    throw new Error('抽象产品B的use方法必须被重写')
  }
}
// 具体产品B1
class ProductB1 extends AbstractProductB {
  operate(){ // 实现产品接口
    console.log('使用产品B1')
  }
}
class ProductB2 extends AbstractProductB {
  operate(){
    console.log('使用产品B2')
  }
}


// 抽象工厂类  --- 工厂接口
class AbstractFactory {
  createProductA(){ // 定义创建产品A 和产品B 的抽象方法
    throw new Error('抽象工厂类createProductA方法必须被重写')
  }
  createProductB(){
    throw new Error('抽象工厂类createProductB方法必须被重写')
  }
}
// 具体工厂子类1 --- 具体工厂 ConCreteFactory1/2 分别实现产品A/B，创建不同的产品族
class ConcreteFactory1 extends AbstractFactory {
  createProductA(){
    return new ProductA1()
  }
  createProductB(){
    return new ProductB1()
  }
}
// 具体工厂子类2
class ConcreteFactory2 extends AbstractFactory {
  createProductA(){
    return new ProductA2()
  }
  createProductB(){
    return new ProductB2()
  }
}


// 使用抽象工厂创建对象
const factory1 = new ConcreteFactory1()
const productA1 = factory1.createProductA()
const productB1 = factory1.createProductB()
productA1.use() // 输出：使用产品A1
productB1.operate() // 输出：使用产品B1

const factory2 = new ConcreteFactory2()
const productA2 = factory2.createProductA()
const productB2 = factory2.createProductB()
productA2.use() // 输出：使用产品A2
productB2.operate() // 输出：使用产品B2