SWPatterns.com

Facade - Kotlin

The Facade pattern provides a simplified interface to a complex subsystem. It defines a high-level interface that hides the intricacies of the underlying components. This makes the subsystem easier to use for clients who don’t need to know the details.

The Kotlin code demonstrates a Computer facade that …

Decorator - Kotlin

The Decorator pattern dynamically adds responsibilities to an object. It provides a flexible alternative to subclassing for extending functionality. Instead of inheriting from a base class to add behavior, you “wrap” the original object with decorator classes, each adding a specific responsibility. This …

Composite - Kotlin

The Composite pattern allows you to treat individual objects and compositions of objects uniformly. It defines a tree-like structure where each node can be either a leaf (representing a simple object) or a composite (representing a collection of objects). This enables operations to be performed on entire structures …

Bridge - Kotlin

The Bridge pattern is a structural design pattern that lets you split one or several interfaces from their implementation(s), allowing you to vary them independently. It’s beneficial when you have a class that can be configured with different abstractions or implementations without causing tight coupling.

This …

Adapter - Kotlin

The Adapter pattern converts the interface of a class into another interface clients expect. It lets classes work together that couldn’t otherwise because of incompatible interfaces. This implementation uses Kotlin’s interface delegation and object expressions to adapt a LegacyPrinter class (providing a specific …

Service Locator - Kotlin

The Service Locator pattern provides a centralized way to obtain dependencies (services) without tightly coupling a client to concrete implementations. Instead of injecting dependencies directly, clients ask a central “locator” for the service they need, identified by a key or name. This allows for …

Dependency Injection - Kotlin

The Dependency Injection (DI) pattern decouples classes from their dependencies, promoting modularity, testability, and maintainability. Instead of a component creating its own dependencies, they are provided to it from an external source. This implementation uses Kotlin’s constructor injection, a common and …

Lazy Initialization - Kotlin

The Lazy Initialization pattern delays the creation of an object until it’s actually needed. This improves performance when object creation is expensive and the object isn’t always used. Kotlin provides built-in support for lazy initialization using the lazy delegate. The code defines a ReportGenerator …

Object Pool - Kotlin

The Object Pool pattern manages a pool of reusable objects to reduce the overhead of frequent object creation and destruction. This is particularly useful for expensive-to-create objects. The pattern involves a pool that holds available objects, and clients request objects from the pool instead of creating new ones. …

Multiton - Kotlin

The Multiton pattern ensures that only a fixed number of instances of a class can exist. It’s a variation of the Singleton pattern, where rather than a single instance, you allow a limited, pre-defined number. This can be useful for managing resources like database connections or limited-license software access. …