Kotlin Advanced - Apalon Kotlin Sprint Part 3

Kirill Rozov
Senior Android Developer krl.rozov@gmail.com

Lazy Properties
class Address {
val id: Long = …
var name: String = …
var street: String = …
val fullInfo by lazy { "$id $name $street" }
}

Delegated properties
class Example {
var p: String by Delegates()
}

private class NotNullVar<T: Any>() : ReadWriteProperty<Any?, T> {
private var value: T? = null
public override fun getValue(thisRef: Any?, prop: KProperty<*>): T {
return value ?: throw IllegalStateException(…)
}
public override fun setValue(thisRef: Any?, prop: KProperty<*>, value: T) {
this.value = value
}
}

operator fun getValue(thisRef: Any?, prop: KProperty<*>): T {
return value ?: throw IllegalStateException(…)
}
operator fun setValue(thisRef: Any?, prop: KProperty<*>, value: T) {
this.value = value
}

Object declaration
object DataProviderManager {
fun registerDataProvider(provider: DataProvider) {
// ...
}
val allDataProviders: Collection<DataProvider>
get() = // ...
}

Object declaration
DataProviderManager.registerDataProvider(...)

Object expression
window.addMouseListener(object : MouseAdapter() {
override fun mouseClicked(e: MouseEvent) {
// ...
}
override fun mouseEntered(e: MouseEvent) {
// ...
}
})

High-Order Functions
fun <T> lock(lock: Lock, body: () -> T): T {
lock.lock()
try {
return body()
}
finally {
lock.unlock()
}
}

(Type1, Type2, …, TypeN) -> TypeOut

fun toBeSynchronized() {
sharedResource.operation()
}
val result = lock(lock, ::toBeSynchronized)

Lambdas
lock(lock, { sharedResource.operation() })

Lambdas
{ name1: Type1, …, nameN: TypeN -> … }

Lambdas
val sum = { x: Int, y: Int -> x + y }

Lambdas
val sum: (Int, Int) -> Int = { x, y -> x + y }

Lambdas
lock (lock) {
sharedResource.operation()
}

Lambdas
fun <T, R> List<T>.map(transform: (T) -> R): List<R>

Lambdas
ints.map { value -> value * 2 }

Lambdas
ints.map { it * 2 }

Inline functions
l.lock()
try {
foo()
}
finally {
l.unlock()
}

Inline functions
inline fun lock<T>(lock: Lock, body: () -> T): T {
// ...
}

Inline functions
lock(l) { foo() }

Inline functions
fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
var p = parent
while (p != null && !clazz.isInstance(p)) {
p = p.parent
}
return p as T?
}

Inline functions
treeNode.findParentOfType(MyTreeNode::class.java)

Inline functions
treeNode.findParentOfType(MyTreeNode::class.java)
treeNode.findParentOfType<MyTreeNode>()

Inline functions
fun <T> TreeNode.findParentOfType(clazz: Class<T>): T?

Inline functions
inline fun <T> TreeNode.findParentOfType(clazz: Class<T>): T?

Inline functions
inline fun <reified T> TreeNode.findParentOfType(clazz: Class<T>): T?

Inline functions
inline fun <reified T> TreeNode.findParentOfType(): T?

fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
var p = parent
while (p != null && !clazz.isInstance(p)) {
p = p.parent
}
return p as T?
}
Inline functions
inline fun <reified T> TreeNode.findParentOfType(): T? {
var p = parent
while (p != null && p !is T) {
p = p.parent
}
return p as T?
}

Other
• Function inﬁx notation

• Operators overloading

• Tail recursion optimizations

• Local functions

apply
inline fun <T> T.apply(block: T.() -> Unit): T {
block();
return this
}

apply
val args = Bundle(3)
args.putCharSequence(ARG_TITLE, title)
args.putCharSequence(ARG_MESSAGE, message)
args.putBoolean(ARG_CANCELABLE, cancelable)
val fragment = ProgressDialogFragment()
fragment.arguments = args

apply
val args = Bundle(3).apply {
putCharSequence(ARG_TITLE, title)
putCharSequence(ARG_MESSAGE, message)
putBoolean(ARG_CANCELABLE, cancelable)
}
fragment.arguments = args

apply
fragment.arguments = Bundle(3).apply {
}

apply
ProgressDialogFragment().apply {
arguments = Bundle(3).apply {
}
}

Functions
inline fun <T> T.apply(block: T.() -> Unit): T {
block();
return this
}
inline fun <T> T.also(block: (T) -> Unit): T {
block(this);
return this
}
inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
inline fun <T, R> T.let(block: (T) -> R): R = block(this)

also
ProgressDialogFragment().also { fragment ->
fragment.arguments = Bundle(3).also { args ->
}
}

let
Bundle(3).let { args ->
ProgressDialogFragment().apply { arguments = args }
}

Try-with-resource
val stream: InputStream = …
stream.use {
it.read()
}

@Deprecated
public annotation class Deprecated(
val message: String,
val replaceWith: ReplaceWith = ReplaceWith(""),
val level: DeprecationLevel = DeprecationLevel.WARNING
)
public annotation class ReplaceWith(
val expression: String, vararg val imports: String)
public enum class DeprecationLevel {
WARNING,ERROR,HIDDEN
}

Collections
devices.filter { it.cpu == "Qualcomm" }
.filter(Device::isLargeRamDevice)
.map { it.name }
.toList()

Collections
devices.asSequence()
.filter { it.cpu == "Qualcomm" }
.filter(Device::isLargeRamDevice)
.map { it.name }
.toList()

Common
• No ternary operator (?:)

• No static members

• No checked exception

• No “switch” operator

• Declaration of array type

• Arrays in Kotlin are invariant

• No primitive types

Generics
• No raw types

• Declaration-site & User-site variances instead of wildcards

• Only upper bound constraint

Classes
• All classes are final by default

• No fields

• All functions & properties are final by default

• Nested classes has no access to outer class by default

• Outer class has no access to inner class private members

• No anonymous classes

Visibility Modifiers
• “Visibility modifiers” instead of“Access modifiers”

• All members are public by default

• No “package private”

• New “internal” visibility modifier

Kotlin Advanced - Apalon Kotlin Sprint Part 3

Recommended

More Related Content

What's hot (20)

Similar to Kotlin Advanced - Apalon Kotlin Sprint Part 3 (20)

More from Kirill Rozov (20)

Kotlin Advanced - Apalon Kotlin Sprint Part 3