Kotlin%20Interview%20Questions%20and%20Answers

Ques 1. What is Kotlin?

Kotlin is an open-source, general-purpose, statically typed programming language. It is JVM-based and may be used in all projects where Java is currently used.

It may be used to create Android apps, server-side apps, and a variety of other applications. It is an improved version of Java and is completely interoperable with it. We can even mix Kotlin and Java in the same project.

It blends Object Oriented Programming (OOPs) and functional programming in a platform that is unlimited, self-contained, and unique. It also enables functional twinning using microcodes. 

Ques 2. Who has created Kotlin?

The JetBrains team created Kotlin. The language was initially launched in February 2016 after a project began in 2010 to develop it. The Apache 2.0 license was used to create Kotlin. 

Ques 3. Tell some good features about Kotlin?

• Programs written in Kotlin do not require semicolons. This makes the code more readable and easy to understand.
• This language enables the interchange and usage of Java in a variety of ways.
• Furthermore, code written in Java and Kotlin can coexist in the same project.
• The type system of Kotlin is designed to eliminate NullPointerException from code.
• Writing new code in Kotlin will take you less time.
• Kotlin code is even easier to deploy and manage at scale.

Ques 4. Tell me about the top features of Kotlin.

• Compact code: Kotlin is an OOPs-based programming language with code lines that may be reduced by up to 40% when compared to Java, making it an excellent choice for software development.
• Open Source: Kotlin for Android is open-source and uses the JVM to combine the benefits of OOPs and functional programming.
• Simple Language: When working with Kotlin, compiling the code is simple, resulting in improved performance for Android development. It also explains which types of data functions can be used throughout the code.
• High number of extensions: Without modifying the code, Kotlin may support a variety of extension functions. It aids developers in making existing code more appealing and wonderful.
• Full Java Interoperability: Java code can utilize Kotlin code, and Kotlin code can use Java code. So, if you're familiar with OOPS programming, switching to Kotlin development is simple. Also, if there are any Java-based applications, they can be used with Kotlin's environment.
• Smart Cast: Smart casting is a technique that reduces the cost of an application while also improving its speed and performance. It uses typecasting or immutable data to manage the efficiency of programming. This technique is supported by Kotlin.
• Low Learning Curve: Kotlin is preferred by businesses due to its low adoption cost. Most significantly, it is simple for developers to learn, especially if they have programming experience.

Ques 5. What are the various data types available in Kotlin? Explain them.

Primitive data types are the most basic data types in Kotlin, and all others are reference types like array and string. Kotlin contains all data types as objects. Following are the different data types available in Kotlin:

Ques 6. How are variables declared in Kotlin? What are the different types of variables in Kotlin? Explain with examples.

Every variable in Kotlin must be declared before it can be used. An attempt to use a variable without declaring it results in a syntax error. The type of data you are authorised to put in the memory address is determined by the variable type declaration. The type of variable can be determined from the initialised value in the case of local variables.

For example,

var site = "interviewbit"

The above code declares a variable “site” of type String because the value with which the variable is initialised is a String.

val variableName = value

val sample = "interview"
sample = "interviewbit"    // results in compile time error

var sample = "interview"
val newSample = sample    // no compile time error

var variableName = value

var sample = "interview"
sample = "fun"    // no compile time error

Ques 7. What are data classes in Kotlin? Explain with a proper example.

The Data class is a simple class that holds data and provides typical functions. To declare a class as a data class, use the data keyword. 

Syntax:

data class className ( list_of_parameters)

The following functions are automatically derived by the compiler for the data classes:

• equals() - The equals() function returns true if two objects have the identical contents. It operates similarly to \"==,\" although for Float and Double values it works differently.
• hashCode() - The hashCode() function returns the object\'s hashcode value.
• copy() - The copy() function is used to duplicate an object, changing only a few of its characteristics while leaving the rest unaltered.
• toString() - This function returns a string containing all of the data class\'s parameters.

To ensure consistency, data classes must meet the following requirements:

• At least one parameter is required for the primary constructor.
• val or var must be used for all primary constructor parameters.
• Abstract, open, sealed, or inner data classes are not possible.
• Only interfaces may be implemented by data classes.

Example:

data class Sample(var input1 : Int, var input2 : Int)

The above code snippet creates a data class Sample with two parameters.

