Kotlin on Aamer Paul

Strategy Pattern in Action

Sat, 02 Aug 2025 08:53:20 +0530

Strategy Pattern is a behavioral design pattern that enables selecting an algorithm’s behavior at runtime.

It’s widely used and very flexible, perfect for cases where you want to avoid complex if-else or switch statements.

Use cases

You want to replace conditionals (if-else or switch) with polymorphism.
You need to switch behavior at runtime or make it configurable. Example: User selecting payment option
You want to define multiple ways of doing something (e.g., sorting, compression, payment).

Core Concepts

The pattern consists of three main components:

Builder Design Pattern

Mon, 28 Jul 2025 18:30:20 +0530

The Builder Design Pattern is a creational design pattern that lets you construct complex objects step by step. Using Builder pattern you can use same construction process to can create different representations.

Use case

Use the Builder Pattern when:

An object has many optional fields or configurations.
You want to avoid constructor telescoping (i.e., too many overloaded constructors).
You need to create immutable objects step by step.

public class User {
    private String firstName;
    private String lastName;
    private int age;
    private String email;
    private String phone;

    public User(String firstName, String lastName) { ... }
    public User(String firstName, String lastName, int age) { ... }
    public User(String firstName, String lastName, int age, String email) { ... }

    // ...
}

In above example, you can see User class is hard to maintain and read.

Factory and Abstract Factory Design Pattern

Sun, 27 Jul 2025 10:51:59 +0530

Factory Design Pattern

Factory Pattern is creational pattern that delegate the instantiation of objects to a separate method or class.

The Factory design pattern provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that’ll be created. This pattern helps to decouple the client code from the concrete classes it needs to instantiate.

Core Components

The Factory pattern has three main components: