工厂模式

工厂模式是一种创建型设计模式，它提供了一种创建对象的接口，但允许子类决定要实例化的类。工厂模式将对象的创建过程封装在一个单独的类或方法中，客户端通过调用这个类或方法来创建对象，而不直接使用 new 关键字。

工厂模式主要有三种变体：

简单工厂模式（Simple Factory Pattern）： 提供一个单独的工厂类，负责创建对象。客户端通过调用工厂类的静态方法或方法来创建对象。
工厂方法模式（Factory Method Pattern）： 定义一个创建对象的接口，但将实际的创建工作延迟到子类中。每个子类都可以实现这个接口以提供特定类型的对象。
抽象工厂模式（Abstract Factory Pattern）： 提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。

以下是一个简单的 JavaScript 示例，演示了简单工厂模式：

// 简单工厂
class CarFactory {
  createCar(type) {
    switch (type) {
      case 'Sedan':
        return new SedanCar();
      case 'SUV':
        return new SUVCar();
      default:
        throw new Error('Invalid car type.');
    }
  }
}

// 具体产品 - SedanCar
class SedanCar {
  drive() {
    console.log('Driving a sedan car.');
  }
}

// 具体产品 - SUVCar
class SUVCar {
  drive() {
    console.log('Driving an SUV car.');
  }
}

// 客户端代码
const factory = new CarFactory();

const sedan = factory.createCar('Sedan');
sedan.drive();
// Output: Driving a sedan car.

const suv = factory.createCar('SUV');
suv.drive();
// Output: Driving an SUV car.

在这个例子中，CarFactory 是简单工厂类，负责根据客户端请求创建不同类型的汽车对象。SedanCar 和 SUVCar 是具体产品类，它们实现了相同的接口。客户端通过简单工厂类来创建具体产品的实例。

工厂模式的优点包括封装了对象的创建过程，使得客户端代码与具体类的实现解耦。它提供了灵活性，允许在不修改客户端代码的情况下引入新的产品类型。

工厂方法模式（Factory Method Pattern）

工厂方法模式定义了一个创建对象的接口，但将实际的创建工作延迟到子类中。这样，每个子类都可以实现这个接口以提供特定类型的对象。

示例：

// 工厂方法接口
class CarFactory {
  createCar() {
    throw new Error('createCar method must be implemented by subclasses.');
  }
}

// 具体工厂 - SedanCarFactory
class SedanCarFactory extends CarFactory {
  createCar() {
    return new SedanCar();
  }
}

// 具体工厂 - SUVCarFactory
class SUVCarFactory extends CarFactory {
  createCar() {
    return new SUVCar();
  }
}

// 客户端代码
const sedanFactory = new SedanCarFactory();
const sedan = sedanFactory.createCar();
sedan.drive();
// Output: Driving a sedan car.

const suvFactory = new SUVCarFactory();
const suv = suvFactory.createCar();
suv.drive();
// Output: Driving an SUV car.

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。这种模式涉及一个接口，其中的每个方法负责创建某个产品的一部分。

示例：

// 抽象工厂接口
class CarFactory {
  createSedanCar() {
    throw new Error('createSedanCar method must be implemented by subclasses.');
  }

  createSUVCar() {
    throw new Error('createSUVCar method must be implemented by subclasses.');
  }
}

// 具体工厂 - ToyotaFactory
class ToyotaFactory extends CarFactory {
  createSedanCar() {
    return new ToyotaSedanCar();
  }

  createSUVCar() {
    return new ToyotaSUVCar();
  }
}

// 具体工厂 - HondaFactory
class HondaFactory extends CarFactory {
  createSedanCar() {
    return new HondaSedanCar();
  }

  createSUVCar() {
    return new HondaSUVCar();
  }
}

// 具体产品 - ToyotaSedanCar
class ToyotaSedanCar {
  drive() {
    console.log('Driving a Toyota sedan car.');
  }
}

// 具体产品 - ToyotaSUVCar
class ToyotaSUVCar {
  drive() {
    console.log('Driving a Toyota SUV car.');
  }
}

// 具体产品 - HondaSedanCar
class HondaSedanCar {
  drive() {
    console.log('Driving a Honda sedan car.');
  }
}

// 具体产品 - HondaSUVCar
class HondaSUVCar {
  drive() {
    console.log('Driving a Honda SUV car.');
  }
}

// 客户端代码
const toyotaFactory = new ToyotaFactory();
const toyotaSedan = toyotaFactory.createSedanCar();
toyotaSedan.drive();
// Output: Driving a Toyota sedan car.

const toyotaSUV = toyotaFactory.createSUVCar();
toyotaSUV.drive();
// Output: Driving a Toyota SUV car.

在抽象工厂模式中，CarFactory 是抽象工厂接口，定义了创建 Sedan 和 SUV 汽车的方法。具体的工厂类（ToyotaFactory 和 HondaFactory）实现了这个接口，并分别负责创建特定品牌的汽车。这样，客户端可以选择不同的工厂来生产不同品牌的汽车。

工厂模式

工厂方法模式（Factory Method Pattern）​

抽象工厂模式（Abstract Factory Pattern）​

工厂方法模式（Factory Method Pattern）

抽象工厂模式（Abstract Factory Pattern）