Kotlinの基本構文一覧

## 1. HelloWorld
```kotlin:HelloWorld.kt
fun main() {
    println("Hello, World!")
}
```
## 2. 変数宣言
`val`で読み取り専用の変数を宣言します。
```kotlin
val number: Int = 10 // 整数型
val str: String = "Hello Kotlin" // 文字列型
number = 15 // エラー。Val cannot be reassigned
```
`var`で通常の変数を宣言します。
```kotlin
var str: String = "Hello Kotlin" // 文字列型
var number: Int = 10 // 整数型
number = 15
```
Kotlinは変数の型を推論してくれるので、明示的な型の宣言は必要ないことが多いです。
```kotlin
var str = "Hello Kotlin" // Stringに推論される
var number = 10 // Intに推論される
```
Kotlinの基本のデータ型は以下の通りです。
| データ型 | 値 |
|:-:|:-:|
| Byte  | 8ビット整数  |
| Short  | 16ビット整数  |
| Int | 32ビット整数 |
| Long | 64ビット整数 |
| Float | [単精度浮動小数点](https://ja.wikipedia.org/wiki/%E5%8D%98%E7%B2%BE%E5%BA%A6%E6%B5%AE%E5%8B%95%E5%B0%8F%E6%95%B0%E7%82%B9%E6%95%B0) |
| Double | [倍精度浮動小数点](https://ja.wikipedia.org/wiki/%E5%80%8D%E7%B2%BE%E5%BA%A6%E6%B5%AE%E5%8B%95%E5%B0%8F%E6%95%B0%E7%82%B9%E6%95%B0) |
| Char | 16ビットUnicode文字 |
| Boolean | 'true'または'false' |
| String | 文字列 |

## 3. 分岐
### if-else
```kotlin
if (number > 0) {
    println("正の数")
} else if (number < 0) {
    println("負の数")
} else {
    println("ゼロ")
}
```
Kotlinのif文は式であるため以下のように書ける。
```kotlin
val a = 5
val b = 10
var max = if (a > b) a else b
```
### when
```kotlin
var x = 1
when (x) {
    1 -> println("x is 1")
    2 -> println("x is 2")
    else -> println("x is else")
}
```
kotlinのwhen文は式であるため以下のように書ける。
```kotlin
var result = when (x) {
    1 -> "x is 1"
    2 -> "x is 2"
    else -> "x is neither 1 nor 2"
}
```
## 4. 繰り返し
### for
```kotlin
val numbers = listOf("one", "two", "three")
for (item in numbers) {
    println("item is $item")
}

for (i in 1..10) {
    println(i)
}
```
### while
```kotlin
var x = 10
while (x > 0) {
    x--
    println(x)
```
### do-while
```kotlin
x = 10
do {
    x--
    println(x)
} while (x > 0)
```
### repeat
```kotlin
repeat(5) {
    println("Hello")
}
```
## 5. 関数
`fun 【関数名】(【引数】)【戻り値の型】{}`
```kotlin
fun add(a: Int, b: Int): Int {
    return a + b
}
fun main() {
    println(add(5, 10)) // 15
}
```
## 6. クラスとオブジェクト
以下は[プライマリコンストラクタ](https://kotlin.keicode.com/lang/classes-constructor.php)の例。
プロパティの宣言と初期化を1行でまとめることができる。
```kotlin
// クラスの宣言。プライマリコンストラクタを使ってプロパティを宣言。
class Person(var name: String, var age: Int) {
    // メソッド
    fun introduce() {
        println("My name is $name and I am $age years old.")
    }
}
fun main() {
    // オブジェクトの生成。プライマリコンストラクタの値を引数として渡す。
    val person = Person("Alice", 20)
    // メソッドの呼び出し。
    person.introduce() // My name is Alice and I am 20 years old.
}
```
以下はオブジェクトを生成してからプロパティを設定する例
```kotlin
class User1 {
    var name: String = ""
}
fun main() {
    // オブジェクトを宣言してからプロパティを設定
    val user = User1()
    user.name = "Yamada"
    println(user.name) // Yamada
}
```
## 7. エラー処理
```kotlin
try {
    val result = 10 / 0
} catch (e: ArithmeticException) {
    println("Cannot divide by zero!")
}
```
## 8. List（配列）
### List
後から要素を追加したい場合は`MutableList`を使用します。
```kotlin
val numbers: List<Int> = listOf(1, 2, 3, 4, 5)
// Listにはaddできない。（コンパイルエラー）
// numbers.add(6)
// Listの値を取得する
println(numbers[0])

val strings: MutableList<String> = mutableListOf("one", "two", "three")
// MutableListにはaddできる。
strings.add("four")
println(strings[0])
```
### Set
Setは値が重複しない要素を保持します。
`contains`で要素が存在するか確認できます。
後から要素を追加したい場合は`MutableSet`を使用します。
```kotlin
val numbersSet: Set<Int> = setOf(1, 2, 3, 1)
// Setには重複しない要素が保持される
println(numbersSet) // [1, 2, 3]
// 値が存在しているかの確認ができる
println(numbersSet.contains(1)) // true

val stringsSet: MutableSet<String> = mutableSetOf("one", "two", "three")
// MutableSetにはaddできる
stringsSet.add("four")
```
## 9. 辞書（連想配列）
```kotlin
// 変更不可
val capitals: Map<String, String> = mapOf("France" to "Paris", "Japan" to "Tokyo")
// 値の取得
println(capitals["France"])

// 変更可
val mutableCapitals: MutableMap<String, String> = mutableMapOf("France" to "Paris")
// 値の設定
mutableCapitals["Japan"] = "Tokyo"
```
## 10. ファイル入出力
`use`を使うことでリソースを自動で閉じる。
### ファイル読み込み
```kotlin
import java.io.File

fun readFile(filePath: String) {
    File(filePath).bufferedReader().use { reader ->
        val content = reader.readText()
        println(content)
    }
}

fun main() {
    val filePath = "input.txt" // 読み込みたいファイルのパス
    readFile(filePath)
}
```
### ファイル書き込み
```kotlin
import java.io.File

fun writeFile(filePath: String, content: String) {
    File(filePath).bufferedWriter().use { writer ->
        writer.write(content)
    }
}

fun main() {
    val filePath = "output.txt" // 書き込みたいファイルのパス
    val content = "Hello, Kotlin!" // ファイルに書き込む内容
    writeFile(filePath, content)
}
```

以上です。