Kotlin インタビューの質問
KotlinはJetBrainsからの最新のJVMプログラミング言語です。GoogleはそれをJavaと共にAndroid開発の公式言語として採用しました。開発者は、Javaプログラミングで直面する問題に対処していると言います。私はたくさんのKotlinのチュートリアルを書いてきましたので、ここで重要なKotlinのインタビューの質問を提供します。
Kotlin の面接質問
(Kotlin no mensetsu shitsumon)
以下には、Kotlinの面接質問と回答を提供しています。これらのKotlinの面接質問は初心者だけでなく経験豊富なプログラマにも役立ちます。コーディングスキルをアップさせるためのコーディングの質問も含まれています。
- 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(){
}
```
- Kotlinにおけるコンストラクタの種類は何ですか？それらはどのように異なるのですか？クラス内でそれらを定義する方法はありますか？
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
}
}
```
- Kotlinにおけるinitブロックとは何ですか。
`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.
- Kotlinでは、文字列補間はどのように機能しますか？コードの一部を使って説明してください。
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`.
- Kotlinで「new」はキーワードですか？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()
```
- Kotlinにおけるswitch式の相当するものは何ですか？それは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.
- コトリンにおけるデータクラスとは何ですか？何がそれほど役に立つのですか？どのように定義されますか？
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://scdev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-data-classes.png)
- Kotlinにおける構造分解宣言とは何ですか？例を用いて説明してください。 (Kotlinにおける「構造分解宣言」とは何ですか？例を使って説明してください。)
Destructuring Declarations is a smart way to assign multiple values to variables from data stored in objects/arrays. [](https://scdev.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://scdev.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://scdev.nyc3.cdn.digitaloceanspaces.com/2018/04/kotlin-interview-questions-infix-notations.png)
- 怠惰（たいだ）と遅延初期化（ちえんしょきか）の違いは何ですか？(Taida to chien shokika no chigai wa nan desu ka?)
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.
- Kotlinにはstaticキーワードがありますか？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()`.
- 以下の配列の型は何ですか？
```
val arr = arrayOf(1, 2, 3);
```
The type is Array<Int>.
これがKotlinのインタビューの質問と回答に関するすべてです。