Extensions in Kotlin are very powerful mechanism. It allows for add any method to any of existing classes. Each instance has (as in Java)
equals
,
toString
and
hashCode
methods, but there is much more in Kotlin.
Example classes
Let's define some simple classes describing person: normal class and data class.
class PersonJaxb {
var firstName: String? = null
var lastName: String? = null
var age: Int? = null
}
data class Person(val firstName: String, val lastName: String, val age: Int)
Normal class extensions
All instances have methods described below.
apply
method
I often work with jaxb classes similar to
PersonJaxb
, which has not all arg constructor and all fields must be set via setters. Kotlin helps to deal with it via
apply
method. Target instance is provided as delagate to closure so we could define all fields values in it and returns
this
. The signature is
T.apply(f: T.() -> Unit): T
.
@Test
fun applyTest() {
//when
val person = PersonJaxb().apply {
firstName = "John"
lastName = "Smith"
age = 20
}
//then
assertEquals(20, person.age)
assertEquals("John", person.firstName)
assertEquals("Smith", person.lastName)
}
let
method
Another extension is
let
method which is similar to map operation for collections. It has signature
T.let(f: (T) -> R): R
.
this
is passed as parameter to given closure/function.
@Test
fun letTest() {
//when
val fullName = Person("John", "Smith", 20).let {
"${it.firstName} ${it.lastName}"
}
//then
assertEquals("John Smith", fullName)
}
run
method
run
method looks like merge of
apply
and
let
methods: access to
this
is via delegate as in
apply
, but it also returns value as in
let
method. It has signature
T.run(f: T.() -> R): R
.
@Test
fun runTest() {
//when
val fullName = Person("John", "Smith", 20).run {
"$firstName $lastName"
}
//then
assertEquals("John Smith", fullName)
}
to
method
Each instance has also defined
to
infix operator, which is used to create
Pair
. Pairs is helpful to create map entries. It has signature
A.to(that: B): Pair<A, B>
.
@Test
fun toTest() {
//when
val pair = Person("John", "Smith", 20) to 5
//then
assertEquals(Person("John", "Smith", 20), pair.first)
assertEquals(5, pair.second)
}
Data class methods
Data class instances have also some other helpful methods (which are not extensions, but are generated for us).
componentX
methods
Data class
Person
has three fields and it has component method generated for each of them:
component1
for
firstName
,
component2
for
lastName
and
component3
for
age
.
@Test
fun componentsTest() {
//when
val p = Person("John", "Smith", 20)
//then
assertEquals("John", p.component1())
assertEquals("Smith", p.component2())
assertEquals(20, p.component3())
}
Why is it helpful?
componentX
methods are used in extracting (similar to Scala case classes extracting mechanism), e. g.:
@Test
fun extractingTest() {
//when
val (first, last, age) = Person("John", "Smith", 20)
//then
assertEquals(20, age)
assertEquals("John", first)
assertEquals("Smith", last)
}
copy
method
copy
method allows to create new instance based on current instance.
@Test
fun copyTest() {
//when
val person = Person("John", "Smith", 20).copy(lastName = "Kowalski", firstName = "Jan")
//then
assertEquals(Person("Jan", "Kowalski", 20), person)
}
Summary
Kotlin's extensions for each instances are very simple and help to solve many problems. The code written with these extensions is much more readable and concise than written in Java.
Sources are available
here.