Kotlin-References

Language Specific Features

No new keyword for instantiaing objects : val x = Person("Arpan")

Pair can be used to assign two variables at a time :

val(d: String, c: Person) = {
	if(x<10) Pair("Arpan", Person("x"))
	else Pair("ARPAN", Person("y"))
}

We can omit the type of a variable if it can be inferred from the context. But kotlin is a statically typed language, every expression has a type.

We can use when instead of if :

val(d: String, c: Person) = when {
	x<10 -> Pair("Arpan", Person("x"))
	else -> Pair("ARPAN", Person("y"))
}

Functions can be defined at the top level, i.e at the package level.
main function can be written with without any arguments unlike java.
if can be used as an expression and it's result can be assigned to a variable.

Difference between var and val

var : var is like general variable and it's known as a mutable variable in kotlin and can be assigned multiple times.
val : val is like Final variable and it's known as immutable in kotlin and can be initialized only single time.

Note : Function parameters can only be val(not to be mentioned explicitly). Previously mutable parameters were allowed to be used in functions, but in the latest version of Kotlin, the support is removed.

Lateinit and Lazy

Using lateinit, the initial value does not need to be assigned. But, it needs to be assigned before we use it. Using it unassigned will lead to NPE.

A property defined via by lazy is initialized using the supplied lambda upon first use, unless a value had been previously assigned. Example : val nameTextView by lazy { view!!.findViewById(R.id.nameTextView) }

When to Use Lazy or Lateinit

Lazy is a good fit for properties that may or may not be accessed. If we never access them, we avoid computing their initial value. They may work for Activities, as long as they are not accessed before setContentView is called. They are not a great fit for referencing views in a Fragment, because the common pattern of configuring views inside onCreateView would cause a crash. They can be used if view configuration is done in onViewCreated.

With Activities or Fragments, it makes more sense to use lateinit for their properties, especially the ones referencing views. While we don’t control the lifecycle, we know when those properties will be properly initialized. The downside is we have to ensure they are initialized in the appropriate lifecycle methods.

Objects and Companion Objects

Objects are used to define singletons in Kotlin i.e a class that has only one instance. We use the object keyword to declare the singleton instead of the class keyword.

object CarFactory {
    val cars = mutableListOf<Car>()
    
    fun makeCar(horsepowers: Int): Car {
        val car = Car(horsepowers)
        cars.add(car)
        return car
    }
}

Companion Objects are useful when we want some static methods or data members. Declaring such methods and variables in a companion object allows us to use those as static ones from directly the class without instantiating any object for it.

class Car(val horsepowers: Int) {
    companion object Factory {
        val cars = mutableListOf<Car>()

        fun makeCar(horsepowers: Int): Car {
            val car = Car(horsepowers)
            cars.add(car)
            return car
        }
    }
}

Useful Kotlin Libraries