Kotlin est le dernier langage de programmation pour la JVM développé par JetBrains. Google l’a désigné comme le langage officiel pour le développement Android aux côtés de Java. Les développeurs affirment qu’il résout les problèmes rencontrés dans la programmation Java. J’ai rédigé de nombreux tutoriels Kotlin, et ici, je propose des questions importantes pour les entretiens Kotlin.
Questions d’entretien Kotlin
Je présente ici des questions et réponses d’entretien Kotlin qui vous seront utiles. Ces questions d’entretien Kotlin conviennent aux débutants ainsi qu’aux programmeurs expérimentés. Il y a aussi des questions de codage pour améliorer vos compétences en programmation.
-
Quelle est la plateforme cible de Kotlin ? Comment la compatibilité Kotlin-Java est-elle possible ?
La machine virtuelle Java (JVM) est la plateforme cible de Kotlin. Kotlin est entièrement interopérable avec Java, car les deux produisent du bytecode lors de la compilation. Ainsi, le code Kotlin peut être appelé depuis Java et vice versa.
-
Comment déclarez-vous des variables en Kotlin ? En quoi la déclaration diffère-t-elle de son équivalent en Java ?
Il existe deux différences majeures entre la déclaration des variables en Java et en Kotlin :
-
Le type de déclaration En Java, la déclaration ressemble à ceci :
String s = "Java String"; int x = 10;En Kotlin, la déclaration ressemble à ceci :
val s: String = "Hi" var x = 5En Kotlin, la déclaration commence par un
valou unvarsuivi du type optionnel. Kotlin peut détecter automatiquement le type en utilisant l’inférence de type. -
Valeur par défaut Ce qui suit est possible en Java :
String s:La déclaration de variable suivante en Kotlin n’est pas valide.
val s: String
-
-
Quelle est la différence entre une déclaration val et var ? Comment convertir une chaîne de caractères en entier ?
Les variables
valne peuvent pas être modifiées. Elles sont similaires aux modificateurs finaux en Java. Une variablevarpeut être réassignée. La valeur réassignée doit être du même type de données.fun main(args: Array<String>) { val s: String = "Salut" var x = 5 x = "6".toInt() }Nous utilisons la méthode
toInt()pour convertir une chaîne de caractères en entier. -
Qu’est-ce que la sécurité de Null et les types Nullable en Kotlin ? Quel est l’opérateur Elvis ?
Kotlin accorde beaucoup d’importance à la sécurité de null, qui est une approche visant à prévenir les redoutables exceptions de pointeur null en utilisant des types nullable comme
String?,Int?,Float?, etc. Ceux-ci agissent comme un type d’emballage et peuvent contenir des valeurs null. Une valeur nullable ne peut pas être ajoutée à un autre type de valeur nullable ou de base. Pour récupérer les types de base, nous devons utiliser des appels sécurisés qui déballent les types nullable. Si, lors du déballage, la valeur est null, nous pouvons choisir de l’ignorer ou d’utiliser une valeur par défaut à la place. L’opérateur Elvis est utilisé pour déballer en toute sécurité la valeur du Nullable. Il est représenté par?:sur le type nullable. La valeur du côté droit serait utilisée si le type nullable contient un null.var str: String? = "JournalDev.com" var newStr = str?: "Valeur par défaut" str = null newStr = str?: "Valeur par défaut"
-
Qu’est-ce qu’un
const? En quoi diffère-t-il d’unval?Par défaut, les propriétés
valsont définies à l’exécution. Ajouter un modificateur const à unvalen ferait une constante à temps de compilation. Unconstne peut pas être utilisé avec unvarou seul. Unconstn’est pas applicable à une variable locale.
-
Est-ce que Kotlin nous permet d’utiliser des types primitifs tels que int, float, double?
Au niveau du langage, nous ne pouvons pas utiliser les types mentionnés ci-dessus. Mais le bytecode JVM généré les inclut certainement.
-
Quel est le point d’entrée de chaque programme Kotlin?
La fonction
mainest le point d’entrée de chaque programme Kotlin. En Kotlin, nous pouvons choisir de ne pas écrire la fonction main à l’intérieur de la classe. Lors de la compilation, la JVM l’encapsule implicitement dans une classe. Les chaînes passées sous forme deArray<String>sont utilisées pour récupérer les arguments de la ligne de commande. -
Comment
!!diffère-t-il de ?. lors du déballage des valeurs nullables ? Existe-t-il un autre moyen de déballer les valeurs nullables en toute sécurité ?!!est utilisé pour forcer le déballage du type nullable afin d’obtenir la valeur. Si la valeur retournée est nulle, cela entraînerait un crash en temps d’exécution. Par conséquent, l’opérateur!!doit être utilisé uniquement lorsque vous êtes absolument sûr que la valeur ne sera jamais nulle. Sinon, vous obtiendrez la redoutable exception de pointeur nul. D’autre part, ?. est un opérateur Elvis qui effectue un appel sécurisé. Nous pouvons utiliser l’expression lambdaletsur la valeur nullable pour déballer en toute sécurité comme indiqué ci-dessous.
Ici, l’expression let effectue un appel sécurisé pour déballer le type nullable. -
Comment une fonction est-elle déclarée ? Pourquoi les fonctions Kotlin sont-elles appelées fonctions de niveau supérieur ?
fun sommeDe(a: Int, b: Int): Int{ return a + b }Le type de retour d’une fonction est défini après le
:. Les fonctions en Kotlin peuvent être déclarées à la racine du fichier Kotlin. -
Quelle est la différence entre les opérateurs == et === en Kotlin ?
\== is used to compare the values are equal or not. === is used to check if the references are equal or not.
- public
- internal
- protected
- private
`public` is the default visibility modifier.
```
class A{
}
class B : A(){
}
```
**NO**. By default classes are final in Kotlin. To make them non-final, you need to add the `open` modifier.
```
open class A{
}
class B : A(){
}
```
Constructors in Kotlin are of two types: **Primary** - These are defined in the class headers. They cannot hold any logic. There's only one primary constructor per class. **Secondary** - They're defined in the class body. They must delegate to the primary constructor if it exists. They can hold logic. There can be more than one secondary constructors.
```
class User(name: String, isAdmin: Boolean){
constructor(name: String, isAdmin: Boolean, age: Int) :this(name, isAdmin)
{
this.age = age
}
}
```
`init` is the initialiser block in Kotlin. It's executed once the primary constructor is instantiated. If you invoke a secondary constructor, then it works after the primary one as it is composed in the chain.
String interpolation is used to evaluate string templates. We use the symbol $ to add variables inside a string.
```
val name = "Journaldev.com"
val desc = "$name now has Kotlin Interview Questions too. ${name.length}"
```
Using `{}` we can compute an expression too.
By default, the constructor arguments are `val` unless explicitly set to `var`.
**NO**. Unlike Java, in Kotlin, new isn't a keyword. We can instantiate a class in the following way:
```
class A
var a = A()
val new = A()
```
when is the equivalent of `switch` in `Kotlin`. The default statement in a when is represented using the else statement.
```
var num = 10
when (num) {
0..4 -> print("value is 0")
5 -> print("value is 5")
else -> {
print("value is in neither of the above.")
}
}
```
`when` statments have a default break statement in them.
In Java, to create a class that stores data, you need to set the variables, the getters and the setters, override the `toString()`, `hash()` and `copy()` functions. In Kotlin you just need to add the `data` keyword on the class and all of the above would automatically be created under the hood.
```
data class Book(var name: String, var authorName: String)
fun main(args: Array<String>) {
val book = Book("Kotlin Tutorials","Anupam")
}
```
Thus, data classes saves us with lot of code. It creates component functions such as `component1()`.. `componentN()` for each of the variables. [](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-data-classes.png)
Destructuring Declarations is a smart way to assign multiple values to variables from data stored in objects/arrays. [](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-destructuring-declarations.png) Within paratheses, we've set the variable declarations. Under the hood, destructuring declarations create component functions for each of the class variables.
[Inline functions](/community/tutorials/kotlin-inline-function-reified) are used to save us memory overhead by preventing object allocations for the anonymous functions/lambda expressions called. Instead, it provides that functions body to the function that calls it at runtime. This increases the bytecode size slightly but saves us a lot of memory. [](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-inline-functions.png) [infix functions](/community/tutorials/kotlin-functions) on the other are used to call functions without parentheses or brackets. Doing so, the code looks much more like a natural language. [](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-infix-notations.png)
Both are used to delay the property initializations in Kotlin `lateinit` is a modifier used with var and is used to set the value to the var at a later point. `lazy` is a method or rather say lambda expression. It's set on a val only. The val would be created at runtime when it's required.
```
val x: Int by lazy { 10 }
lateinit var y: String
```
To use the singleton pattern for our class we must use the keyword `object`
```
object MySingletonClass
```
An `object` cannot have a constructor set. We can use the init block inside it though.
**NO**. Kotlin doesn't have the static keyword. To create static method in our class we use the `companion object`. Following is the Java code:
```
class A {
public static int returnMe() { return 5; }
}
```
The equivalent Kotlin code would look like this:
```
class A {
companion object {
fun a() : Int = 5
}
}
```
To invoke this we simply do: `A.a()`.
```
val arr = arrayOf(1, 2, 3);
```
The type is Array<Int>.
C’est tout pour les questions et réponses d’entretien Kotlin.
Source:
https://www.digitalocean.com/community/tutorials/kotlin-interview-questions