Domande dell’intervista Kotlin

Kotlin è l’ultimo linguaggio di programmazione JVM sviluppato da JetBrains. Google lo ha reso il linguaggio ufficiale per lo sviluppo di Android insieme a Java. Gli sviluppatori sostengono che affronti le problematiche riscontrate nella programmazione Java. Ho scritto molti tutorial su Kotlin e qui sto fornendo importanti domande di colloquio su Kotlin.

Domande di colloquio su Kotlin

Qui sto fornendo domande e risposte di colloquio su Kotlin che ti aiuteranno nei tuoi colloqui su Kotlin. Queste domande di colloquio su Kotlin sono adatte sia per principianti che per programmatori esperti. Ci sono anche domande di codifica per migliorare le tue abilità di programmazione.

1. Qual è la piattaforma di destinazione di Kotlin? Come è possibile l’interoperabilità tra Kotlin e Java?

   La piattaforma di destinazione di Kotlin è la Java Virtual Machine (JVM). Kotlin è interoperabile al 100% con Java poiché entrambi, alla compilazione, producono bytecode. Pertanto il codice Kotlin può essere chiamato da Java e viceversa.

2. Come si dichiarano le variabili in Kotlin? In che modo si differenzia la dichiarazione rispetto a quella di Java?

   Ci sono due differenze principali tra la dichiarazione di variabili in Java e Kotlin:

   • Il tipo di dichiarazione In Java la dichiarazione appare così:

     String s = "Java String";
     int x = 10;
     

     In Kotlin la dichiarazione appare così:

     val s: String = "Hi"
     var x = 5
     

     In Kotlin, la dichiarazione inizia con un val e un var seguito dal tipo opzionale. Kotlin può rilevare automaticamente il tipo utilizzando l’inferezza del tipo.

   • Valore predefinito È possibile fare quanto segue in Java:

     String s:
     

     La seguente dichiarazione di variabile in Kotlin non è valida.

     val s: String
     

3. Qual è la differenza tra la dichiarazione di val e var? Come convertire una Stringa in un Int?

   Le variabili val non possono essere cambiate. Sono simili ai modificatori final in Java. Una variabile var può essere riassegnata. Il valore riassegnato deve essere dello stesso tipo di dato.

   fun main(args: Array<String>) {
       val s: String = "Ciao"
       var x = 5
       x = "6".toInt()
   }
   

   Usiamo il metodo toInt() per convertire la Stringa in un Int.

4. Cosa sono la Null Safety e i tipi Nullable in Kotlin? Cos’è l’operatore Elvis?

   Kotlin dà molta importanza alla sicurezza del null, che è un approccio per prevenire le temute eccezioni Null Pointer utilizzando tipi nullable come String?, Int?, Float?, ecc. Questi agiscono come un tipo wrapper e possono contenere valori nulli. Un valore nullable non può essere aggiunto a un altro valore di tipo nullable o di base. Per recuperare i tipi di base dobbiamo utilizzare chiamate sicure che estraggono i tipi Nullable. Se durante l’estrazione il valore è nullo, possiamo scegliere se ignorarlo o utilizzare invece un valore predefinito. L’operatore Elvis viene utilizzato per estrarre in modo sicuro il valore dal Nullable. È rappresentato come ?: sopra il tipo nullable. Il valore a destra verrà utilizzato se il tipo nullable contiene un null.

   var str: String?  = "JournalDev.com"
   var newStr = str?: "Valore Predefinito" 
   str = null
   newStr = str?: "Valore Predefinito"
   

   

5. Cosa è un const? In che cosa differisce da un val?

   Per impostazione predefinita le proprietà val sono impostate a tempo di esecuzione. Aggiungere un modificatore const su un val lo renderebbe una costante a tempo di compilazione. Un const non può essere utilizzato con un var o da solo. Un const non è applicabile a una variabile locale.

6. Kotlin ci consente di utilizzare tipi primitivi come int, float, double?

   A livello di linguaggio, non possiamo utilizzare i tipi sopra menzionati. Ma il bytecode JVM compilato li ha certamente.

