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

Kotlin

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

Kotlin

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

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

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

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

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

Kotlin

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

Kotlin

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

Introduction to the Strategy Pattern

What You Will Learn

Understanding and Implementing the Strategy Pattern

Step 1: Define the Strategy Interface

Join the 1M+ learners on CodeSignal

Step 2: Implement Concrete Strategy Classes

Step 3: Create the Context Class

Step 4: Using the Strategy Pattern in Practice

Why the Strategy Pattern is Important