Exploring the Abstract Factory Pattern in Scala

Introduction

Hello Scala enthusiast! Welcome back to another exciting journey into the world of design patterns, you're already midway through this course on Creational Patterns in Scala! 🎉 Already energized by the magic of the Factory Method Pattern you just learned about? We're going to extend that excitement today with an adventure into the Abstract Factory Pattern . This pattern is going to bring another level of flexibility, allowing you to create entire families of objects without getting tangled up in their specific classes. Let's dive in! 🚀

Understanding the Abstract Factory Pattern

The Abstract Factory Pattern is a creational design pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes . While the Factory Pattern that we discussed in the previous lesson focuses on creating a single type of object, the Abstract Factory Pattern takes this concept further by creating entire families of related objects. For example, imagine you're tasked with building a consistent user interface across different operating systems - where a traditional factory might only handle button creation, an Abstract Factory would manage the creation of buttons, checkboxes, and other UI elements that need to maintain a consistent style. This pattern is particularly useful when you need to ensure that a set of related objects work together seamlessly, maintaining consistency across your application. Let's see how it works in Scala!

Scenario Example

To understand this better, let's consider a scenario where you are developing a graphical user interface (GUI) toolkit : Your toolkit should support multiple operating systems, such as Windows and Mac . Each OS has its own set of UI components, like buttons and checkboxes . Using the Abstract Factory Pattern, you can define interfaces for these components and create their concrete implementations for each OS.

Step 1: Defining Abstract Product Interfaces

Before our factory can get going, we need to define the abstract product interfaces. Recall that, in Scala, we usually employ traits to achieve this, as traits allow us to define the behavior that all concrete products will implement. Scala // Abstract Product A trait Button: def paint(): Unit Here, Button is a trait specifying that all button implementations must provide the paint method. This means any button from our factory will have the expected behavior. Scala // Abstract Product B trait Checkbox: def paint(): Unit // Abstract Product B trait Checkbox: def paint(): Unit Similarly, Checkbox defines the contract for all checkbox components, ensuring that they also implement a paint method. With these traits, we've set a robust foundation for our application components. 🛠️

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Scala

// Abstract Product B
trait Checkbox:
  def paint(): Unit

Scala

// Concrete Product A1
class WinButton extends Button:
  def paint(): Unit =
    println("Rendering a button in a Windows style.")

// Concrete Product A2
class MacButton extends Button:
  def paint(): Unit =
    println("Rendering a button in a Mac style.")

// Concrete Product B1
class WinCheckbox extends Checkbox:
  def paint(): Unit =
    println("Rendering a checkbox in a Windows style.")

// Concrete Product B2
class MacCheckbox extends Checkbox:
  def paint(): Unit =
    println("Rendering a checkbox in a Mac style.")

// Concrete Product A1
class WinButton extends Button:
  def paint(): Unit =
    println("Rendering a button in a Windows style.")

// Concrete Product A2
class MacButton extends Button:
  def paint(): Unit =
    println("Rendering a button in a Mac style.")

// Concrete Product B1
class WinCheckbox extends Checkbox:
  def paint(): Unit =
    println("Rendering a checkbox in a Windows style.")

// Concrete Product B2
class MacCheckbox extends Checkbox:
  def paint(): Unit =
    println("Rendering a checkbox in a Mac style.")

Scala

// Abstract Factory
trait GUIFactory:
  def createButton(): Button
  def createCheckbox(): Checkbox

// Abstract Factory
trait GUIFactory:
  def createButton(): Button
  def createCheckbox(): Checkbox

Scala

// Concrete Factory 1
class WinFactory extends GUIFactory:
  def createButton(): Button = WinButton()
  def createCheckbox(): Checkbox = WinCheckbox()

// Concrete Factory 2
class MacFactory extends GUIFactory:
  def createButton(): Button = MacButton()
  def createCheckbox(): Checkbox = MacCheckbox()

// Concrete Factory 1
class WinFactory extends GUIFactory:
  def createButton(): Button = WinButton()
  def createCheckbox(): Checkbox = WinCheckbox()

// Concrete Factory 2
class MacFactory extends GUIFactory:
  def createButton(): Button = MacButton()
  def createCheckbox(): Checkbox = MacCheckbox()

Scala

class Application(factory: GUIFactory):
  private val button: Button = factory.createButton()
  private val checkbox: Checkbox = factory.createCheckbox()

  def paint(): Unit =
    button.paint()
    checkbox.paint()

class Application(factory: GUIFactory):
  private val button: Button = factory.createButton()
  private val checkbox: Checkbox = factory.createCheckbox()

  def paint(): Unit =
    button.paint()
    checkbox.paint()

Scala

@main def main(): Unit =
  val osType = "Windows" // Change to "Mac" to see Mac UI
  val factory: GUIFactory = osType match
    case "Windows" => WinFactory()
    case "Mac"     => MacFactory()
    case _         => throw new IllegalArgumentException("Unknown OS type")

  val app = Application(factory)
  app.paint()

@main def main(): Unit =
  val osType = "Windows" // Change to "Mac" to see Mac UI
  val factory: GUIFactory = osType match
    case "Windows" => WinFactory()
    case "Mac"     => MacFactory()
    case _         => throw new IllegalArgumentException("Unknown OS type")

  val app = Application(factory)
  app.paint()

Scala

// Concrete Product A1
class WinButton extends Button:
  def paint(): Unit =
    println("Rendering a button in a Windows style.")

// Concrete Product A2
class MacButton extends Button:
  def paint(): Unit =
    println("Rendering a button in a Mac style.")

// Concrete Product B1
class WinCheckbox extends Checkbox:
  def paint(): Unit =
    println("Rendering a checkbox in a Windows style.")

// Concrete Product B2
class MacCheckbox extends Checkbox:
  def paint(): Unit =
    println("Rendering a checkbox in a Mac style.")

Scala

// Abstract Factory
trait GUIFactory:
  def createButton(): Button
  def createCheckbox(): Checkbox

Scala

// Concrete Factory 1
class WinFactory extends GUIFactory:
  def createButton(): Button = WinButton()
  def createCheckbox(): Checkbox = WinCheckbox()

// Concrete Factory 2
class MacFactory extends GUIFactory:
  def createButton(): Button = MacButton()
  def createCheckbox(): Checkbox = MacCheckbox()

Scala

class Application(factory: GUIFactory):
  private val button: Button = factory.createButton()
  private val checkbox: Checkbox = factory.createCheckbox()

  def paint(): Unit =
    button.paint()
    checkbox.paint()

Scala

@main def main(): Unit =
  val osType = "Windows" // Change to "Mac" to see Mac UI
  val factory: GUIFactory = osType match
    case "Windows" => WinFactory()
    case "Mac"     => MacFactory()
    case _         => throw new IllegalArgumentException("Unknown OS type")

  val app = Application(factory)
  app.paint()

Introduction

Understanding the Abstract Factory Pattern

Scenario Example

Step 1: Defining Abstract Product Interfaces

Join the 1M+ learners on CodeSignal

Step 2: Creating Concrete Product Implementations

Step 3: Defining the Abstract Factory Interface

Step 4: Creating Concrete Factory Implementations

Step 5: Implementing the Client Code: Application Class

Step 6: Putting It All Together

Abstract Factory vs Factory Method: A Comparison

Conclusion