Kotlin Technical Interview Questions

Question 1

How do you create a Singleton in Kotlin?

Answer 1

Use the “object” keyord (e.g. object someSingleton)

Question 2

How to initialize an array in Kotlin with values?

Answer 2

val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)

Question 3

What is a data class in Kotlin?

Answer 3

A class with the express purpose of holding data, with the following requirements:

• The primary constructor needs to have at least one parameter
• All primary constructor parameters need to be marked as val or var
• Data classes cannot be abstract, open, sealed, or inner

Question 4

What is the difference between var & val in Kotlin?

Answer 4

var - a general, mutable variable

val - like a final, immutable variable

Question 5

Where should val & var be used?

Answer 5

Use var where the a value is going to change frequently

Use val where there is no change in the value

Question 6

Explain the advantages of when vs. switch in Kotlin

Answer 6

• Has a better design
• More concise & powerful than a traditional switch
• Can be used either as an expression or as a statement
• usage examples:
  
  • 2 or more choices
  • “when” without arguments
  • Any type can be passed into when
  • Smart casting (via “is” comparator)
  • Ranges

Question 7

Explain the null safety in Kotlin

Answer 7

Kotlin’s type safety system is aimed at eliminating the danger of null references from code (aka the Billion Dollar Mistake). In Kotlin, the type system distinguishes between references that can hold null (nullable references) & those that cannot (non-null references)

Question 8

How is it recommended to create constants in Kotlin?

Answer 8

val MY_CONSTANT = “constant1”
const val MY_CONSTANT = “constant2”

The difference here is that while both are immutable (via val), the “const” keyword is used for variables that are known at compile-time.

Question 9

Why should you not use companion objects with constants?

Answer 9

It is a more expense call to instance methods (getters/setters) than calling static methods. Instead, use objects

Question 10

Can you use IntArray & Array in Kotlin interchangeably?

Answer 10

NO - Array is Integer[] under the hood, while IntArray is int[].

This means that when an Int is put into an Array, it will always be boxed, whereas with IntArray, no boxing will occur b/c it translates to a Java primitive array

Question 11

What are Coroutines in Kotlin?

Answer 11

Coroutines is a rich library that contains a number of high-level coroutine enabled primitives (like launch & async) & provides an API to write async code sequentially.

Coroutines act like light-weight threads that use predefined thread pools & smart scheduling & thus, doesn’t actually allocate new threads. Additionally, coroutines can be suspended & resumed mid-execution.

Question 12

What are the advantages of Kotlin over Java?

Answer 12

• Data Classes vastly reduce getter/setter setup code from Java
• Abstract vs. Open classes: Open class lets you make an inheritable class while also being usable itself
• Extension functions
• Null: Kotlin allows you to decide what can & can’t be null
• Singleton: object instead of a class
• Generics: Reified generics (actual usage of the type), in & out for covariance
• Named parameters for API back compatibility preservation
• Primary constructor: able to write constructor without any additional functions or extra declarations

Question 13

What is lateinit in Kotlin & when would you use it?

Answer 13

Lateinit - means late initialization; If you don’t want to initialize a variable in the constructor, you can instead initialize it later on (while guaranteeing that it’s initialized before you use it). It will not allocate memory until it’s initialized, however you cannot use lateinit for primitive types

Question 14

What are some useful cases for lateinit?

Answer 14

• Android: variables that get initialized in lifecycle methods
• Using Dagger for DI
• Setup for unittests
• Spring boot annotations

Question 15

What is the purpose of Companion Objects in Kotlin?

Answer 15

Since Kotlin doesn’t have static members/member functions, if you need to write a function that cal be called w/o having a class instance but needs access to the itnernals of a class, you can write it as a member of a companion object declaration inside a class.

The companion object is a Singleton, a proper object on its own, & can have its own supertypes

Question 16

What is the kotlin double-bang (!!) operator?

Answer 16

The double-bang operator is the not-null assertion operator - it converts any value to a non-null type & throws a KotlinNullPointerException if the value is null.

This operator should be used in cases where you need to 100% guarantee that a value is not null.

Question 17

What is the difference between const and val?

Answer 17

“const”s are compile-time constants & can never be assigned a function or class constructor - only String or primitives

“val”s are compiled/assigned at runtime & can be assigned primitives, functions, &/or class constructors

Question 18

What is the difference between open & public in Kotlin?

Answer 18

open - means open for extension; allows others to inherit from the class

public - default visibility modifier

Question 19

What is the difference between suspending and blocking?

Answer 19

Blocking - means that a call to any other function from the same thread will halt the parent’s execution. This also means that if a blocking call is made on the main thread, you effectively freeze the UI

Suspending - doesn’t necessarily block the parent function’s execution. If you call a suspending function in some thread, you can easily push that function to a different thread. In case it is a heavy operation, it won’t block the main thread. If the suspending function has to suspend, it will simply pause its execution, freeing up its thread for other work. Once it’s done suspending, it will get the next free thread from the pool to finish its work.

Question 20

What is the equivalent of Java static methods in Kotlin?

Answer 20

Using functions within a companion object for a class.

Question 21

When to use lateinit over lazy initialization in Kotlin?

Answer 21

Lateinit:

• If properties are mutable
• If properties are set externally (e.g. need to pass in some external value to set it)

Lazy:
- If they are only meant to be initialized once & shared by all, & it’s more internally set

Question 22

Compare lateinit vs Lazy in Kotlin

Answer 22

lateinit var:

• Can be intialized from anywhere the object is seen from
• Multiple initialization possible
• Non-thread safe
• Can only be used for var
• Not eligible for nonnull properties
• An isInitialized method added to check whether the value has been initialized before
• Not allowed on properties of primitive types

by lazy:

• Can only be initialized from the initializer lambda
• Only initialized a single time
• Thread-safe by default & guarantees that the initializer is invoked once
• Can only be used for val
• not eligible for nonnull properties
• Property never able to un-initialize
• Allowed on properties of primitive types.