SWPatterns.com

Memento - Kotlin

The Memento pattern is a behavioral pattern that allows you to capture and externalize the internal state of an object without violating encapsulation. It’s often used for implementing undo/redo functionality. A Memento object holds a snapshot of the object’s state. The Originator creates mementos and …

Mediator - Kotlin

The Mediator pattern defines an object that encapsulates how a set of objects interact. It promotes loose coupling by preventing objects from referring to each other explicitly, and instead letting them communicate through the mediator. This reduces dependencies and increases reusability.

This Kotlin example models a …

Iterator - Kotlin

The Iterator pattern provides a way to access the elements of an aggregate object sequentially without exposing the underlying representation. It defines a standard interface for creating iterators, allowing clients to traverse a collection without knowing its specific implementation. This promotes loose coupling and …

Interpreter - Kotlin

The Interpreter pattern defines a way to evaluate a language, defined by a grammar, using classes to represent the grammar’s rules. This example demonstrates interpreting simple arithmetic expressions with addition and subtraction. It defines abstract classes for Expression and implements concrete classes for Number …

Command - Kotlin

The Command pattern encapsulates a request as an object, allowing parameterization of clients with different requests, queuing or logging of requests, and support for undoable operations. This implementation features a Command interface defining an execute() method. Concrete commands like OpenCommand and CloseCommand …

Chain of Responsibility - Kotlin

The Chain of Responsibility is a behavioral pattern that allows you to pass a request along a chain of handlers. Each handler decides either to process the request or to pass it to the next handler in the chain. This decouples the sender of a request from its receivers, giving multiple objects the opportunity to handle …

Extension Object - Kotlin

The Extension Object pattern allows you to add new behavior to an existing class without modifying its source code, using a separate “extension” object. This is achieved by having the extension object hold an instance of the original class and delegate method calls to it, potentially adding pre- or …

Module - Kotlin

The Module pattern creates an isolated execution scope, encapsulating internal state and exposing a public API. This prevents global namespace pollution and allows for better organization and maintainability. In Kotlin, this is naturally achieved using object declarations, which are singletons with a defined interface. …

Proxy - Kotlin

The Proxy pattern provides a surrogate or placeholder for another object to control access to it. It’s useful for adding functionality like access control, lazy initialization, or logging without modifying the original object. This Kotlin example uses an interface for the real subject (RealImage) and a proxy ( …

Flyweight - Kotlin

The Flyweight pattern aims to minimize memory usage by sharing objects that are similar. It separates the object’s state into intrinsic (shared) and extrinsic (unique) parts. Intrinsic state is stored in the flyweight object, while extrinsic state is passed as a parameter when the flyweight is used. This example …