fun main(agrs: Array) {     
  val temp = Sample(1, 2)     
  println(temp)  
}  

Here, we create an instance of the data class Sample and pass the parameters to it.

Output:-

Sample(input1=1, input2=2)

Ques 8. Explain the concept of null safety in Kotlin.

Kotlin's type system aims to eradicate null references from the code. If a program throws NullPointerExceptions at runtime it might result in application failure or system crashes. If the Kotlin compiler finds a null reference it throws a NullPointerException.

var a: String = "interview"
a = null // results in compilation error

var a: String? = "interview"
a = null // no compilation error

Ques 9. Explain the various methods to iterate over any data structure in Kotlin with examples.

for(item in collection) {     
  // code 
}

// KOTLIN
fun main(args: Array) {   
  var numbersArray = arrayOf(1,2,3,4,5,6,7,8,9,10)    
  for (num in numbersArray){       
    if(num % 2 == 0){           
      print("$num ")       
    }   
  }
}

2 4 6 8 10

while(condition) {         
  // code 
}

// KOTLIN
fun main(args: Array) {   
  var number = 1   
  while(number <= 5) {       
    println(number)       
    number++;   
  }
}

12345

do {     
  // code 
} while(condition)

// KOTLIN
fun main(args: Array) {   
  var number = 4   
  var sum = 0    
  do {       
    sum += number       
    number--   
  } while(number > 0)   
  println("Sum of first four natural numbers is $sum")
}

Sum of first four natural numbers is 10

Ques 10. How can you concatenate two strings in Kotlin?

Following are the different ways by which we can concatenate two strings in Kotlin:

val s1 = "Without"
val s2 = "Book"
val s3 = "$s1 $s2" // stores "Without Book"

val s1 = "Without"
val s2 = "Book"
val s3 = s1 + s2 // stores "WithoutBook"
val s4 = s1.plus(s2) // stores "WithoutBook"

val s1 = "Without"
val s2 = "Book"
val s3 =  StringBuilder()     
s3.append(s1).append(s2)
val s4 = s3.toString() // stores "WithoutBook"

Ques 11. What’s the Target Platform of Kotlin? How is Kotlin-Java interoperability possible?

Java Virtual Machine(JVM) is the Target Platform of Kotlin. Kotlin is 100% interoperable with Java since both, on compilation produce bytecode. Hence Kotlin code can be called from Java and vice-versa.

Ques 12. Explain Safe call, Elvis and Not Null Assertion operator in the context of Kotlin.

Safe Call operator ( ?. ) -  Null comparisons are trivial, but the number of nested if-else expressions can be exhausting. So, in Kotlin, there\'s a Safe call operator,?, that simplifies things by only doing an action when a specified reference holds a non-null value. It allows us to use a single expression to perform both a null check and a method call.

For example,

The following expression in Kotlin

name?.toLowerCase() 

is equivalent to the following

if(name != null)    
  name.toLowerCase()
else   
  null 

Elvis Operator ( ?: ) - When the original variable is null, the Elvis operator is used to return a non-null value or a default value. In other words, the elvis operator returns the left expression if it is not null, otherwise, it yields the right expression. Only if the left-hand side expression is null is the right-hand side evaluated. 

val sample1 = sample2 ?: "Undefined"

val sample1 = if(sample2 != null)        
    sample2     
  else        
    "Undefined"

val sample1 = sample2 ?: throw IllegalArgumentException("Invalid")

// KOTLIN
fun main(args: Array) {   
  var sample : String?  = null   
  str!!.length
}

Exception in thread "main" kotlin.KotlinNullPointerException

Ques 13. Differentiate between Kotlin and Java.

Following are the differences between Kotlin and Java:

Ques 14. What are the different types of constructors available in Kotlin? Explain them with proper examples.

class Sample constructor(val a: Int, val b: Int) {   
  // code
}

