10 Kotlin interview questions for 2025

Kotlin is a general-purpose, high-level, open-source programming language that supports both object-oriented and functional programming styles. Its first stable release was in 2016. Though it mainly targets Java virtual machines, its code can also be compiled into JavaScript or native code. In 2019, it was announced as the preferred language for Android developers by Google. It’s a cross-platform and statically typed language with more concise and expressive syntax compared to Java. It’s also used for server-side development, web development (with frameworks like Ktor), desktop applications, and more.

In this blog, we’ll discuss the ten most commonly asked interview questions in Kotlin.

Target audience#

This blog will be helpful to anyone who wants to learn Kotlin and start their career as Android developer, Java developer, cross-platform developer, web developer, and anyone interested in modern, concise, and safe programming language. With the passage of time Kotlin’s popularity is growing especially in the Android ecosystem which makes it a valuable skill for developers looking to stay relevant in the industry.

1. What is a data class in Kotlin?#

A data class is a special type of class that is primarily used to hold data. They are concise and facilitate the creation of immutable objectsImmutable objects are objects whose state cannot be changed once they have been created. for representing data in a straightforward and efficient manner. They are often utilized for modeling simple data structures, such as data transfer objects (DTOs) in database applications. The main purpose of creating data classes is to minimize boilerplate code and improve readability, thereby enhancing the developer’s productivity when working with data-centric classes. It is designed to automatically generate standard methods such as equals(), hashCode(), toString(), and copy(), based on the properties defined within the class. A sample data class is provided below for reference.

Code explanation#

• Line 2: The keyword data is used to create a data class. The name of the data class is Student, while name and age are the properties of the class. It should be noted that the primary constructor needs to have at least one parameter and the data class cannot be abstract, open, sealed, or inner.

• Line 3: We create the object of the Student class.

• Line 4: We print the name of the student object we created.

2. How many object types does Kotlin support?#

Kotlin has built-in object types of Number (to store integer or floating point values), Character (to store a unicode character), String (to store a sequence of characters), Boolean (to store true of false value), and Array (to store a fixed-size collection of elements of the same type). Let’s discuss these types in more detail below.

Number#

This data type can be used to store integer values or floating point values. It is further divided into the following types.

• Signed integers: These include Byte (8-bit), Short (16-bit), Int (32-bit), and Long (64-bit).

• Floating-point numbers: These include Float (32-bit) and Double (64-bit).

Let’s have a look at a working example of the above-mentioned data types.

Note: We have assigned the maximum values to Byte and Short data types. Try increasing the value by 1 to see if you get an error.

Code explanation#

• Lines 2–7: We declare variables of type Byte, Short, Int, Long, Float, and Double respectively.

• Lines 10–15: We print the values of the variables.

Character#

It can store a single 16-bit Unicode character. Let’s have a look at a working example of the Char data type below.

Code explanation#

• Line 2: We declare a character variable named letter.

• Line 3: We assign the value A to our variable letter.

• Line 4: We print the character.

String#

It can store a sequence of characters. Note that the strings in Kotlin are immutable, meaning their values cannot be changed after they are created. There are two kinds of strings available in Kotlin:

• Escaped string: It is declared within double quotes (" ") and may contain any escape characters. They are used for regular string literals where we need to escape special characters or include expressions using string interpolation.

• Raw string: It is declared within triple quotes (""" """) and may contain multiple lines of text without any escape characters. They are used when we want to have multiline strings without the need for escape characters. For long strings that span multiple lines, such as multi-line comments or large blocks of text.

Let’s have a look at a working example of both strings.

Note: Try adding an escape sequence of \n in the raw string and see the result.

Code explanation#

• Line 2: We declare an escaped string with an escaped character `\n`.

• Line 3: We declare a raw string with multi-line text.

• Lines 7–8: We print both the strings.

Boolean#

