Explore topic-wise InterviewSolutions in .

Following are the advantages of Kotlin over Java:-

• Data class: In Java, you must create getters and SETTERS for each object, as well as properly write hashCode (or allow the IDE to build it for you, which you must do every time you update the class), TOSTRING, and equals. Alternatively, you could utilize lombok, but that has its own set of issues. In Kotlin, data classes take care of everything.
• Patterns of getter and setter: In Java, for each variable, you use it for, rewrite the getter and setter methods. You don't have to write getter and setter in kotlin, and if you must, custom getter and setter take a lot less typing. There are ADDITIONAL delegates for identical getters and setters.
• Extension Functions: In Java, there is no support for extension functions. Kotlin on the other hand provides support for extension functions which makes the code more clear and cleaner.
• Support for one common codebase: You may extract one common codebase that will TARGET all of them at the same time using the Kotlin Multi-Platform framework.
• Support for Null Safety: Kotlin has built-in null safety support, which is a lifesaver, especially on Android, which is full of old Java-style APIs.
• Less prone to errors: There is less space for error because it is more CONCISE and expressive than Java.

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.

For example,

Output:-

Explanation:- In the above code, the variable temp has the VALUE “Interview”. The when condition matches for the exact value as that of temp’s and executes the corresponding code statements. Thus, “Interview Bit is the solution” is printed.

The keyword “open” refers to the TERM "open for expansion". The open annotation on a class is the POLAR opposite of the final annotation in Java: it allows others to inherit from it. By default, a class cannot be inherited in Kotlin. In Kotlin, an open method signifies that it can be overridden, whereas it cannot be by default. Instead, any methods in Java can be overridden by default.

In Kotlin, all the CLASSES are final by default. If no visibility modifier is specified, the public is USED by default, which means our declarations will be accessible everywhere inside the program.

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. 

We must use the companion keyword in front of the object definition to construct a companion object.

We can also remove the CompanionObject name and replace it with the term companion, resulting in the companion object's default name being Companion, as SHOWN below:

All the required static member functions and member variables can be kept INSIDE the companion object created. For example,

Output:-

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:

Output:-

Explanation:-

We don't have a method named "addStr" inside the "Sample" class in the preceding example, but we are implementing the same method outside of the class. This is all because of function extension.

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

Using String Interpolation:- We use the technique of string interpolation to concatenate the two strings. Basically, we SUBSTITUTE the strings in place of their placeholders in the initialisation of the third string.

Using the + or plus() operator:- We use the ‘+’ operator to concatenate the two strings and store them in a third variable.

Using STRINGBUILDER:- We concatenate two strings using the StringBuilder object. First, we append the first string and then the second string. 

Following are the different WAYS to iterate over any data structure in Kotlin :

• For Loop - The for loop is used to scan any data structure that SUPPLIES an iterator in this case. It is not used in the same way as the for loop in other programming languages such as Java or C.

In Kotlin, the for loop has the following Syntax:

Here, collection refers to the data structure to be iterated and item refers to each element of the data structure.

For example,

Output -

• While Loop - It is made up of a code block and a condition to be checked for each iteration. First, the while condition is assessed, and if it is true, the code within the block is executed. Because the condition is verified every time before entering the block, it repeats until the condition turns false. The while loop can be thought of as a series of if statements that are repeated.

The while loop's syntax is as follows:

For example,

Output -

• Do While Loop - The condition is assessed after all of the statements inside the block have been executed. If the do-while condition is true, the code block is re-executed. As long as the expression evaluates to true, the code block EXECUTION procedure is repeated. The loop ends if the expression becomes false, and control is passed to the sentence following the do-while loop. Because it verifies the condition after the block is executed, it's also KNOWN as a post-test loop.

The do-while loop's syntax is as follows:

For example,

Output -

<P>There are two types of Kotlin constructors:

• Primary Constructor  - This type of constructor is initialised in the class header and is provided after the class name. It is declared using the “constructor” keyword. Parameters are optional in this type of constructor. For example,

If no annotations or ACCESS modifiers are provided, the constructor keyword can be omitted. The initialization code can be placed in a separate initializer block prefixed with the init keyword because the primary constructor cannot contain any code. 

For example, 

Output:-

Explanation - The values 1 and 2 are SUPPLIED to the constructor arguments a and b when the object s1 is created for the class Sample. In the class p and q, two attributes are specified. The initializer block is called when an object is created, and it not only sets up the attributes but also PRINTS them to the standard output.

• Secondary Constructor - Secondary constructors allow for the initialization of variables as well as the addition of logic to the class. They have the constructor keyword prefixed to them. For example,

Output:-

The compiler determines which secondary constructor will be called based on the inputs provided. We don't specify which constructor to use in the above program, so the compiler chooses for us.

In Kotlin, a class can contain one or more secondary constructors and at most one primary constructor. The primary constructor INITIALIZES the class, while the secondary constructor initialises the class and adds some additional logic.

Following are the differences between Kotlin and Java:-

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

is equivalent to the following

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. 

For example,

The following expression in Kotlin

is equivalent to the following

Furthermore, on the right side of the Elvis operator, we may use throw and return expressions, which is particularly handy in functions. As a result, instead of returning a default value on the right side of the Elvis operator, we can throw an exception. For example,

Not Null Assertion Operator ( !! ) - If the value is null, the not null assertion (!!) operator changes it to a non-null type and throws an exception.

Anyone who wants a NullPointerException can ask for it explicitly with this operator.

For example,

The above CODE snippet gives the following OUTPUT:-

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.

The Kotlin type system distinguishes between references that can hold null (nullable references) and those that cannot (non-null references). Null cannot be stored in a String variable. We get a compiler error if we try to assign null to the variable. 

If we want the above string to be ABLE to hold null value as well, we can declare it of type nullable using the ‘?’ operator after the String keyword as follows :

Kotlin PROVIDES Safe Call (?.), Elvis (?:) and Not Null Assertion (!!) operators which define what needs to be done in case of a null encounter. This makes the code more reliable and less prone to errors. Thus, Kotlin ENFORCES null safety by having nullable, non-nullable type variables and the different operators to tackle null encounters.

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:

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:

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

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

Output:-

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.

There are broadly two types of variables in Kotlin. They are as follows:-

• Immutable Variables — Immutable variables are also known as read-only variables. They are declared using the val keyword. Once these variables have been declared, we cannot change their values.

The syntax is as follows :

For example,

The second line in the above code SNIPPET would RESULT in a compile-time error as expected.

Because it can be initialized with the value of a variable, an immutable variable is not a constant. It means that the value of an immutable variable does not need to be known at compile-time and that if it is defined inside a construct that is called several times, it can take on a different value with each function call. For example, 

The above code snippet runs fine and does not produce any errors.

• Mutable Variables - In a mutable variable, the value of the variable can be changed. We use the keyword “var” to declare such variables.

The syntax is as follows :

For example,

The above code snippet runs fine and does not produce any errors.

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:-

Integer Data Type -

Floating Point Data Type - 

BOOLEAN Data Type - 

True or false is the only bit of information represented by the Boolean data type. In Kotlin, the Boolean type is the same as in Java. 

Character Data Type - 

Small letters (a-z), capital letters (A-Z), numerals (0-9), and other symbols are represented by the character data type.

String Data Type -

Strings are represented in Kotlin by the type String. A string value is OFTEN a sequence of characters enclosed in double quotations ("). The space required in this CASE depends on the number of characters in the string.

Array Data Type -

The Array class in Kotlin is used to represent arrays. It has the get and set functions that, due to operator overloading conventions, can be used as  ‘[]’  as well. The space required by the array also depends on the number of elements it posses.