Kotlin Delegated Properties: Reusing Getter/Setter Logic

Why it exists

Many properties follow common patterns: their value is expensive to compute and should be deferred, or changes to them need to trigger other logic. Writing this boilerplate for every property is repetitive and error-prone. Delegated properties offer a reusable, language-level solution to these common behaviors.

The mental model

Think of a delegated property as hiring a specialist. Your class defines a property (var name: String), but it uses the by keyword to hire a delegate to manage the details of getting and setting its value. The class doesn't need to know how the value is stored or calculated; it just trusts the delegate to handle it correctly.

How it works

The syntax var p: String by Delegate() tells the compiler to redirect all reads and writes of property p to a Delegate instance. Instead of a standard backing field, the compiler calls Delegate.getValue() for reads and Delegate.setValue() for writes. Any object can be a delegate as long as it provides these required operator functions.

When to use it

Delegated properties are ideal for implementing common patterns cleanly. Three key use cases are: first, lazy initialization with by lazy { ... }, where an expensive object is created only on its first use; second, observing changes with by Delegates.observable(), which runs a block of code after a property is modified, perfect for updating UI or logging; third, vetoing changes with by Delegates.vetoable(), which can validate a new value and prevent the assignment if it's invalid.

When not to use it

For simple properties that just store a value with no special logic, a standard property (val x = 10) is more direct and performant. Using delegation for every property adds unnecessary indirection and object allocation. Stick to standard properties unless you need reusable getter/setter behavior.

One canonical example

The most common delegate is lazy. It defers the execution of a code block until the property is first accessed, and caches the result for all subsequent calls.

val lazyValue: String by lazy {
println("computed!")

"Hello" }

println(lazyValue) // Prints "computed!" then "Hello" println(lazyValue) // Prints only "Hello"

The message "computed!" is printed only once, proving the initializer block ran only on the first access. This is a powerful way to improve performance by avoiding expensive work until it's truly needed.