Introduction to the Strategy Pattern in Scala

Introduction

Welcome to another exciting chapter in our exploration of Behavioral Patterns in Scala! In our earlier lessons, we delved into the Command and Observer patterns, focusing on enhancing the way objects communicate and respond to changing states. In this lesson, we shift gears to the Strategy Pattern, a powerful design technique that allows for dynamism and flexibility in algorithm selection. This lesson will dissect the Strategy Pattern step-by-step and demonstrate its practical implementation using a clear, relatable example. Ready? 🔥

Understanding the Strategy Pattern

Imagine having a toolbox full of different gadgets, each perfect for a specific task. The Strategy Pattern allows a class to tap into this toolbox and choose the most suitable algorithm without altering its codebase. It's all about selecting the right strategy at runtime, providing flexibility and clean separation of concerns. Consider a scenario with a Shopping Cart class that handles payments via multiple channels like credit cards or PayPal. By employing the Strategy Pattern, each payment method can be encapsulated into distinct classes. The Shopping Cart can then swap these strategies effortlessly. The key components of the Strategy Pattern are: Strategy Trait: A trait defining a common interface for all strategies. Concrete Strategies: Specific case classes implementing the strategies. Context Class: A class that utilizes these strategies dynamically. Let's roll up our sleeves and integrate the Strategy Pattern into our shopping cart scenario!

Strategy Trait

Firstly, we define a trait that all payment strategy case classes will implement. This guarantees consistency across all payment methods, allowing them to be interchangeable. Scala // Define the trait for the payment strategy trait PaymentStrategy: def pay(amount: Int): Unit Here, the PaymentStrategy trait contains the pay method, and any class that extends this trait must provide a specific implementation for the pay method.

Concrete Strategies

Next, we implement concrete strategies that house different payment methods. We'll kick things off with the CreditCardStrategy : Scala // Implementation of the CreditCard strategy case class CreditCardStrategy(cardNumber: String) extends PaymentStrategy: def pay(amount: Int): Unit = println(s"Paid $$amount using Credit Card: $cardNumber") The CreditCardStrategy class extends PaymentStrategy and provides the pay method's logic to handle credit card transactions, requiring a card number during instantiation. Similarly, the PayPalStrategy class encapsulates the logic for PayPal transactions. It initializes with an email address. Scala // Implementation of the PayPal strategy case class PayPalStrategy(email: String) extends PaymentStrategy: def pay(amount: Int): Unit = println(s"Paid $$amount using PayPal: $email")

Join the 1M+ learners on CodeSignal

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

Scala

// Implementation of the CreditCard strategy
case class CreditCardStrategy(cardNumber: String) extends PaymentStrategy:
  def pay(amount: Int): Unit =
    println(s"Paid $$amount using Credit Card: $cardNumber")

Scala

// Implementation of the PayPal strategy
case class PayPalStrategy(email: String) extends PaymentStrategy:
  def pay(amount: Int): Unit =
    println(s"Paid $$amount using PayPal: $email")

Scala

// ShoppingCart class that uses a payment strategy
class ShoppingCart(strategy: Option[PaymentStrategy] = None):
  def setPaymentStrategy(strategy: PaymentStrategy): ShoppingCart =
    ShoppingCart(Some(strategy))

  def checkout(amount: Int): Unit =
    strategy match
      case Some(s) => s.pay(amount)
      case None    => println("No payment strategy set.")

// ShoppingCart class that uses a payment strategy
class ShoppingCart(strategy: Option[PaymentStrategy] = None):
  def setPaymentStrategy(strategy: PaymentStrategy): ShoppingCart =
    ShoppingCart(Some(strategy))

  def checkout(amount: Int): Unit =
    strategy match
      case Some(s) => s.pay(amount)
      case None    => println("No payment strategy set.")

Scala

@main def main(): Unit =
  val cart = ShoppingCart()

  // Create payment strategies
  val creditCard = CreditCardStrategy("1234-5678-9876-5432")
  val payPal = PayPalStrategy("user@example.com")

  // Use CreditCard strategy and checkout
  val cartWithCreditCard = cart.setPaymentStrategy(creditCard)
  cartWithCreditCard.checkout(100)
  // Output: Paid 100 using Credit Card: 1234-5678-9876-5432

  // Switch to PayPal strategy and checkout
  val cartWithPayPal = cart.setPaymentStrategy(payPal)
  cartWithPayPal.checkout(200)
  // Output: Paid 200 using PayPal: user@example.com

@main def main(): Unit =
  val cart = ShoppingCart()

  // Create payment strategies
  val creditCard = CreditCardStrategy("1234-5678-9876-5432")
  val payPal = PayPalStrategy("user@example.com")

  // Use CreditCard strategy and checkout
  val cartWithCreditCard = cart.setPaymentStrategy(creditCard)
  cartWithCreditCard.checkout(100)
  // Output: Paid 100 using Credit Card: 1234-5678-9876-5432

  // Switch to PayPal strategy and checkout
  val cartWithPayPal = cart.setPaymentStrategy(payPal)
  cartWithPayPal.checkout(200)
  // Output: Paid 200 using PayPal: user@example.com

Scala

// ShoppingCart class that uses a payment strategy
class ShoppingCart(strategy: Option[PaymentStrategy] = None):
  def setPaymentStrategy(strategy: PaymentStrategy): ShoppingCart =
    ShoppingCart(Some(strategy))

  def checkout(amount: Int): Unit =
    strategy match
      case Some(s) => s.pay(amount)
      case None    => println("No payment strategy set.")

Scala

@main def main(): Unit =
  val cart = ShoppingCart()

  // Create payment strategies
  val creditCard = CreditCardStrategy("1234-5678-9876-5432")
  val payPal = PayPalStrategy("user@example.com")

  // Use CreditCard strategy and checkout
  val cartWithCreditCard = cart.setPaymentStrategy(creditCard)
  cartWithCreditCard.checkout(100)
  // Output: Paid 100 using Credit Card: 1234-5678-9876-5432

  // Switch to PayPal strategy and checkout
  val cartWithPayPal = cart.setPaymentStrategy(payPal)
  cartWithPayPal.checkout(200)
  // Output: Paid 200 using PayPal: user@example.com

Introduction

Understanding the Strategy Pattern

Strategy Trait

Concrete Strategies

Join the 1M+ learners on CodeSignal

Context Class

Integration in the Main Program

Conclusion