Kotlin for Android Developers

24.2 Delegation
The
delegation pattern²⁶
is a really useful pattern that can be used to extract responsibilities from a
class. The delegation pattern is supported natively by Kotlin, so it prevents from the need of calling
the delegate. The delegator just needs to specify which instance implements the interface.
In our previous example, we can specify how the animal flies through the constructor, instead of
implementing it. For instance, a flying animal that uses wings to fly can be specified this way:
1
interface CanFly {
2
fun fly()
3
}
4
5
class Bird(f: CanFly) : CanFly by f
We can indicate that a bird can fly by using the interface, but the way the bird uses to fly is defined
through a delegate that is defined in the constructor, so we can have different birds with different
flying methods. The way an animal with wings flies is defined in another class:
²⁶
https://en.wikipedia.org/wiki/Delegation_pattern

---

24 Interfaces and Delegation
114
1
class AnimalWithWings : CanFly {
2
val wings: Wings = Wings()
3
override fun fly() = wings.move()
4
}
An animal with wings moves its wings to be able to fly. So now we can create a bird that flies using
wings:
1
val birdWithWings = Bird(AnimalWithWings())
2
birdWithWings.fly()
But now wings can be used with another animals that are not birds. If we assume that bats always
use wings, we could instantiate the object directly where we specify the delegation:
1
class Bat : CanFly by AnimalWithWings()
2
...
3
val bat = Bat()
4
bat.fly()