7. Qual è il punto di ingresso di ogni programma Kotlin?

   La funzione main è il punto di ingresso di ogni programma Kotlin. In Kotlin possiamo scegliere di non scrivere la funzione main all’interno della classe. Alla compilazione, la JVM la incapsula implicitamente in una classe. Le stringhe passate sotto forma di Array<String> vengono utilizzate per recuperare gli argomenti della riga di comando.

8. Come è diverso il !! dal ?. nel disimballaggio dei valori nullabili? Esiste un altro modo per disimballare i valori nullabili in modo sicuro?

   Il !! viene utilizzato per forzare il disimballaggio del tipo nullabile per ottenere il valore. Se il valore restituito è nullo, ciò porterebbe a un arresto anomalo durante l’esecuzione. Pertanto, l’operatore !! dovrebbe essere utilizzato solo quando si è assolutamente certi che il valore non sarà mai nullo. In caso contrario, si otterrà la temuta eccezione del puntatore nullo. D’altra parte, il ?. è un operatore Elvis che effettua una chiamata sicura. Possiamo utilizzare l’espressione lambda let sul valore nullabile per disimballare in modo sicuro come mostrato di seguito. Qui l’espressione let effettua una chiamata sicura per disimballare il tipo nullabile.

9. Come viene dichiarata una funzione? Perché le funzioni Kotlin sono conosciute come funzioni di livello superiore?

   fun sumOf(a: Int, b: Int): Int{
       return a + b
   }
   

   Il tipo di ritorno di una funzione è definito dopo il :. Le funzioni in Kotlin possono essere dichiarate alla radice del file Kotlin.

10. Qual è la differenza tra gli operatori == e === in Kotlin?

\== is used to compare the values are equal or not. === is used to check if the references are equal or not.

11. Elenca le modifiche di visibilità disponibili in Kotlin. Qual è il modificatore di visibilità predefinito?

-   public
-   internal
-   protected
-   private

`public` is the default visibility modifier.

12. Il seguente schema di ereditarietà viene compilato?

```
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(){

}
```

13. Quali sono i tipi di costruttori in Kotlin? In cosa differiscono? Come li si definisce nella propria classe?

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
}

}
```

14. Cos’è il blocco init in Kotlin

`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.

15. Come funziona l’interpolazione di stringhe in Kotlin? Spiega con un frammento di codice.

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.

16. Qual è il tipo degli argomenti all’interno di un costruttore?

By default, the constructor arguments are `val` unless explicitly set to `var`.

17. È “new” una parola chiave in Kotlin? Come si istanzia un oggetto di classe in Kotlin?

**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()
```

18. Qual è l’equivalente dell’espressione switch in Kotlin? In cosa differisce da switch?

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.

19. Cosa sono le classi di dati in Kotlin? Cosa li rende così utili? Come vengono definite?

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. [![kotlin interview questions data classes](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-data-classes.png)](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-data-classes.png)

20. Cosa sono le dichiarazioni di destrutturazione in Kotlin? Spiega con un esempio.

Destructuring Declarations is a smart way to assign multiple values to variables from data stored in objects/arrays. [![kotlin interview questions destructuring declarations](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-destructuring-declarations.png)](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.

21. Qual è la differenza tra funzioni inline e funzioni infix? Dai un esempio di ciascuna.

[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. [![kotlin interview questions inline functions](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-inline-functions.png)](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. [![kotlin interview questions infix notations](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-infix-notations.png)](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-infix-notations.png)

22. Qual è la differenza tra lazy e lateinit?

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

23. Come creare classi Singleton?

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.

24. Kotlin ha la parola chiave statica? Come creare metodi statici in Kotlin?

**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()`.

25. Qual è il tipo dell’array seguente?

```
val arr = arrayOf(1, 2, 3);
```

The type is Array<Int>.

Questo è tutto per le domande e risposte dell’intervista su Kotlin.