It can store either true or false. Let’s have a look at a working example of the Boolean data type below. The most common use of boolean types is in control structures like if, when, and loops (while, do-while, for) to make decisions based on whether a condition is true or false. Additionally, functions can return boolean values to indicate success, failure, or the result of a condition.

Code explanation#

• Line 2: We declare a boolean variable named myBool.

• Line 3: We print the value of the boolean variable.

Array#

It is a fixed-size collection of elements of the same type. In Kotlin they are mutable, and their size cannot be changed after creation.  Let’s have a look at a working example of the Array data type below. The array is used when the number of elements is known and won’t change frequently. We also use them to pass data between different parts of a program or represent grids, tables, or any structure with rows and columns.

Code explanation#

• Line 2: We declare an integer array named myIntArray with five elements.

• Line 3: We declare a string array named myStringArray with four elements.

• Lines 4–5: We print the elements at the first index for the integer array and the second index for the string array.

3. What is the difference between var and val in Kotlin?#

In Kotlin, var and val are used to declare variables, but they have different characteristics:

The var keyword#

Using var we can declare a mutable variable whose value can be changed after it is initialized. We can reassign values to variables declared with var. It is useful for variables whose values are determined based on runtime conditions.

The val keyword#

Using val we can declare an immutable variable, meaning its value cannot be changed after it is initialized. Once initialized, we cannot reassign values to variables declared with it. Kindly note that because it can be initialized with the value of a variable, an immutable variable is not a constant. We should use it for constants, such as mathematical constants (PI, E) or configuration values. Its usage also helps to prevent accidental reassignments, making code safer and easier to reason about. It also improves thread safety in concurrent programming because once initialized, val cannot change, reducing potential race conditions.

The difference between val and const is that val is evaluated at runtime, whereas, const values are fixed at compile time. So using val is suitable for values that are not compile-time constants but whose value should not change once assigned.

Let’s have a look at a working example of both variable types.

Note: Try uncommenting the code on line 5 and see what will be the output.

Code explanation#

• Line 2: We declare a mutable variable named a and assign it a value of 10.

• Line 3: We reassign the value to our mutable variable.

• Line 4: We declare an immutable variable named b and assign it a value of 5.

• Lines 7–8: We print the values of both the variables.

4. How to create a singleton class in Kotlin?#

Creating a singleton class in Kotlin is very simple. We just need to use the object keyword and we are done. The object class can have functions, properties, and the init method. However, we cannot have a constructor method in a singleton class. We can use the init method if some initialization is required. The object gets instantiated when it is used for the first time. It provides us with thread-safe lazy initialization without having to rely on a locking algorithm.

Code explanation#

• Line 1: We use the object keyword to create a class named Singleton.

• Lines 2–4: We print the message “Initialization of Singleton class.” in its initialization method.

• Line 5: We declare a variable myVariable.

• Lines 6–8: We add a method named printVariable that just prints the variable myVariable.

• Line 11: We directly access the singleton class and call its printVariable method.

• Line 12: We assign a new value to the variable myVariable.

5. What is the difference between fold and reduce in Kotlin?#

In Kotlin, both fold and reduce are higher-order functionsHigher-order functions are functions that can take other functions as parameters or return functions. used for combining elements of a collection into a single result. However, they differ in terms of their usage.

The fold function#

It is used to accumulate a single value by applying a given binary operation to each element and accumulating the result with an initial value. Therefore, we must provide an initial value for the accumulation.

In this example, fold starts with an initial value of 1 and adds each element of the numbers list to the accumulator.

The reduce function#

It is quite similar to fold, but it does not require an initial value. It starts with the first element of the collection as the initial accumulator.

In this example, reduce starts with the first element 1 as the initial accumulator and adds each subsequent element to it.

6. Explain null safety in Kotlin#

In Kotlin, we have a prominent feature of null safety that eliminates the NullPointerExceptions (NPEs) common in many other programming languages. Basically, every variable has a default non-null type, meaning it cannot hold a null value unless explicitly specified. If a variable can hold a null value, its type must be declared explicitly by appending ? to the type. Let’s have a look at the usage of ? below.

