This tutorial assumes that all you know is Java, but you want to learn Kotlin.

Please note that the resources are in the wiki page.

A few things that are worth watching to know more about Kotlin.

• By me: Odd things to look out for when converting code to Kotlin

• By me: Code clean-up with Kotlin

• Android KTX source code: Github snapshot or AOSP (actively developed)

• Jake Wharton: Instrumentation Testing Robots

• How to Kotlin - from the Lead Kotlin Language Designer (Google I/O '18)

• Droidcon NYC 2018: Advanced Kotlin

• Google I/O 2017 - Jake Wharton / Christina Lee: Life is Great and Everything will be OK: Kotlin is here

https://www.reddit.com/r/androiddev/comments/77sl1c/devs_who_review_kotlin_regularly_what_are_things/dorsk3i/

• inverted argument order, no semi-colons, void vs Unit, Object vs Any?, fun

• interfaces with val, var and fun

• constructors, inheritance

• lateinit vars

• enum class

• annotation class

• final by default vs open

• for loops (in ranges, until)

• object for singleton

• statics via companion object, const val

• visibility in Kotlin (public by default, private, protected, internal)

• static nested class in Java vs inner class in Kotlin

• backticks for reserved keywords (Mockito.when, $) and import aliases

• is instead of instanceof, as and as? for casting

• creating anonymous implementations for classes/interfaces

• there is no condition ? true : false ternary operator

• arrayOf and arrayOfNulls and listOf and mutableListOf and linkedMapOf

• array literals in annotations (for vararg parameters)

• operator conventions (get() vs [], .equals() vs ==)

• there are no checked exceptions, try-with-resources as .use {}

• @Volatile and synchronized

• multiple generic bounds

• typed nullability, and null-safety operators (?., ?:)

• smart casting (and mutable vars gotcha)

• lateinit vars

• properties, backing fields

• string interpolation and """multiline escaped ${strings}"""

• data classes

• when keyword (and complex conditions, such as ranges)

• control statement as expression (assignment of when, return, ...)

• named arguments, default arguments

• vararg and the * spread operator

• interfaces and default implementation

• generics (<T: Blah>, in/out, and star projection <*>)

• lambda types, trailing lambdas

• method reference

• typealias

• lambdas with receivers

• extension functions, extension properties

• standard library functions - scoping functions: apply, let, also, run, with

• standard library functions - more utility functions: takeIf, takeUnless

• tailrec keyword

• inline functions (crossinline, noinline)

• *a glance at the Collections API (see API here)

• inline fun <reified T>

• sealed classes

• infix keyword

• tuples (to) and destructuring

• *extension operators (componentN)

• *property delegates (and built-in ones: lazy, observable/vetoable, by map for configurations via Map<String, Any?>)

• delegation by class

• *JVM annotations: @JvmOverloads, @JvmField, @JvmSuppressWildcards, @get: and @set: and @field:

• synthetic view accessors with kotlin android extensions

• @Parcelize data class with experimental kotlin android extensions

• things marked with * in the table of contents

• coroutines?

• channels?

• @DslMarker?

• multi-platform things: expect and actual?

Copyright 2018 Gabor Varadi

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.