Introduction to the Strategy Pattern in Scala | CodeSignal Learn

Introduction to the Strategy Pattern in Scala | CodeSignal Learn

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")

Sign up

Join the 1M+ learners on CodeSignal

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

Context Class

In our scenario, the ShoppingCart takes the role of the context class, as it employs any designated payment strategy efficiently. This class references a PaymentStrategy and can switch strategies as needed. // 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.") The ShoppingCart class leverages a Scala Option to handle the possible absence of a strategy and uses pattern matching for its checkout method to determine which strategy to apply. This implementation also enforces immutability by returning a new ShoppingCart instance when setPaymentStrategy is called, aligning with best practices in Scala. By avoiding mutable state, we ensure that each ShoppingCart instance remains unmodified, promoting safer and more predictable code.

Integration in the Main Program

Finally, let's piece everything together in a main program that illustrates the combined operation of the ShoppingCart class and various payment strategies. @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 In this code snippet, we: Create a new ShoppingCart . Develop payment strategies for both credit cards and PayPal. Direct the cart to utilize the credit card strategy and proceed to checkout. Change the cart's strategy to PayPal and check out again. The ShoppingCart adeptly alternates between strategies without modifying its underlying logic, showcasing the essence of the Strategy Pattern.

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