Introduction to the Strategy Pattern in Kotlin

Introduction to the Strategy Pattern

Welcome to the lesson on the Strategy pattern, a key concept in Behavioral Design Patterns . In this unit, we explore behavioral design patterns that enable complex interactions between objects. Behavioral patterns focus on how objects interact and communicate with each other to distribute responsibilities. We will begin with the Strategy pattern, which helps object-oriented systems choose the appropriate algorithm at runtime.

What You Will Learn

By the end of this lesson, you will: Understand the concept of the Strategy pattern . Learn how to implement and use it in Kotlin . Recognize the benefits of using the Strategy pattern in software design.

Understanding and Implementing the Strategy Pattern

The Strategy pattern is a behavioral design pattern that allows you to define a family of algorithms, encapsulate each one in a separate class, and make them interchangeable within the context object. This encapsulation allows you to select and change the algorithm at runtime, providing flexibility and decoupling the client's code from the specific implementations of the algorithms. The pattern is particularly useful when you have multiple ways to perform a task and want to enable the dynamic selection of the algorithm based on the application's current state or user input. Let's look at a practical example involving different payment methods for a shopping cart. Here, the Strategy pattern allows us to switch between various payment methods — such as credit card and PayPal — dynamically during checkout. By defining a common interface for payment strategies and creating separate classes for each method, the ShoppingCart can easily switch between them at runtime, enhancing flexibility and maintainability.

Step 1: Define the Strategy Interface

First, we create an interface representing our payment method. Kotlin interface PaymentStrategy {fun pay(amount: Int)} Here, we define a PaymentStrategy interface with a single function, pay(amount: Int) . Any class implementing this interface will need to provide an implementation for the pay method, allowing that class's own payment logic to be used.

Join the 1M+ learners on CodeSignal

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

Now, let's create two concrete strategies: one for payments via credit card and another for PayPal.

Kotlin

class CreditCardStrategy(private val cardNumber: String) : PaymentStrategy {
    override fun pay(amount: Int) {
        println("Paid $amount using Credit Card: $cardNumber")
    }
}

The CreditCardStrategy class implements the PaymentStrategy interface and provides a specific implementation for the pay method. This class uses a credit card number, passed to its constructor, to process the payment.

Kotlin

class PayPalStrategy(private val email: String) : PaymentStrategy {
    override fun pay(amount: Int) {
        println("Paid $amount using PayPal: $email")
    }
}

The PayPalStrategy class also implements the PaymentStrategy interface but processes the payment using an email address. This example demonstrates how different concrete strategies can provide their specific implementations of the same method.

Kotlin

class ShoppingCart {
    private var strategy: PaymentStrategy? = null

    fun setPaymentStrategy(strategy: PaymentStrategy) {
        this.strategy = strategy
    }

    fun checkout(amount: Int) {
        strategy?.pay(amount) ?: println("No payment strategy set.")
    }
}

class ShoppingCart {
    private var strategy: PaymentStrategy? = null

    fun setPaymentStrategy(strategy: PaymentStrategy) {
        this.strategy = strategy
    }

    fun checkout(amount: Int) {
        strategy?.pay(amount) ?: println("No payment strategy set.")
    }
}

The ShoppingCart class uses a PaymentStrategy reference to process payments. By using the setPaymentStrategy method, the payment strategy can be changed at runtime. The checkout function ensures that a payment strategy is set before attempting to process a payment, providing a safety check before calling the pay method.

Finally, let's see how to use these classes together.

Kotlin

fun main() {
    val cart = ShoppingCart()

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

    cart.setPaymentStrategy(creditCard)
    cart.checkout(100)

    cart.setPaymentStrategy(payPal)
    cart.checkout(200)
}

// Expected Output:
// Paid 100 using Credit Card: 1234-5678-9876-5432
// Paid 200 using PayPal: user@example.com

fun main() {
    val cart = ShoppingCart()

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

    cart.setPaymentStrategy(creditCard)
    cart.checkout(100)

    cart.setPaymentStrategy(payPal)
    cart.checkout(200)
}

// Expected Output:
// Paid 100 using Credit Card: 1234-5678-9876-5432
// Paid 200 using PayPal: user@example.com

In the main function, we create a ShoppingCart instance and two payment strategies: CreditCardStrategy and PayPalStrategy. By changing the payment strategy at runtime with the setPaymentStrategy method, we demonstrate the flexibility of the Strategy pattern. We process two payments, first using the credit card strategy and then using the PayPal strategy.

The Strategy pattern provides flexibility and reusability in your code:

Flexibility: It allows the algorithm to be selected at runtime, enabling dynamic behavior changes.
Reusability: Individual algorithms are encapsulated in separate classes, making them reusable across different contexts.

This pattern follows the Open/Closed Principle, as new strategies can be introduced without modifying the existing code.

Now that you understand the Strategy pattern, it's time to dive into the practice section and apply what you've learned. This hands-on approach will reinforce your understanding and help you see how powerful and flexible the Strategy pattern can be. Let's get started!