@JvmStatic (Kotlin can also generate static methods for functions defined in named objects or companion objects if you annotate those functions as @JvmStatic. If you use this annotation, the compiler will generate both a static method in the enclosing class of the object and an instance method in the object itself.)
Sealed classes (A sealed class can have subclasses, but all of them must be declared in the same file as the sealed class itself. Note that classes which extend subclasses of a sealed class (indirect inheritors) can be placed anywhere, not necessarily in the same file. The key benefit of using sealed classes comes into play when you use them in a when expression. If it's possible to verify that the statement covers all cases, you don't need to add an else clause to the statement.)
Inline functions (NOINLINE:In case you want only some of the lambdas passed to an inline function to be inlined, you can mark some of your function parameters with the noinline modifier. CROSSINLINE: some inline functions may call the lambdas passed to them as parameters not directly from the function body, but from another execution context, such as a local object or a nested function. In such cases, non-local control flow is also not allowed in the lambdas. To indicate that, the lambda parameter needs to be marked with the crossinline modifier. REIFIED: позволяет не передовать дополнительный параметр типа Class для использования операторв is, as, а использовать для этого сам тип Т.)
Extension functions (Extensions are resolved statically, Nullable receiver, Extension properties)
Null-safety (!!, ?, ?:, as?)
Smart casts (In many cases, one does not need to use explicit cast operators in Kotlin, because the compiler tracks the is-checks and explicit casts for immutable values and inserts (safe) casts automatically when needed.)
String templates (String literals may contain template expressions, i.e. pieces of code that are evaluated and whose results are concatenated into the string. A template expression starts with a dollar sign ($) and consists of either a simple name.)
Properties (get, set, val, var, const, lateinit)
Primary constructors
Delegation (The Delegation pattern has proven to be a good alternative to implementation inheritance, and Kotlin supports it natively requiring zero boilerplate code. A class Derived can implement an interface Base by delegating all of its public members to a specified object. The by-clause in the supertype list for Derived indicates that b will be stored internally in objects of Derived and the compiler will generate all the methods of Base that forward to b.)
Type inference for variable and property types
Singletons (object declarations are initialized lazily, when accessed for the first time.
A companion object is initialized when the corresponding class is loaded (resolved), matching the semantics of a Java static initializer.)
Declaration-site variance & Type projections (in, out, *)
Range expressions (1..10)
Operator overloading(operator fun)
Companion objects
Data classes(equals(), hashCode(),
toString() of the form "User(name=John, age=42)",
componentN() functions corresponding to the properties in their order of declaration,
copy())
Separate interfaces for read-only and mutable collections
Coroutines
Scope functions
also (It'll return the object it was invoked on, which makes it handy when we want to generate some side logic on a call chain.)
aply (Apply is just like also, but with an implicit this)
let (Simply put, a transformation function takes a source of one type and returns a target of another type.)
run (Run is just like let, but with an implicit this)
with (It's like run in that it has an implicit this, but it's not an extension method.)
Coroutines
Launch: start a coroutine in the background and keep working.
Async: perform an asynchronous operation and return a deferred object. We can call await on the deferred value in order to wait and get the result.
RunBlocking: this blocks the current thread and waits for the coroutine to finish execution.
Dispatchers: Default(It uses a common pool of shared background threads), IO(uses a shared pool of on-demand created threads and is designed for offloading of IO-intensive blocking operations), Unconfined