// KOTLIN
fun main(args: Array) {   
  val s1 = Sample(1, 2)
}
class Sample(a : Int , b: Int) {   
  val p: Int   
  var q: Int   
  // initializer block   
  init {       
    p = a       
    q = b       
    println("The first parameter value is : $p")       
    println(\"The second parameter value is : $q\")   
  }
}

The first parameter value is: 1
The second parameter value is: 2

// KOTLIN
fun main(args: Array) {   
  val s1 = Sample(1, 2)
}
class Sample {   
  constructor(a: Int, b: Int) {       
    println("The first parameter value is : $p")       
    println("The second parameter value is : $q")   
  }
}

The first parameter value is: 1
The second parameter value is: 2

Ques 15. Differentiate between open and public keywords in Kotlin.

Ques 16. Explain about the “when” keyword in the context of Kotlin.

The “when” keyword is used in Kotlin to substitute the switch operator in other languages such as Java. When a certain condition is met, a specific block of code must be run. Inside the when expression, it compares all of the branches one by one until a match is discovered. After finding the first match, it proceeds to the conclusion of the when block and executes the code immediately following the when block. We do not need a break statement at the end of each case, unlike switch cases in Java or any other programming language.

// KOTLIN
fun main(args: Array) {      
  var temp = "Interview"   
  when(temp) {       
    "Interview" -> println("Without Book is the solution.")       
    "Job" -> println("Interview is the solution.")       
    "Success" -> println("Hard Work is the solution.")   
  }
}

Without Book is the solution.

Ques 17. What do you understand about function extension in the context of Kotlin? Explain.

In Kotlin, we can add or delete method functionality using extensions, even without inheriting or altering them. Extensions are statistically resolved. It provides a callable function that may be invoked with a dot operation, rather than altering the existing class.

Function Extension - Kotlin allows users to specify a method outside of the main class via function extension. We\'ll see how the extension is implemented at the functional level in the following example:

// KOTLIN
class Sample { 
  var str : String = "null"    
  fun printStr() {     
    print(str) 
  }        
}
fun main(args: Array) { 
  var  a = Sample() 
  a.str = "Without" 
  var  b = Sample() 
  b.str = "Book" 
  var  c = Sample() 
  c.str = a.add(b) 
  c.printStr()
}
// function extension
fun Sample.add(a : Sample):String{ 
  var temp = Sample() 
  temp.str = this.str + \" \" +a.str return temp.str
}

Output:-

Without Book

Ques 18. What do you understand about Companion Object in the context of Kotlin?

In some languages, such as Java, the static keyword is used to declare class members and utilise them without creating an object, i.e. by simply calling them by their class name. In Kotlin, there is nothing called the “static” keyword. So, if we want to achieve the functionality of static member functions, we use the companion objects. This is also referred to as Object Extension. 

// Syntax in KOTLIN
class CompanionClass {    
  companion object CompanionObjectName {      
    // code    
  }
}
val obj = CompanionClass.CompanionObjectName

// KOTLIN
class CompanionClass {   
  companion object {     
    // code   
  }
}
val obj = CompanionClass.Companion

class Sample {   
  companion object Test {       
    var a: Int = 1       
    fun testFunction() = println("Companion Object’s Member function called.")   
  }
}
fun main(args: Array) {   
  println(Sample.a)   
  Sample.testFunction()
}

1Companion Object’s Member function called.

Ques 19. What are the advantages of Kotlin over Java?

Following are the advantages of Kotlin over Java:

Ques 20. Which one is better to use - val mutableList or var immutableList in the context of Kotlin?

The program's design clarity is improved by using mutable and immutable lists. This is done to have the developer think about and clarify the collection's purpose.

We use a mutable list if the collection will alter as part of the design. On the other hand, we use an immutable list if the model is only meant to be viewed.

Val and var serve a distinct purpose than immutable and mutable lists. The val and var keywords specify how a variable's value/reference should be handled. We use var when the value or reference of a variable can be altered at any moment. On the other hand, we use val when a variable's value/reference can only be assigned once and cannot be modified later in the execution.

Immutable lists are frequently preferred for a variety of reasons:

• They promote functional programming, in which state is passed on to the next function, which constructs a new state based on it, rather than being altered. This is evident in Kotlin collection methods like map, filter, reduce, and so forth.
• It's often easier to understand and debug software that doesn't have any side effects (you can be sure that the value of an object will always be the one at its definition).
• Because no write access is required in multi-threaded systems, immutable resources cannot induce race conditions.

However, there are some disadvantages of using immutable lists as well. They are as follows :

• Copying large collections simply to add/remove a single piece is very expensive.
• When you need to alter single fields frequently, immutability can make the code more difficult. Data classes in Kotlin provide a built-in copy() method that allows you to clone an instance while changing only part of the fields' values.

Ques 21. What do you understand about lateinit in Kotlin? When would you consider using it?

lateinit is an abbreviation for late initiation. If you don\'t want to initialize a variable in the constructor and instead want to do it later, and you can guarantee the initialization before using it, use the lateinit keyword to declare that variable. It won\'t start allocating memory until it\'s been initialized. Lateinit cannot be used for primitive type attributes like Int, Long, and so on. Because the lateinit variable will be initialized later, you cannot use val. When a lateinit property is accessed before it has been initialized, a special exception is thrown that explicitly identifies the property and the fact that it hasn\'t been initialized.

// KOTLIN
lateinit var test: Stringfun testFunction() {   
  test = "Interview"   
  println("The length of string is "+test.length)   
  test = "Book"
}

9 

Ques 22. Explain lazy initialization in the context of Kotlin.

// KOTLIN
class FastClass {   
  private val slowObject: SlowClass = SlowClass()
}

class FastClass {   
  private val slowObject: SlowClass by lazy {       
    SlowClass()   
  }  
}

// KOTLIN
class FastClass {   
  private val slowObject: SlowClass by lazy {       
    println("Slow Object initialised")       
    SlowClass()   
  }       
  fun access() {       
    println(slowObject)   
  }
}
fun main(args: Array) {   
  val fastClass = FastClass()   
  println("FastClass initialised")   
  fastClass.access()   
  fastClass.access()
}

FastClass initialised 
Slow Object initialised 
SlowClass@2b12fkk7 
SlowClass@2b12fkk7

Ques 23. Differentiate between lateinit and lazy initialisation. Explain the cases when you should use lateinit and when you should use lazy initialisation.

Ques 24. What do you understand about coroutines in the context of Kotlin?

Ques 25. Explain scope functions in the context of Kotlin. What are the different types of Scope functions available in Kotlin?

The Kotlin standard library includes numerous functions that aid in the execution of a block of code within the context of an object. When you use a lambda expression to call these functions on an object, temporary scope is created. These functions are referred to as Scope functions. The object of these functions can be accessed without knowing its name. Scope functions make code more clear, legible, and succinct, which are key qualities of the Kotlin programming language.

Ques 26. Explain suspend function in the context of Kotlin.

A function that may be started, halted, then resumed is known as a suspend function. One of the most important things to remember about the suspend functions is that they can only be invoked from another suspend function or from a coroutine. Suspending functions are merely standard Kotlin functions with the suspend modifier added, indicating that they can suspend coroutine execution without blocking the current thread. This means that the code you're looking at may pause execution when it calls a suspending function and restart execution at a later time. However, it makes no mention of what will happen to the present thread in the meantime.

Ques 27. What do you understand about sealed classes in Kotlin?

Kotlin introduces a crucial new form of class that isn't seen in Java. These are referred to as "sealed classes." Sealed classes, as the name implies, adhere to constrained or bounded class hierarchies. A sealed class is one that has a set of subclasses. When it is known ahead of time that a type will conform to one of the subclass types, it is employed. Type safety (that is, the compiler will validate types during compilation and throw an exception if a wrong type has been assigned to a variable) is ensured through sealed classes, which limit the types that can be matched at compile time rather than runtime.

Ques 28. What do you understand about the backing field in Kotlin?

var marks: Int = someValue       
get() = field       
set(value) {           
  field = value       
}

Ques 29. Differentiate between launch / join and async / await in Kotlin.

Ques 30. What are some of the disadvantages of Kotlin?

Following are some of the disadvantages of Kotlin:

• In Kotlin, there are a few keywords that have non-obvious meanings: internal, crossinline, expect, reified, sealed, inner, open. Java has none of these.
• Checked exceptions are likewise absent in Kotlin. Although checked exceptions have become less prominent, many programmers believe them to be an effective technique to ensure that their code is stable.
• A lot of what happens in Kotlin is hidden. You can almost always trace the logic of a program in Java. When it comes to bug hunting, this can be really useful. If you define a data class in Kotlin, getters, setters, equality testing, tostring, and hashcode are automatically added for you.
• Learning resources are limited. The number of developers who are moving to Kotlin is growing, yet there is a small developer community accessible to help them understand the language or address problems during development.
• Kotlin has variable compilation speed. In some situations, Kotlin outperforms Java, particularly when executing incremental builds. However, we must remember that when it comes to clean builds, Java is the clear winner.