{"id":12723,"date":"2015-11-14T16:24:00","date_gmt":"2015-11-14T15:24:00","guid":{"rendered":"https:\/\/touk.pl\/blog\/?guid=958dc4e03e732e9d451b558c1faf5fac"},"modified":"2022-08-03T12:48:48","modified_gmt":"2022-08-03T10:48:48","slug":"kotlins-extensions-for-each-class","status":"publish","type":"post","link":"https:\/\/touk.pl\/blog\/2015\/11\/14\/kotlins-extensions-for-each-class\/","title":{"rendered":"Kotlin’s extensions for each class"},"content":{"rendered":"

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<\/code>, toString<\/code> and hashCode<\/code> methods, but there is much more in Kotlin.<\/p>\n

Example classes<\/h2>\n

Let’s define some simple classes describing person: normal class and data class.<\/p>\n

class PersonJaxb {\r\n    var firstName: String? = null\r\n    var lastName: String? = null\r\n    var age: Int? = null\r\n}<\/pre>\n
data class Person(val firstName: String, val lastName: String, val age: Int)<\/p>\n
 <\/p>\n
Normal class extensions<\/h2>\n
All instances have methods described below.<\/p>\n
apply<\/code> method<\/h3>\n
I often work with jaxb classes similar to PersonJaxb<\/code>, which has not all arg constructor and all fields must be set via setters. Kotlin helps to deal with it via apply<\/code> method. Target instance is provided as delagate to closure so we could define all fields values in it and returns this<\/code>. The signature is T.apply(f: T.() -> Unit): T<\/code>.<\/p>\n
@Test\r\nfun applyTest() {\r\n    \/\/when\r\n    val person = PersonJaxb().apply {\r\n        firstName = \"John\"\r\n        lastName = \"Smith\"\r\n        age = 20\r\n    }<\/pre>\n
\/\/then
\nassertEquals(20, person.age)
\nassertEquals(“John”, person.firstName)
\nassertEquals(“Smith”, person.lastName)
\n}<\/p>\n
 <\/p>\n
let<\/code> method<\/h3>\n
Another extension is let<\/code> method which is similar to map operation for collections. It has signature T.let(f: (T) -> R): R<\/code>. this<\/code> is passed as parameter to given closure\/function.<\/p>\n
@Test\r\nfun letTest() {\r\n    \/\/when\r\n    val fullName = Person(\"John\", \"Smith\", 20).let {\r\n        \"${it.firstName} ${it.lastName}\"\r\n    }<\/pre>\n
\/\/then
\nassertEquals(“John Smith”, fullName)
\n}<\/p>\n
 <\/p>\n
run<\/code> method<\/h3>\n
run<\/code> method looks like merge of apply<\/code> and let<\/code> methods: access to this<\/code> is via delegate as in apply<\/code>, but it also returns value as in let<\/code> method. It has signature T.run(f: T.() -> R): R<\/code>.<\/p>\n
@Test\r\nfun runTest() {\r\n    \/\/when\r\n    val fullName = Person(\"John\", \"Smith\", 20).run {\r\n        \"$firstName $lastName\"\r\n    }<\/pre>\n
\/\/then
\nassertEquals(“John Smith”, fullName)
\n}<\/p>\n
 <\/p>\n
to<\/code> method<\/h3>\n
Each instance has also defined to<\/code> infix operator, which is used to create Pair<\/code>. Pairs is helpful to create map entries. It has signature A.to(that: B): Pair<A, B><\/code>.<\/p>\n
@Test\r\nfun toTest() {\r\n    \/\/when\r\n    val pair = Person(\"John\", \"Smith\", 20) to 5<\/pre>\n
\/\/then
\nassertEquals(Person(“John”, “Smith”, 20), pair.first)
\nassertEquals(5, pair.second)
\n}<\/p>\n
 <\/p>\n
Data class methods<\/h2>\n
Data class instances have also some other helpful methods (which are not extensions, but are generated for us).<\/p>\n
componentX<\/code> methods<\/h3>\n
Data class Person<\/code> has three fields and it has component method generated for each of them: component1<\/code> for firstName<\/code>, component2<\/code> for lastName<\/code> and component3<\/code> for age<\/code>.<\/p>\n
@Test\r\nfun componentsTest() {\r\n    \/\/when\r\n    val p = Person(\"John\", \"Smith\", 20)<\/pre>\n
\/\/then
\nassertEquals(“John”, p.component1())
\nassertEquals(“Smith”, p.component2())
\nassertEquals(20, p.component3())
\n}<\/p>\n
Why is it helpful? componentX<\/code> methods are used in extracting (similar to Scala case classes extracting mechanism), e. g.:<\/p>\n
@Test\r\nfun extractingTest() {\r\n    \/\/when\r\n    val (first, last, age) = Person(\"John\", \"Smith\", 20)<\/pre>\n
\/\/then
\nassertEquals(20, age)
\nassertEquals(“John”, first)
\nassertEquals(“Smith”, last)
\n}<\/p>\n
 <\/p>\n
copy<\/code> method<\/h3>\n
copy<\/code> method allows to create new instance based on current instance.<\/p>\n
@Test\r\nfun copyTest() {\r\n    \/\/when\r\n    val person = Person(\"John\", \"Smith\", 20).copy(lastName = \"Kowalski\", firstName = \"Jan\")<\/pre>\n
\/\/then
\nassertEquals(Person(“Jan”, “Kowalski”, 20), person)
\n}<\/p>\n
 <\/p>\n
Summary<\/h2>\n
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.<\/p>\n
Sources are available here<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"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 classesLet’s define some simple cl…\n","protected":false},"author":54,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11],"tags":[556],"class_list":{"0":"post-12723","1":"post","2":"type-post","3":"status-publish","4":"format-standard","6":"category-development-design","7":"tag-kotlin"},"_links":{"self":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts\/12723","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/users\/54"}],"replies":[{"embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/comments?post=12723"}],"version-history":[{"count":8,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts\/12723\/revisions"}],"predecessor-version":[{"id":14930,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts\/12723\/revisions\/14930"}],"wp:attachment":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/media?parent=12723"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/categories?post=12723"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/tags?post=12723"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}