Scala 中的工厂模式

工厂模式是一种常见的软件设计模式，它用于根据具体需求动态创建对象。在 Scala 中，我们可以使用多种方法实现工厂模式，以满足各种场景下的需求。

简单工厂模式

简单工厂模式是最基本的工厂模式，它通过一个工厂类来创建对象。下面是一个示例：

trait Product {
  def operation(): Unit
}

class ConcreteProductA extends Product {
  override def operation(): Unit = {
    println("ConcreteProductA operation")
  }
}

class ConcreteProductB extends Product {
  override def operation(): Unit = {
    println("ConcreteProductB operation")
  }
}

object SimpleFactory {
  def createProduct(productType: String): Product = {
    productType match {
      case "A" => new ConcreteProductA()
      case "B" => new ConcreteProductB()
      case _ => throw new RuntimeException("Invalid product type")
    }
  }
}

val productA = SimpleFactory.createProduct("A")
productA.operation() // 输出：ConcreteProductA operation

val productB = SimpleFactory.createProduct("B")
productB.operation() // 输出：ConcreteProductB operation

在上面的示例中，我们定义了一个 Product trait，然后有两个具体的产品类 ConcreteProductA 和 ConcreteProductB 实现了该 trait。同时，我们创建了一个简单工厂类 SimpleFactory，它根据传入的参数来创建相应的产品对象。通过调用简单工厂的 createProduct 方法，我们可以动态创建不同类型的产品对象。

工厂方法模式

工厂方法模式是一种更加灵活的工厂模式，它将具体产品的创建交给了具体的工厂类。下面是一个示例：

trait Product {
  def operation(): Unit
}

class ConcreteProductA extends Product {
  override def operation(): Unit = {
    println("ConcreteProductA operation")
  }
}

class ConcreteProductB extends Product {
  override def operation(): Unit = {
    println("ConcreteProductB operation")
  }
}

abstract class Factory {
  def createProduct(): Product
}

class ConcreteFactoryA extends Factory {
  override def createProduct(): Product = {
    new ConcreteProductA()
  }
}

class ConcreteFactoryB extends Factory {
  override def createProduct(): Product = {
    new ConcreteProductB()
  }
}

val factoryA = new ConcreteFactoryA()
val productA = factoryA.createProduct()
productA.operation() // 输出：ConcreteProductA operation

val factoryB = new ConcreteFactoryB()
val productB = factoryB.createProduct()
productB.operation() // 输出：ConcreteProductB operation

在上面的示例中，我们定义了一个 Product trait，然后有两个具体的产品类 ConcreteProductA 和 ConcreteProductB 实现了该 trait。接着，我们定义了一个抽象的工厂类 Factory，其中的 createProduct 方法是抽象的，具体的工厂类需要实现该方法来创建相应的产品对象。通过不同的工厂类，我们可以创建不同类型的产品对象。

抽象工厂模式

抽象工厂模式是一种更加抽象的工厂模式，它用于创建一系列相关或依赖的对象。下面是一个示例：

trait ProductA {
  def operation(): Unit
}

trait ProductB {
  def operation(): Unit
}

class ConcreteProductA1 extends ProductA {
  override def operation(): Unit = {
    println("ConcreteProductA1 operation")
  }
}

class ConcreteProductA2 extends ProductA {
  override def operation(): Unit = {
    println("ConcreteProductA2 operation")
  }
}

class ConcreteProductB1 extends ProductB {
  override def operation(): Unit = {
    println("ConcreteProductB1 operation")
  }
}

class ConcreteProductB2 extends ProductB {
  override def operation(): Unit = {
    println("ConcreteProductB2 operation")
  }
}

trait AbstractFactory {
  def createProductA(): ProductA
  def createProductB(): ProductB
}

class ConcreteFactory1 extends AbstractFactory {
  override def createProductA(): ProductA = {
    new ConcreteProductA1()
  }

  override def createProductB(): ProductB = {
    new ConcreteProductB1()
  }
}

class ConcreteFactory2 extends AbstractFactory {
  override def createProductA(): ProductA = {
    new ConcreteProductA2()
  }

  override def createProductB(): ProductB = {
    new ConcreteProductB2()
  }
}

val factory1 = new ConcreteFactory1()
val productA1 = factory1.createProductA()
val productB1 = factory1.createProductB()
productA1.operation() // 输出：ConcreteProductA1 operation
productB1.operation() // 输出：ConcreteProductB1 operation

val factory2 = new ConcreteFactory2()
val productA2 = factory2.createProductA()
val productB2 = factory2.createProductB()
productA2.operation() // 输出：ConcreteProductA2 operation
productB2.operation() // 输出：ConcreteProductB2 operation

在上面的示例中，我们定义了两个产品族 ProductA 和 ProductB，每个产品族有多个具体的产品类实现。然后，我们定义了一个抽象工厂类 AbstractFactory，其中的 createProductA 和 createProductB 方法是抽象的，具体的工厂类需要实现这些方法来创建相应的产品对象。通过不同的工厂类，我们可以创建不同产品族的产品对象。

以上就是 Scala 中的工厂模式的几种常见实现方法。根据具体的需求，选择适合的工厂模式可以提供更好的灵活性和扩展性。