Non-nullable types (default) #

Variables of these types cannot hold null values. The type is declared without the ? symbol.

Note: Try uncommenting line 4 and see what error you get.

Code explanation#

• Line 3: We declare a non-nullable variable named name of type string.

• Line 5: We print a message along with the value of the name variable.

Nullable types#

Variables of these types can hold null values. The type is declared with the ? symbol.

Code explanation#

• Line 3: We declare a nullable variable named name of type string.

• Line 5: We print a message along with the value of the name variable.

7. What are coroutines in Kotlin?#

In Kotlin, coroutines are a powerful feature that allows for asynchronous programming, enabling us to write non-blocking, asynchronous code in a sequential manner. Coroutines provide a way to perform long-running tasks efficiently and conveniently without blocking the main thread, similar to other async/await patterns found in other languages.

Let’s have a look at an example below.

Code explanation#

• Line 1: We import the required package for creating coroutines.

• Line 6: We use the launch method to launch a coroutine. Inside the coroutine.

• Line 7: We use delay(1000) method to suspend the coroutine for 1 second. Note that the main thread will continue to execute immediately after launching the coroutine.

• Line 12: We use Thread.sleep(2000) to ensure the coroutine has enough time to complete before the program exits.

8. What are companion objects in Kotlin?#

In Kotlin, we do not have the “static” keyword, so, if we want to achieve the functionality of static member functions, we use the companion objects. It is a special type of object that is tied to the class it belongs to rather than to instances of that class. It allows us to define methods and properties that are similar to static members in other programming languages. Let’s have a look at a sample companion object below.

Code explanation#

• Line 2: We declare a companion object by using the companion keyword.

• Line 3: We declare a variable named companionVariable inside the companion object.

• Line 4: We create a method named companionMethod inside the companion object.

9. What is a sealed class in Kotlin?#

In Kotlin, a sealed class is a special type of class that can have a fixed set of subclasses, defined within the sealed class itself. This means that all subclasses must be defined inside the sealed class declaration, and no other subclasses can be created outside of it. It is used when all the possible subclasses are known upfront. They are useful for representing restricted class hierarchies. It is to be noted that sealed classes can have constructors, but the constructors cannot be declared as private. They can be protected, internal, or public.

Code explanation#

• Line 1: We create a sealed class named Shape.

• Lines 2–4: It has three subclasses named Circle, Rectangle, and Square, respectively.

• Line 7: We define a function that will compute the area of all three shapes using the when operator.

• Lines 16–18: We create objects of the shapes circle, rectangle, and square.

• Lines 20–22: We print the area of these shapes.

10. What are object expressions in Kotlin?#

Object expressions provide a way to create anonymous objects, similar to anonymous inner classes in Java. It allows us to create an instance of a class or interface without explicitly declaring a named subclass. It’s particularly useful for creating objects that are only needed once and don’t need to be reused elsewhere. There are some limitations to it though. We cannot have constructors in object expressions and they cannot be reused elsewhere in the code.

Code explanation#

• Line 1: We create an interface Shape with a draw() function.

• Line 5: We create a drawShapes method that will iterate over the list of Shape objects and call its draw method.

• Lines 13–18, we create two anonymous objects using object expressions, each implementing the Shape interface with its own draw() implementation.

• Line 25: We call the drawShapes method passing the two anonymous objects.

This wraps up our blog about the top ten interview questions in Kotlin. We started by first stating the question and then explaining the answer in detail. We then provided a code-based example for better comprehension. It is to be noted that there are many other concepts in Kotlin that will be covered in the next series of this blog.

Your next learning steps#

To deepen your understanding of the Kotlin programming languages, we strongly recommend you look through the following selection of specialized courses on the Educative platform:

Don’t pass up this chance to increase your knowledge and expertise in Kotlin. Take the first step toward becoming an expert developer in Kotlin by immediately enrolling in Educative courses!