Kotlinのソースを表示

{{Pathnav|メインページ|工学|情報技術|プログラミング}}

'''Kotlin'''は、[[w:JetBrains|JetBrains]]社によって開発された静的型付けされたオブジェクト指向のプログラミング言語で、[[W:Java仮想マシン|Java仮想マシン]](JVM)上で動作します。[[JavaScript]]や、[[W:LLVM|LLVMフレームワーク]]を介して多くのプラットフォームで実行可能なコードにもコンパイルできます。

Kotlinは、複数のコンパイルターゲットをサポートしています。Kotlin/JVMは従来のJava仮想マシン上でアプリケーションを実行し、Kotlin/JSはJavaScriptへのコンパイルを可能にします。Kotlin/Nativeはネイティブコードへのコンパイルを実現し、LLVMを活用してさまざまなプラットフォームに対応します。

特に'''Kotlin/Wasm'''は、Kotlinの新しいコンパイルターゲットであり、[[WebAssembly]]をサポートする環境やデバイス上で実行可能なアプリケーションを作成することができます。これにより、Kotlinの強力な機能と柔軟性を活用して、Webアプリケーションやクライアントサイドのプログラミングにも取り組むことができます。

Kotlinは[[Java]]よりも簡潔で型安全性が高く、[[Scala]]よりもシンプルな言語を目指して開発されました。Scalaと比較して、簡略化された結果、コンパイルが高速化され、IDEでの言語サポートも充実しています。また、KotlinはJavaと完全な互換性があり、Java開発者は徐々に導入することができます。

完全なJava互換性により、既存のJavaライブラリや既存のコードベースとシームレスに連携できます。[[プログラミング/Null安全性|null安全性]]は言語に組み込まれており、開発者は実行時のNullPointerExceptionのリスクを軽減できます。簡潔で表現力の高い文法は、コードの可読性と生産性を向上させ、関数型プログラミングのサポートにより、より柔軟なプログラミングスタイルを可能にします。拡張関数の機能により、既存のクラスに追加のメソッドを定義できます。

特に、KotlinはAndroidアプリケーション開発において重要な役割を果たしており、2019年にGoogleはKotlinをAndroidの推奨プログラミング言語として指定しました。既存のAndroidアプリケーションは、アプリケーション全体を書き換えることなくKotlinで新機能を実装することができます。

2024年現在、KotlinはGitHub上でのオープンソースプロジェクトとして継続的に発展しており、[[w:JetBrains|JetBrains]]とGoogle、そしてKotlin Foundationによってサポートされています。Kotlin Foundationが商標「Kotlin」を管理しています。

モバイルアプリケーション開発、特にAndroidにおいて非常に強力です。サーバーサイドアプリケーションの開発、クロスプラットフォーム開発、Web開発、さらにはデータサイエンスの分野でも利用されており、幅広いプログラミングニーズに対応できる汎用的な言語となっています。

== はじめに ==
=== 予備知識 ===
Kotlinは多様なプラットフォームで利用できるモダンで柔軟なプログラミング言語です。

このチュートリアルに取り組む前に、以下の予備知識が役立ちます。

;プログラミング基礎:
: 変数、制御構造（条件分岐、ループ）、関数など、プログラミングの基本的な概念を理解していることが望ましいです。これらの概念はKotlinを含む多くのプログラミング言語で共通しています。
;オブジェクト指向プログラミング（OOP）:
:Kotlinはオブジェクト指向の概念を採用しており、クラス、オブジェクト、継承、ポリモーフィズムなどのOOPの基本的な理解が重要です。
;Javaの基本知識（Kotlin/JVMの場合）:
:KotlinはJavaとの高い互換性を有しています。Javaの基本的な概念やJavaの標準ライブラリについての基本的な知識があると、Kotlin/JVMの理解がより深まります。
;Web開発基礎（Kotlin/JSの場合）:
:Kotlin/JSはJavaScriptに変換され、Web開発に利用されます。HTMLやCSS、基本的なWeb開発の知識があると、Kotlin/JSを使用したWebアプリケーションの開発がスムーズに進みます。
;ネイティブ開発基礎（Kotlin/Nativeの場合）:
:Kotlin/Nativeはネイティブな実行コードを生成し、組み込みシステムやiOSアプリケーションなどで利用されます。ネイティブ開発の基本的な知識があると、Kotlin/Nativeを活用した開発がしやすくなります。

以上の予備知識を持っていると、Kotlinをより効果的に学習し、異なるプラットフォームでの利用に対応することができます。各プラットフォームにおけるKotlinの特徴や最適な利用法を理解することで、幅広い開発環境で柔軟かつ効率的なプログラミングが可能になります。

==== プログラミング経験者へ ====
Kotlinを学ぶ際に他の言語のプログラミング経験がある場合、以下のアドバイスが役立つかもしれません。

;Java経験者へのアドバイス:
:KotlinはJavaとの互換性が高いため、既存のJavaコードとの統合がスムーズに行えます。JavaのコードをKotlinに変換することも可能です。
:Kotlinの拡張関数やラムダ式など、新しい機能を積極的に試してみましょう。これにより、コードの簡潔性と可読性が向上します。
;他の静的型付け言語経験者へのアドバイス:
:Kotlinも静的型付け言語であり、型推論が強力です。しかし、null安全性や拡張関数など、他の言語にはない独自の機能にも焦点を当てて学習しましょう。
:Kotlinのコルーチンを利用して非同期処理を書くことで、他の言語での非同期コードよりもシンプルで効率的なコードを書けます。
;関数型プログラミング経験者へのアドバイス:
:Kotlinは関数型プログラミングの概念をサポートしています。ラムダ式や高階関数を駆使して、より宣言的で簡潔なコードを書く方法を探求してみてください。
:Kotlinの拡張関数やパターンマッチングを利用することで、関数型プログラミングの手法をさらに発展させることができます。
;Android開発者へのアドバイス:
:KotlinはAndroidの公式開発言語として広く採用されています。既存のJavaベースのAndroidプロジェクトでもKotlinへの移行が可能です。Android Studioとの統合を利用して、Androidアプリケーションの開発にKotlinを組み込んでみましょう。

総じて、Kotlinは他のプログラミング言語において得た経験を活かしやすい言語です。適応期間は短く、生産性を高めるために積極的に新しい機能や手法を試してみることが重要です。また、公式のドキュメントやサンプルコードを利用して、Kotlinの言語仕様やベストプラクティスに精通することもおすすめです。

==== プログラミング未経験者へ ====
プログラミング未経験者がKotlinやプログラミング全般に取り組む際のアドバイスは以下の通りです:

;基本的なプログラミング概念の理解:
:プログラミングの基本概念（変数、条件分岐、ループなど）を理解することから始めましょう。これらの基本的な概念はほぼ全てのプログラミング言語で共通しています。
;Kotlinの特徴を理解:
:KotlinがJavaとの互換性が高く、Androidアプリケーション開発で広く使われていることを知りましょう。Kotlinはコードの簡潔性や可読性を向上させるための多くの機能を提供しています。
;オンライン教材やチュートリアルを活用:
:オンライン上には多くの無料または低コストでプログラミングを学べる教材やチュートリアルがあります。これらのリソースを活用して基礎から学び、実際に手を動かしながら進めてみましょう。
;実践を重視:
:理論だけでなく、実際にコードを書いてみることが非常に重要です。小さなプログラムから始め、段階的に難易度を上げながら進めていくと良いでしょう。
;エラーを恐れず、デバッグの練習:
:プログラムでエラーが発生することはよくあることです。エラーを見つけて修正することはプログラミングの一部であり、そのプロセスを恐れずに経験してみましょう。
;プロジェクトを通じた学習:
:実際のプロジェクトに取り組むことで、プログラミングの実践的な側面を理解しやすくなります。小さなプロジェクトから始め、徐々に複雑性を増していくと良いでしょう。
;コミュニティへの参加:
:Kotlinやプログラミングに関するコミュニティやフォーラムに参加すると、他の学習者や経験者からのアドバイスやサポートを得ることができます。質問をしてコミュニケーションをとることも大切です。
;継続的な学習と興味を持つ:
プログラミングは絶え間ない学習が求められる分野です。新しい技術やツールに興味を持ち、継続的に学び続けることでスキルを向上させることができます。

プログラミングはスキルの向上に時間がかかるものですが、継続的な努力と実践を通じて着実に成長していきます。最初は小さなステップから始め、徐々に進んでいくことが大切です。

=== Hello world ===
{{先頭に戻る|style=border-top:1px solid gray;}}
他の多くのチュートリアルがそうであるように、 私たちもまずはKotlinの世界にあいさつすることから始めましょう。hello.ktというファイルを作り、次のように書いて保存して下さい(Kotlinのソースファイルの拡張子は .kt です)。

;[https://pl.kotl.in/JCCTJjX4_ hello.kt]:<syntaxhighlight lang=kotlin copy>
fun main() = println("Hello, World!")
</syntaxhighlight>
それでは、ソースプログラムをコンパイルして実行してみましょう。
:<syntaxhighlight lang="console">
% kotlinc hello.kt -include-runtime -d hello.jar
% java -jar hello.jar
Hello, World!
% _
</syntaxhighlight>

# <code>fun main()</code> :
#* <code>fun</code>は関数（function）を宣言するためのキーワードです。
#* <code>main</code>はプログラムのエントリーポイントとなる特別な関数の名前です。通常、プログラムの実行が始まるところです。
# <code>=</code> :
#* このイコール記号は、関数の本体が始まることを示します。Kotlinでは、単一の式の関数を記述する際に、本体とイコールを省略して1行で記述できます。
# <code>println("Hello, World!")</code> :
#* <code>println</code>はコンソールに文字列を表示するための関数です。<code>("Hello, World!")</code>は引数として渡される文字列です。
#* この行全体は、関数の呼び出しとして、文字列 "Hello, World!" をコンソールに表示するものです。

これにより、この一行のコードは「<code>main</code>という関数を宣言し、その中で 'Hello, World!' という文字列をコンソールに表示する」という単純なプログラムを実現しています。Kotlinはこのようにシンプルかつ読みやすい構文を持っており、初学者にも優れた学習言語となっています。

<br style="clear:both">

=== クイックツアー ===
Kotlinのクイックツアーでは、基本的な構文や機能に焦点を当て、簡単なコード例を通じて言語の特徴を理解していきます。

# 変数と基本的なデータ型
#:<syntaxhighlight lang=kotlin copy>
fun main() {
    // 変数の宣言
    val message: String = "Hello, Kotlin!"

    // 自動型推論も可能
    val number = 42

    // 文字列テンプレート
    println("$message The answer is $number")
}
</syntaxhighlight>
# 条件分岐とループ
#:<syntaxhighlight lang=kotlin copy>
fun main() {
    val score = 75

    // 条件分岐
    if (score >= 80) {
        println("Great job!")
    } else if (score >= 60) {
        println("Good job!")
    } else {
        println("You can do better.")
    }

    // ループ
    for (i in 1..5) {
        println("Count: $i")
    }
}
</syntaxhighlight>
# 関数の定義と呼び出し
#:<syntaxhighlight lang=kotlin copy>
fun main() {
    // 関数の呼び出し
    greet("Alice")

    // 関数の定義
    fun greet(name: String) {
        println("Hello, $name!")
    }
}
</syntaxhighlight>
# クラスとオブジェクト
#:<syntaxhighlight lang=kotlin copy>
fun main() {
    // クラスの定義
    class Person(val name: String, val age: Int)

    // オブジェクトの作成
    val person = Person("John", 25)

    // プロパティへのアクセス
    println("${person.name} is ${person.age} years old.")
}
</syntaxhighlight>
# Null安全性
#:<syntaxhighlight lang=kotlin copy>
fun main() {
    // Null許容型
    var name: String? = "Bob"

    // 安全呼び出し演算子
    val length: Int? = name?.length

    // Elvis演算子
    val result = name ?: "Guest"

    println("Name length: $length")
    println("Result: $result")
}
</syntaxhighlight>
# 拡張関数
#:<syntaxhighlight lang=kotlin copy>
fun main() {
    // 拡張関数の定義
    fun String.addExclamation(): String {
        return "$this!"
    }

    // 拡張関数の呼び出し
    val greeting = "Hello".addExclamation()
    println(greeting)
}
</syntaxhighlight>
# コルーチン
#:<syntaxhighlight lang=kotlin copy>
import kotlinx.coroutines.*

fun main() {
    // コルーチンの起動
    GlobalScope.launch {
        delay(1000) // 1秒待つ
        println("World!")
    }

    println("Hello, ")

    // プログラムを待機して終了しないようにする
    Thread.sleep(2000) // 2秒待つ
}
</syntaxhighlight>
# Kotlin DSL
#:<syntaxhighlight lang=kotlin copy>
data class Person(val name: String, val age: Int)

fun buildPerson(block: PersonBuilder.() -> Unit): Person {
    val builder = PersonBuilder()
    builder.block()
    return builder.build()
}

class PersonBuilder {
    var name: String = ""
    var age: Int = 0

    fun build(): Person {
        return Person(name, age)
    }
}

fun main() {
    val person = buildPerson {
        name = "Alice"
        age = 30
    }

    println("Built person: $person") // => Built person: Person(name=Alice, age=30)
}
</syntaxhighlight>
#: この例では、Kotlin DSLを使用して、特定のドメイン（ここでは<code>Person</code>オブジェクトの構築）に特化した言語拡張を行っています。
# Smart cast
#: Kotlinは型の安全性を高めるためにスマートキャストを提供しています。これにより、条件分岐やインスタンスのチェック後に自動的にキャストが行われ、冗長なキャストを省略できます。
#:<syntaxhighlight lang=kotlin copy>
fun processValue(value: Any) {
    if (value is String) {
        // valueはString型として扱われる
        println(value.length) // ここでlengthプロパティにアクセスできる
    }
    
    if (value is Int) {
        // valueはInt型として扱われる
        println(value * 2) // ここでvalueをIntとして使用できる
    }
    
    // スマートキャストを利用することで、valueがどの型であるかを明示的にキャストする必要がない
}

fun main() {
    processValue("Hello") // 出力: 5 (Stringの長さ)
    processValue(10)      // 出力: 20 (Intを2倍にした値)
}
</syntaxhighlight>

これらの例はKotlinの基本を紹介するものであり、より高度な概念や機能も学ぶことができます。

{{:Kotlin/インストール方法}}
{{:Kotlin/実行方法}}

== 特徴 ==
{{先頭に戻る}}
; [[W:コンパイル型言語|コンパイル型言語]] : Kotlinはコンパイラーとして実装されています。REPLやスクリプティングエンジンもあります。
:; Kotlin/JVM: １つまたは複数のソースコードをコンパイルしてJavaバイトコードを生成し、生成したJavaバイトコードを実行します。
:; Kotlin/JS: １つまたは複数のソースコードをコンパイルしてJavaScriptを生成し、生成したJavaScriptを実行します。
:; Kotlin/Native: １つまたは複数のソースコードをコンパイルしてLLVMインフラストラクチャーをバックエンドに実行形式を生成し、生成した実行形式を実行します。
:; Kotlin/Wasm: １つまたは複数のソースコードをコンパイルしてWebAssembly（Wasm）バイナリを生成し、WebAssembly仮想マシン上で実行します。
; [[W:静的型付け|静的型付け]] : 値・変数・関数のパラメーター・関数の戻値などの型はコンパイル時に検証され、[[W:型安全性|型安全性]]が担保されます。
; [[W:例外#コンピュータと例外|例外]] : try-catch-finally 形の例外処理をサポートします。
; [[W:多重定義#演算子の多重定義|演算子オーバーロード]]: サポートします。<code>a + b</code> は、メソッド形式 <code>a.plus(b)</code> と同義です。
; [[W:多義定義|関数オーバーロード]] : 同じ名前で引数の数が異なる関数を定義することが可能です。
; [[#ラムダ式|ラムダ式]]: サポートします。<code>{ a: Int, b: Int -> a + b }</code>
; [[#無名関数|無名関数]]: サポートします。<code>fun(a: Int, b: int) = a + b</code>
; [[#拡張関数|拡張関数]]: 既存のクラスに新しいメソッドを生やすことができます。これは Java のクラスライブラリーのクラスも例外ではありません。
; 宣言や定義にはキーワードを伴う: 関数定義なら <code>fun</code>、定数宣言なら <code>val</code>、変数宣言なら <code>var</code>、クラス定義なら <code>class</code> など、明示的にキーワードを使い宣言するので grep フレンドリーです。また、列挙型は <code>enum</code> ではなく、<code>enum class</code> で列挙だと知らなくても '''class''' で検索すれば見落としません。C/C++は、<code>int f(int ch){...}, int i = 9;</code>のように、よく読まないと関数定義なのか変数宣言かわからないのとは対照的です。特にC++は、<code>int a(3)</code>が関数定義なのか変数宣言なのかに曖昧さがあり、パースの時点では確定せずコンパイラーもプログラマーも悩まされます。
; [[W:型推論|型推論]] : サポートします。
; [[W:ガベージコレクション|ガベージコレクション]] : サポートします。
; [[W:クラス (コンピュータ)|クラス]] : クラスベースのオブジェクト指向言語です。
:; 全てがオブジェクト : Javaで言うプリミティブもオブジェクトで、メソッドを持ちます。
:; 祖先クラス : Any
:; [[#コンストラクタ|コンストラクター]] : [[#プライマリーコンストラクター|プライマリーコンストラクター]]・[[#セカンダリコンストラクター|セカンダリコンストラクター]]・[[#init|init]] の３つのメソッドがインスタンス化の機能が割振られます。
:; [[#デストラクタ|デストラクター]] : ありません。
:; [[W:継承 (プログラミング)|継承]] : 単一継承をサポートします。
:; 抽象クラス : [[Java]] や [[Go]] の interface や [[Swift]] の protocol はありませんが、abstract class があります。
; Mix-in : サポートします。
; [[#名前空間|名前空間]] : [[#パッケージ|パッケージ]]が名前空間を持ちます。
; defer : ありません。
; 分岐構造は式 : [[#if|if]], [[#when|when]]は式です。
; 文末の<code>;</code>（セミコロン）: 必要ありません。

== コード・ギャラリー ==
{{先頭に戻る}}
=== エラトステネスの篩 ===
{{先頭に戻る|title=コード・ギャラリーに戻る|label=コード・ギャラリー}}
エラトステネスの篩を、若干 Kotlin らしく書いてみました。

;[https://pl.kotl.in/YOo5wiNi3 エラトステネスの篩]:<syntaxhighlight lang=kotlin line copy>
fun eratosthenes(n: Int) {
    var sieve = BooleanArray(n + 1){ it >= 2 }
    for (i in 2..<sieve.size) {
        if (!sieve[i])
            continue;
        for (j in i * i until sieve.size step i)
            sieve[j] = false
        if (i * i >= sieve.size)
	        break;
    }
    for (i in 2..<sieve.size) {
        if (!sieve[i])
            continue;
        print("$i ")
    }
}

fun main() {
    eratosthenes(100);
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 
</syntaxhighlight>
: 使用頻度の高い sieve は、実行効率の良いプリミティブ型配列の BooleanArray として、初期化式を it >= 2 として宣言と同時に素数候補をマークしました。
: <var>i</var> のループはオーソドックスな IntRange をコレクションにした for ですが、<var>j</var> のループは少し変則的で until は制御構造に見えますが、メソッド <code>infix Int.until(to: Int) : IntProgression</code> で、infix 修飾による中置構文です。

=== 最大公約数と最小公倍数 ===
{{先頭に戻る|title=コード・ギャラリーに戻る|label=コード・ギャラリー}}
最大公約数と最小公倍数を、若干 Kotlin らしく書いてみました。

;[https://pl.kotl.in/eumYGumM7 最大公約数と最小公倍数]:<syntaxhighlight lang=kotlin line copy>
tailrec fun gcd2(a: Int, b: Int): Int = if (b == 0) a else gcd2(b, a % b)
fun gcd(vararg numbers: Int): Int = numbers.reduce(::gcd2)
fun lcm2(a: Int, b: Int): Int = a * b / gcd2(a, b)
fun lcm(vararg numbers: Int): Int = numbers.reduce(::lcm2)

fun main() {
    println("gcd2(30, 45) => ${gcd2(30, 45)}")
	println("gcd(30, 72, 12) => ${gcd(30, 72, 12)}")
	println("lcm2(30, 72) => ${lcm2(30, 72)}")
	println("lcm(30,42,72) => ${lcm(30,42,72)}")
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
gcd2(30, 45) => 15
gcd(30, 72, 12) => 6
lcm2(30, 72) => 360 
lcm(30,42,72) => 2520
</syntaxhighlight>
: 関数 gcd2() は、2つの整数の最大公約数を[[W:ユークリッドの互除法|ユークリッドの互除法]]で求めています。
:: gcd2() の修飾子 <code>tailrec</code> は、コンパイラーに末尾再帰が行なわれていることを教え、再帰をループにするヒントを与えています。
: 関数 gcd() は可変引数関数で、全ての引数に gcd2() を適用し最大公約数を返します。
: 関数 lcm2() は、2つの整数の最小公倍数を、<math>GCD(m,n) \cdot LCM(m,n)=m \cdot n</math>を利用して求めています。
: 関数 lcm() は可変引数関数で、全ての引数に lcm2 を適用し最小公倍数を返します。
それぞれの関数定義は式形式で１行なので拍子抜けですが、概念を簡素にかけていると思います。

=== 二分法 ===
{{先頭に戻る|title=コード・ギャラリーに戻る|label=コード・ギャラリー}}
[[W:二分法|二分法]]を、若干 Kotlin らしく書いてみました。

;[https://paiza.io/projects/HwIg-40sBXp5GOFWFTLKMA?language=kotlin 二分法]:<syntaxhighlight lang=kotlin line copy>
import kotlin.math.abs

tailrec fun bisection(low_: Number, high_: Number, f: (Double) -> Double) : Double {
    var low = low_.toDouble()
    var high = high_.toDouble()
    val x = (low + high) / 2;
    val fx = f(x);
    if (abs(fx) < +1.0e-10)
        return x;
    if (fx < 0.0)
        low = x;
    else
        high = x;
    return bisection(low, high, f);
}

fun main() {
    println(bisection(0, 3){x : Double -> x - 1})
    println(bisection(0, 3){x : Double -> x * x - 1})
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
0.9999999999417923 
1.0000000000291038
</syntaxhighlight>
: [[旧課程(-2012年度)高等学校数学B/数値計算とコンピューター#2分法]]の例を Kotlin に移植しました。
: 命題の式をラムダで渡すのが肝ですが、Kotrinは関数の最後パラメーターが関数型の場合括弧の外に追い出せるので
:: <code>bisection(0, 3){x : Double -> x - 1}</code>のような表現ができます。
: 引数で受取った範囲を一旦varに移替えているのは、関数の引数がイミュータブルなためです。
: また、どうせローカル変数に移すならパラメータは Number 型としてIntなども受け入れるようにし、.toDouble()で型を揃えています。
: このコードはまた、<code>[[#tailrec|tailrec]]</code> の好例にもなっています。

=== 複素数型 ===
{{先頭に戻る|title=コード・ギャラリーに戻る|label=コード・ギャラリー}}
オーソドックスな複素数型の実装（Kotlinの標準ライブラリーには複素数型が見当たらなかったので）

{{:Kotlin/Complex.kt}}

=== クラス定義とインスタンス化とメンバー関数 ===
;[https://paiza.io/projects/9XyNAIQyFNLCewZO020A6Q?language=kotlin シンプルなクラス定義]:<syntaxhighlight lang=kotlin line highlight="1-4,7,11" copy>
class Hello(val s : String = "world") {
    override fun toString() = "Hello $s!"
    fun print() = println(s)
}

fun main() {
    val hello1 = Hello()
    println(hello1)
    hello1.print()

    val hello2 = Hello("my friend")
    println(hello2);
    hello2.print()

    print(
"""
Hello::class.simpleName => ${Hello::class.simpleName}
hello1 => $hello1
hello2.s => ${hello2.s}
"""
    )
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
Hello world!
world
Hello my friend!
my friend

Hello::class.simpleName => Hello
hello1 => Hello world! 
hello2.s => my friend
</syntaxhighlight>
: [[Ruby#クラス]]の例を、Kotlin に移植しました。
: 冒頭4行がクラス定義です。
: クラス定義に、他のオブジェクト指向言語ならコンストラクタに渡すような引数が渡されています。
: メンバーを公開するケースなら、この様に宣言的な引数リストを使うとメンバー定義と暗黙の初期値を与えられます。
: toString は、オブジェクトを文字列化するメンバー関数で、Anyの同名のメンバー関数をオーバーライドしています。
: print は、このクラスに独自なメンバー関数で、println() の戻値型(= Unit)を戻値型としています。

=== ファイルの読出し ===
{{先頭に戻る|title=コード・ギャラリーに戻る|label=コード・ギャラリー}}
;[https://paiza.io/projects/C2zvgreLywbWQvIGSzHGug?language=kotlin JavaのI/Oシステムを使いファイルを読込む]:<syntaxhighlight lang=kotlin line copy>
import java.nio.file.Files
import java.nio.file.Paths
import java.nio.charset.Charset
import java.io.IOException

fun main() {
    try {
        for (s in Files.readAllLines(Paths.get("/etc/hosts"), Charset.forName("UTF-8"))) {
            println(s)
        }
    } catch (e: IOException) {
        e.printStackTrace()
    }
}
</syntaxhighlight>
;[https://paiza.io/projects/cfZOI-b1YK5S36_bao5Isw?language=kotlin readText版]:<syntaxhighlight lang=kotlin line copy>
import java.io.File

fun main(args: Array<String>) {
    print(File("/etc/hosts").readText())
}
</syntaxhighlight>

==チートシート ==
{{先頭に戻る}}
;[[#エントリーポイント|エントリーポイント]]
:;コマンドライン引数を受取らない場合
::<syntaxhighlight lang=kotlin copy>
fun main() {
    // ...
}
</syntaxhighlight>
:;コマンドライン引数を受取る場合
::<syntaxhighlight lang=kotlin copy>
fun main(args: Array<String>) {
    println(args.contentToString()) 
}
</syntaxhighlight>
;[[#コメント|コメント]]:<syntaxhighlight lang=kotlin style="width: fit-content" copy>
// Kotlinには、行末で終わるコメントと
fun main() { /*
              * 複数行に渡ることと
              * /*
                 * 入れ子にすることができる
                 * コメントがあります
                 */
               */
    println("Hello, World!") 
}
</syntaxhighlight>
;プリミティブデータ型
:{| class=wikitable style="text-align: center"
!データ型!!サイズ<hr>(ビット)!!初期値
|-
|Boolean||1||false
|-
|Byte||8||0
|-
|Short||16||0
|-
|Int||32||0
|-
|Long||64||0L
|-
|Float||32||0.0f
|-
|Double||64||0.0
|}
;[[#変数|変数宣言]]
:;[[#val|イミュータブル]]:<syntaxhighlight lang=kotlin inline>val 識別子 : 型 = 初期化式 ;</syntaxhighlight>
::;[[#型推論|型推論版]]:<syntaxhighlight lang=kotlin inline>val 識別子 = 初期化式 ;</syntaxhighlight>
:;[[#var|ミュータブル]]:<syntaxhighlight lang=kotlin inline>var 識別子 : 型 = 初期化式 ;</syntaxhighlight>
; リテラル
:; 整数リテラル:<syntaxhighlight lang=kotlin inline>123, 0b11010, 0o177, 0xbadbeef</syntaxhighlight> 
:; 浮動小数点数リテラル:<syntaxhighlight lang=kotlin inline>3.14, 1.2e-9</syntaxhighlight>
:; 文字リテラル:<syntaxhighlight lang=kotlin inline>'a', '漢', '¥t'</syntaxhighlight>
:; 文字列リテラル:<syntaxhighlight lang=kotlin inline>”abc”, "了解🏝👅"</syntaxhighlight>
::; 複数行に渡る文字列リテラル
::: <syntaxhighlight lang=kotlin style="width: fit-content" copy>
"""
複数行に渡る場合は
この様に
３つの"（ダブルクオーテーションマーク）で囲むことで記述できます。
"""
</syntaxhighlight>
:; 配列の生成:<syntaxhighlight lang=kotlin inline>arrayOf(2,3,5,7), Array(5){1+it)</syntaxhighlight>
; [[#制御構造|制御構造]]
:; [[#分岐|分岐]]
::; [[#if|if]]
:::;else節のないif
::::<syntaxhighlight lang=zig inline>if ( 条件式 ) 式</syntaxhighlight>
::::else節のないifは、値を取ろうとするとコンパイルエラーになります。
:::;ifの値
::::<syntaxhighlight lang=zig inline>if ( 条件式 ) 式１ else 式２</syntaxhighlight>
::::条件式が false でなければifの値は 式１
::::false ならば 式２
::; [[#when|when]]
:::;式で分岐:<syntaxhighlight lang=kotlin style="width: fit-content" copy>
when ( 式 ) {
    値0 -> 式０
    値1, 値2... , 値n　-> 式１
    in 範囲式 -> 式２
    !in 範囲式 -> 式３
    is 型 -> 式４
    !is 型 -> 式５
　　elase -> 式ｘ
}
</syntaxhighlight>
:::;式を省略すると true が仮定されます:<syntaxhighlight lang=kotlin style="width: fit-content" copy>
when {
    式０ -> 式０ｘ
    式１, 式２... , 式n　-> 式１ｘ
　　elase -> 式ｘ
}
</syntaxhighlight>
:::;値を返すwhen（による再帰）:<syntaxhighlight lang=kotlin style="width: fit-content" copy>
fun power(n: Int, i: Int) = when {
    i < 0 -> throw Exception("Negative powers of integers cannot be obtained.")
    i == 0 -> 1
    i == 1 -> n
    else -> n * power(n, i - 1)
}
</syntaxhighlight>
:; [[#繰返し処理|繰返し処理]]
::; [[#while|while]]
:::<syntaxhighlight lang=kotlin copy>
var i = 0
while (i < 5) {
    println(i)
    i++
}
</syntaxhighlight>
::; [[#do-while|do-while]]
:::<syntaxhighlight lang=kotlin copy>
var i = 0
do {
    println(i)
    i++
} while (i < 5)
</syntaxhighlight>
::; [[#for|for]]
:::<syntaxhighlight lang=kotlin copy>
for (i in 0 until 5) {
    println(i)
}
</syntaxhighlight>
; コレクション
:;リストの生成
:;マップの生成
:;リストへのアクセス
:;マップへのアクセス
:;フィルタリング
:;マップへの変換
; クラス
:;enum class
:;abstract class
; 関数
:; 関数呼出し
:; 関数定義

== KotlinとJavaの比較 ==
{{先頭に戻る}}
KotlinとJavaは、どちらもJava Virtual Machine（JVM）上で動作するプログラミング言語です。以下は、KotlinとJavaの主な比較ポイントです。

# Null Safety（null安全性）
#; Kotlin: Kotlinはnull安全性を重視しており、デフォルトで変数がnullになる可能性がある場合、その変数をnullableとして扱います。これにより、nullによる実行時のエラーを減少させます。
#; Java: 近年のJavaバージョンでは、<code>Optional</code>や<code>Nullable</code>などの概念が導入され、nullの扱いが改善されました。しかし、Kotlinのnull安全性はより厳格であり、コンパイル時の警告やエラーが発生しやすくなっています。
# コードの簡潔性
#; Kotlin: KotlinはJavaに比べてコードが簡潔で読みやすくなっています。これは、Kotlinがnullチェックや型推論などを自動的に処理し、冗長なコードを排除できるからです。
#; Java: Javaも近年ではラムダ式やストリームAPIなど、コードの簡潔性を向上させる機能が導入されていますが、依然として冗長なコードが残ることがあります。
# 関数型プログラミング
#; Kotlin: Kotlinは関数型プログラミングをサポートしており、ラムダ式や高階関数の使用が簡単です。
#; Java: Javaも関数型プログラミングをサポートしていますが、Kotlinの方がよりシンプルになっています。
# 互換性
#; Kotlin: KotlinはJavaのライブラリやフレームワークを使用することができ、Javaとの相互運用性が高いです。また、JavaからKotlinに変換することも可能です。
#; Java: JavaはKotlinのコードを直接使用することはできませんが、既存のJavaコードとの連携がスムーズです。
# パフォーマンス
#; Kotlin: KotlinはJavaに比べて少し遅いとされていますが、実際のアプリケーションではその違いがほとんど実感できないことが多いです。KotlinはJavaのバイトコードに変換されるため、ほとんど同じパフォーマンスを実現できます。
# ツールのサポート
#; Kotlin: KotlinはJavaと同じツールを使用できるため、Javaエコシステムのメリットを享受しながら、より現代的な言語機能を利用できます。

総合的に見ると、KotlinはJavaよりも簡潔で読みやすく、より現代的な言語機能を備えています。ただし、Javaのライブラリやフレームワークを使用する場合は、Javaを使用することが必要な場合があります。

== KotlinとScalaの比較 ==
{{先頭に戻る}}
KotlinとScalaは、どちらもJVM（Java Virtual Machine）上で動作する静的型付け言語であり、それぞれ異なる特徴を持っています。以下に、KotlinとScalaをいくつかの側面で比較してみます。

# パフォーマンス
#; Kotlin: Kotlinは、Javaと同等のパフォーマンスを提供し、メモリ使用量が比較的少ないです。Androidアプリケーションの開発においては特に優れた性能を発揮します。
#; Scala: Scalaは一般的にはJavaよりも高速であるとされていますが、同時に多くのメモリを使用します。複雑なシステムの開発において、高いパフォーマンスが求められる場面で利用されます。
# 文法
#; Kotlin: Kotlinの文法はJavaに似ており、より簡素であり、Javaからの移行が容易です。これにより、Java開発者にとっては理解しやすいものです。
#; Scala: Scalaの文法は高度であり、関数型プログラミングの概念を強力にサポートしています。初めてのユーザーにとっては学習コストが高いかもしれませんが、高度な機能を提供しています。
# 開発用途
#; Kotlin: Kotlinは主にAndroidアプリケーションの開発に最適化されています。Android Studioでのサポートが強力であり、Androidエコシステムとの統合がスムーズです。
#; Scala: Scalaは複雑なシステムや大規模なプロジェクトの開発に適しています。特に関数型プログラミングの特徴を生かした開発に向いています。
# 可読性
#; Kotlin: KotlinはJavaと同じように、シンプルで読みやすいコードを書くことができます。文法がシンプルであるため、可読性が高いです。
#; Scala: Scalaは高度な機能を提供するが故に、可読性が低下する可能性があります。特に初心者にとっては、学習コストが高いと感じることがあります。
# 拡張性
#; Kotlin: Kotlinはよりシンプルでクラスベースのプログラミングスタイルを提供しており、拡張性があります。拡張関数や拡張プロパティなどが利用できます。
#; Scala: Scalaは関数型プログラミングの特徴を強調しており、高度な拡張性を提供しています。パターンマッチングや型クラスなどが利用できます。
総合的に見ると、KotlinはJavaからの移行が容易であり、Androidアプリケーションの開発に特に適しています。一方で、Scalaは関数型プログラミングの特徴を生かして複雑なシステムの開発に向いており、高度な拡張性を提供しています。選択する言語は、開発の目的や開発者のスキルセットによって異なることがあります。

== KotlinとSwiftの比較 ==
{{先頭に戻る}}
KotlinとSwiftは、それぞれAndroidとiOSのアプリ開発で主に使用されるプログラミング言語です。以下に、両言語の類似点と相違点をいくつか挙げてみます。

;類似点:
:;静的型付け:
::KotlinとSwiftは両方とも静的型付け言語であり、コンパイル時に型の確認が行われます。これにより、実行時エラーを事前に把握しやすくなり、安全性が向上します。
:;モダンな構文:
::どちらの言語もモダンで読みやすい構文を採用しており、コードの記述が簡潔になっています。これにより、開発者は効率的かつ迅速にコードを書くことができます。
:;ヌル安全性:
::KotlinとSwiftはヌル安全性の考え方を取り入れており、ヌルポインターによるエラーを防ぐための手段を提供しています。これにより、安定したアプリケーションの開発が可能です。
;相違点:
:;ターゲットプラットフォーム:
::Kotlinは主にAndroidアプリ開発に焦点を当てていますが、JetBrainsによって開発・サポートされているため、マルチプラットフォーム開発にも利用されています。
::SwiftはAppleが開発し、iOS、macOS、watchOS、tvOSなどのApple製品向けのアプリ開発に特化しています。
:;開発元とサポート:
::KotlinはJetBrainsによって開発・サポートされています。JetBrainsはプロの開発者向けのツールを提供しており、Kotlinの統合も図られています。
::SwiftはAppleによって開発され、iOSや関連プラットフォーム向けに積極的にサポートされています。Xcodeなどの開発ツールも提供されています。
:;言語機能の違い:
::KotlinはJavaとの相互運用性が高く、既存のJavaコードとの統合が容易です。これにより、Android開発においても既存のJavaライブラリを利用することができます。
::SwiftはObjective-Cとの相互運用性があり、iOS開発においてはObjective-Cコードとの統合が可能です。SwiftはObjective-Cよりもシンプルであり、関数型プログラミングの機能も強化されています。
:;構文と特徴:
::KotlinはJavaに似た構文を持ちつつ、いくつかの新しい機能や改善を提供しています。Javaからの移行が容易であり、Androidアプリケーション開発に適しています。
::SwiftはObjective-Cよりもシンプルで読みやすい構文を持っており、関数型プログラミングの機能が強化されています。iOSアプリケーション開発において使用されます。

どちらの言語も優れた特性を持っており、選択はプロジェクトのニーズや開発者の好みによって異なります。

== エントリーポイント ==
{{先頭に戻る}}
Kotlinでは、関数 mainがエントリーポイントです。
;noop.kt:<syntaxhighlight lang=kotlin copy>
fun main() {}
</syntaxhighlight>
なにもしないプログラムはこの様になります。

=== コマンドライン引数を受取る場合 ===
;use-args.kt:<syntaxhighlight lang=kotlin copy>
fun main(args: Array<String>) {
    println(args.contentToString())
}
</syntaxhighlight>
;Shell:<syntaxhighlight lang=text>
% kotlinc use-args.kt -include-runtime -d use-args.jar
% java -jar use-args.jar 123 abc 漢字
[123, abc, 漢字]
% _
</syntaxhighlight>

== パッケージ ==
{{先頭に戻る}}

パッケージの指定は、ソースファイルの冒頭（shebang!の次）で行ってください<ref>[https://kotlinlang.org/docs/basic-syntax.html#package-definition-and-imports Package definition and imports]</ref>。

:<syntaxhighlight lang="Kotlin">
package my.demo

import kotlin.text.* 

// Imprementation
</syntaxhighlight>
ディレクトリとパッケージの一致は必須ではなく、ソースファイルはファイルシステム上に任意に配置することができます。

=== ディフォルトインポート ===
Kotlinでは、特定のパッケージやクラスを明示的にインポートすることなく、いくつかのデフォルトのインポートが提供されています。これにより、コードをより簡潔にし、冗長性を減少させることができます。以下は、デフォルトでインポートされる主要なパッケージです。

;kotlin.*: Kotlinの基本的な機能や標準ライブラリが含まれています。これにより、Kotlinの核となる機能を利用するための基本的な道具が提供されます。
;kotlin.annotation.*: アノテーション関連の機能が含まれています。アノテーションは、プログラムにメタデータを追加するための重要な手段です。
;kotlin.collections.*: コレクション関連のクラスや関数が含まれています。これにより、リスト、セット、マップなどのデータ構造を効果的に扱うための機能が提供されます。
;kotlin.comparisons.*: 比較関連の機能が含まれています。ソートや比較などの操作をより容易に行うことができます。
;kotlin.io.*: 入出力関連の機能が含まれています。例えば、ファイルの読み書きや標準出力への出力などが簡単に行えます。
;kotlin.ranges.*: 範囲関連の機能が含まれています。これを使用することで、特定の範囲内の要素を操作する際に便利なメソッドが提供されます。
;kotlin.sequences.*: シーケンス処理関連の機能が含まれています。シーケンスを使用することで、遅延評価を活用して効率的なデータ処理が可能です。
;kotlin.text.*: テキスト処理関連の機能が含まれています。文字列の操作やフォーマットなどが簡単に行えます。
また、ターゲットプラットフォームに応じて、追加のデフォルトインポートが行われます。

;JVM:
:;java.lang.*: Javaの基本的なクラスや機能が含まれています。これにより、Javaとの互換性が確保されます。
:;kotlin.jvm.*: JVM関連の機能が含まれています。
;JS:
:;kotlin.js.*: JavaScript関連の機能が含まれています。

上記のパッケージは、明示的にインポートすることなく既にインポートされています<ref>[https://kotlinlang.org/docs/packages.html#default-imports Default imports]</ref>。

このようなデフォルトのインポートにより、開発者は冗長なコードを書かずに済み、効率的にKotlinの機能を利用することができます。

----
以下は、デフォルトでインポートされる主要なパッケージの概要を表形式でまとめたものです。

:{| class=wikitable
|+ デフォルトでインポートされる主要なパッケージ
!パッケージ!!内容の概要
|-
!kotlin.*
|Kotlinの基本的な機能や標準ライブラリ
|-
!kotlin.annotation.*
|アノテーション関連の機能
|-
!kotlin.collections.*
|コレクション関連のクラスや関数
|-
!kotlin.comparisons.*
|比較関連の機能
|-
!kotlin.io.*
|入出力関連の機能
|-
!kotlin.ranges.*
|範囲関連の機能
|-
!kotlin.sequences.*
|シーケンス処理関連の機能
|-
!kotlin.text.*
|テキスト処理関連の機能
|}

また、ターゲットプラットフォームによっては、追加のデフォルトインポートが行われます。

:{| class=wikitable
|+ ターゲットプラットフォーム別の追加のデフォルトインポート
!ターゲットプラットフォーム!!追加されるパッケージの概要
|-
!JVM
|java.lang.*: Javaの基本的なクラスや機能
|kotlin.jvm.*: JVM関連の機能
|-
!JS
|kotlin.js.*: JavaScript関連の機能
|}

これらのデフォルトインポートは、通常のKotlinプロジェクトで基本的な操作や機能を利用するための便利な手段となります。

=== インポート ===
デフォルトインポートとは別に、各ファイルは独自の <code>[[#import|import]]</code> ディレクティブを含むことができます。

単一の名前でインポートすることができます。

 import org.example.Message // Message は無条件にアクセスできます。

または、パッケージ、クラス、オブジェクトなどのスコープのすべてのアクセス可能なコンテンツをインポートすることができます。

 import org.example.* // 'org.example' に含まれるすべてのコンテンツにアクセスできるようになります。

名前の衝突がある場合、as キーワードを使用して、衝突するエンティティの名前をローカルに変更することで、曖昧さをなくすことができます。

 import org.example.Message // Message にアクセスできるようになります。
 import org.test.Message as testMessage // testMessage は 'org.test.Message' を表しています。

import キーワードは、クラスのインポートに限定されません。他の宣言をインポートするためにも使用することができます。

* トップレベルの関数およびプロパティ
* オブジェクト宣言の中で宣言された関数やプロパティ
* enum 定数

=== トップレベル宣言の可視性 ===
トップレベル宣言が private とマークされている場合、その宣言が行われたファイルに対してプライベートとなります。
{{See also|[[#可視性修飾子|可視性修飾子]]}}

== トップレベルオブジェクト ==
{{先頭に戻る}}
いかなる関数スコープにも属さないオブジェクトのことを、トップレベルオブジェクト( ''top level object'' )と言います<ref>[https://kotlinlang.org/spec/syntax-and-grammar.html#grammar-rule-topLevelObject topLevelObject]</ref>。

;[https://paiza.io/projects/jKQiCwDXdUOhVY7dIoDmKg?language=kotlin トップレベルオブジェクトの前方参照は許される]:<syntaxhighlight lang="Kotlin">
val a = 10

fun main() {
    println("a =$a, b = $b")
}

val b = 32
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="text">
a = 10, b = 32
</syntaxhighlight>
:この例では変数 <var>b</var> の参照が前方参照になっていますが、<var>b</var> はトップレベルオブジェクトなので参照解決されます。

== コメント ==
{{先頭に戻る}}
Kotlinには、行末で終わるコメントと、複数行に渡ることと、入れ子にすることができるコメントがあります。
;[https://pl.kotl.in/F-bmww7Bt comments.kt]:<syntaxhighlight lang="Kotlin">
// Kotlinには、行末で終わるコメントと
fun main() { /*
              * 複数行に渡ることと
              * /*
                 * 入れ子にすることができる
                 * コメントがあります
                 */
               */
    println("Hello, World!")
}
</syntaxhighlight>
: <code>/* ... */</code>タイプのコメントは、入れ子にできるのが多くのプログラミング言語と異なります。
:: Kotlinの他には、[[Scala]]と[[D言語]]がコメントを入れ子にできます。

== 基本型 ==
{{先頭に戻る}}
Kotlinでは、任意のインスタンスに対してプロパティーを参照したりメンバー関数を呼出すことができるという意味で、すべてのインスタンスがクラスに属しています。
いくつかの型は特別な内部表現を持つことができます。例えば、数字、文字、ブール値は実行時にプリミティブ値として表現できますが、ユーザーからは参照されるときに自動的にボックス化されるので普通のクラスのインスタンスのように見えます。
これらの型は基本的にJavaのプリミティブに一対一に対応しますが、Stringだけはjava.lang.Stringクラスに対応しています。
基本型は Package kotlin で定義されています。

; Kotlinの基本型
:;[[#論理型|論理型]]:<code>[[#Boolean|Boolean]]</code> {{---}} true, false
:;[[#数値型|数値型]]
::;符号付き整数型:<code>[[#Byte|Byte]]</code> <code>[[#Short|Short]]</code> <code>[[#Int|Int]]</code> <code>[[#Long|Long]]</code>
::;符号無し整数型:<code>[[#UByte|UByte]]</code> <code>[[#UShort|UShort]]</code> <code>[[#UInt|UInt]]</code> <code>[[#ULong|ULong]]</code>
:;[[#浮動小数点数型|浮動小数点数型]]:<code>[[#Float|Float]]</code><code>[[#Double|Double]]</code>
:;[[#文字型|文字型]]: <code>[[#Char|Char]]</code>
:;[[#文字列型|文字列型]]:<code>[[#String|String]]</code>

;[https://pl.kotl.in/sePeMiW1A primitive.kt]:<syntaxhighlight lang="Kotlin">
fun main() {
  println("値 : simpleName")
  println("----------------")
  arrayOf(true, 2.toByte(), 3.toUByte(), 5.toShort(), 7.toUShort(),
          11, 13U, 17L, 19UL, 
          1.23, 3.14F, 'C', "abc").forEach {
	  println("$it : ${it::class.simpleName}")
  }
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
値 : simpleName 
---------------- 
true : Boolean 
2 : Byte 
3 : UByte 
5 : Short 
7 : UShort 
11 : Int 
13 : UInt 
17 : Long 
19 : ULong 
1.23 : Double 
3.14 : Float 
C : Char 
abc : String
</syntaxhighlight>

:{| class="wikitable"
|+ 基本型<ref>[https://kotlinlang.org/docs/basic-types.html Basic types]</ref>
|-
! 型
! Javaの型
! リテラル表現
|-
! <syntaxhighlight lang=kotlin inline>Boolean</syntaxhighlight>
! <syntaxhighlight lang=java inline>boolean</syntaxhighlight>
| <syntaxhighlight lang=kotlin inline>false, true</syntaxhighlight>
|-
! <syntaxhighlight lang=kotlin inline>Byte</syntaxhighlight>
! <syntaxhighlight lang=java inline>byte</syntaxhighlight>
| <syntaxhighlight lang=kotlin inline></syntaxhighlight>
|-
! <syntaxhighlight lang=kotlin inline>Short</syntaxhighlight>
! <syntaxhighlight lang=java inline>short</syntaxhighlight>
| <syntaxhighlight lang=kotlin inline></syntaxhighlight>
|-
! <syntaxhighlight lang=kotlin inline>Int</syntaxhighlight>
! <syntaxhighlight lang=java inline>int</syntaxhighlight>
| <syntaxhighlight lang=kotlin inline>123, 0x17, 0b10110110</syntaxhighlight>
|-
! <syntaxhighlight lang=kotlin inline>Long</syntaxhighlight>
! <syntaxhighlight lang=java inline>long</syntaxhighlight>
| <syntaxhighlight lang=kotlin inline>123L, 0x17L, 0b10110110L</syntaxhighlight>
|-
! <syntaxhighlight lang=kotlin inline>Double</syntaxhighlight>
! <syntaxhighlight lang=java inline>double</syntaxhighlight>
| <syntaxhighlight lang=kotlin inline>1.73205080757,6.62607015e-34</syntaxhighlight>
|-
! <syntaxhighlight lang=kotlin inline>Float</syntaxhighlight>
! <syntaxhighlight lang=java inline>float</syntaxhighlight>
| <syntaxhighlight lang=kotlin inline>1.73205080757f</syntaxhighlight>
|-
! <syntaxhighlight lang=kotlin inline>String</syntaxhighlight>
! <syntaxhighlight lang=java inline>java.lang.String</syntaxhighlight>
| <syntaxhighlight lang=kotlin inline>"Simple sample text."</syntaxhighlight>
|-
! <syntaxhighlight lang=kotlin inline>Char</syntaxhighlight>
! <syntaxhighlight lang=java inline>char</syntaxhighlight>
| <syntaxhighlight lang=kotlin inline>'Q'</syntaxhighlight>

|}

=== 論理型 ===
Kotlinの論理型は <code>{{Anchor|Boolean}}</code> で
;偽: <code>{{Anchor|false}}</code>
;真: <code>{{Anchor|true}}</code>
の２つの値以外は取りえません。

JVMでは、この型の非[[#Nullable|Nullable]]値は、プリミティブ型のbooleanの値として表現されます。
論理型と数値型は可換ではないので、制御構造の条件式などでもゼロとの比較を行う必要があります。
{{See also|[[#Nullable|Nullable]]}}

=== 数値型 ===
Kotlinの数値型は、[[#整数型|整数型]]と[[#浮動小数点数型|浮動小数点数型]]に分かれています。
これらの型は、抽象クラスである <code>{{Anchor|Number}}</code> クラスから派生しており、具象クラスとして利用されます。

なお、[[#文字型|文字型]]は数値型と可換ではありません。

==== 整数型 ====
Kotlinの整数型には、符号付き整数型と符号なし整数型があります。
符号なし整数型の名前は、対応する符号付き整数型の名前の先頭に <code>U</code> を補ったものになります。以下が主な整数型です：

:{| class=wikitable
|+ 整数型
|-
! <code>{{Anchor|Byte}}</code> 
| 符号付き1バイト整数
|-
! <code>{{Anchor|Short}}</code> 
| 符号付き2バイト整数
|-
! <code>{{Anchor|Int}}</code> 
| 符号付き4バイト整数
|-
! <code>{{Anchor|Long}}</code> 
| 符号付き8バイト整数
|-
! <code>{{Anchor|UByte}}</code> 
| 符号なし1バイト整数
|-
! <code>{{Anchor|UShort}}</code> 
| 符号なし2バイト整数
|-
! <code>{{Anchor|UInt}}</code> 
| 符号なし4バイト整数
|-
! <code>{{Anchor|ULong}}</code> 
| 符号なし8バイト整数
|}

==== 浮動小数点数型 ====
Kotlinの浮動小数点数型には、以下の２つがあります：

:{| class=wikitable
|+ 浮動小数点数型
|-
! <code>{{Anchor|Float}}</code>
| 単精度浮動小数点数；ISO/IEC/IEEE 60559:2011-06 のbinary32
|-
! <code>{{Anchor|Double}}</code>
| 倍精度浮動小数点数；ISO/IEC/IEEE 60559:2011-06 のbinary64
|}

これらの数値型は、数学的な演算や精密な計算に利用され、Kotlin言語において数値処理をサポートする基本的な要素となっています。

=== 文字型 ===
{{先頭に戻る}}
{{Anchor|Char}}クラスは文字を表すクラスです。'a' のようなKotlinプログラム内の文字リテラルはすべてこのクラスのインスタンスとして実装されています<ref>[https://kotlinlang.org/docs/characters.html Characters]</ref><ref name=char>[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-char/ Char]</ref>。
<code>Char</code>は、16ビットのUnicode文字を表します。これは、Charがすべての文字をユニコード文字を表すことが'''出来ない'''事をしめしています。

;[https://pl.kotl.in/KRFm8vVVb Charで表現できない文字]:<syntaxhighlight lang="Kotlin" highlight=4>
fun main() {
    val ascii = 'A'
    val kanji = '漢'
    val emoji = '🏝'
}
</syntaxhighlight>
;コンパイル結果:<syntaxhighlight lang=text>
Too many characters in a character literal ''🏝''
</syntaxhighlight>
: 🏝のUnicodeはU+1F3DDと16ビットを超えているので Char には収容できません。
: 絵文字以外にもサロゲートペアはあり、サロゲートペア以外にも合成文字も16ビットを超えるものがあります。
Kotlinは、Javaの文字エンコーディングシステムを引継いだので、Charの収まらない文字の問題に限らずUnicodeを内部エンコーディングに使っていることに起因する厄介ごとと付き合い続ければなりません。

==== 演算子 ====
Charでは、いくつかの演算子が定義されています<ref name=char/>。

;[https://pl.kotl.in/pQ82wUEc_ Charクラスの演算子]:<syntaxhighlight lang="Kotlin" line>
fun main() {
    var a = 'K'
    println("var a = 'K'")
    a--
    println("a-- ⇒ $a")
    a++
    println("a++ ⇒ $a")
    println("'C' - 'A' ⇒ ${'C' - 'A'}")
    println("'C' - 2 ⇒ ${'C' - 2}")
    println("'A' + 2 ⇒ ${'A' + 2}")
    println("'A'..'C' ⇒ ${'A' .. 'C'}")
    println("'A'..<'C' ⇒ ${'A' ..< 'C'}")
    println("'A' + \"BCD\" ⇒ ${'A' + "BCD"}")
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
var a = 'K' 
a-- ⇒ J 
a++ ⇒ K 
'C' - 'A' ⇒ 2 
'C' - 2 ⇒ A 
'A' + 2 ⇒ C 
'A'..'C' ⇒ A..C 
'A'..<'C' ⇒ A..B 
'A' + "BCD" ⇒ ABCD
</syntaxhighlight>

==== エスケープシーケンス ====
特殊文字は、エスケープする \（バックスラッシュ）から始まります。以下のエスケープシーケンスに対応しています。

:{| class="sortable wikitable"
|+ エスケープシーケンス
|-
!表現!!意味
|-
!\t
|水平tab
|-
!\b
|バックスペース
|-
!\n
|改行(LF)
|-
!\r
|キャリッジリターン(CR)
|-
!\'
| シングルクォーテーション
|-
!\"
|ダブルクオーテーションマーク
|-
!\\
|バックスラッシュ
|-
!\$
|ドル記号
|}
その他の文字をエンコードする場合は、Unicodeエスケープシーケンス構文を使用します。'\uFF00' を使用します。

=== 文字列型 ===
{{先頭に戻る}}
{{Anchor|String}}
クラスは文字列を表すクラスです。"abc" のようなKotlinプログラム内の文字列リテラルはすべてこのクラスのインスタンスとして実装されています<ref>[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/ String]</ref>。
Kotlinでは、文字列( <code>String</code> )と文字( <code>Char</code> )とは直接の関係はありません（StringはCharの配列ではありません）。

==== 演算子 ====
Stringでは、加算演算子を連結として定義されています<ref>[https://github.com/JetBrains/kotlin/blob/f3385fbdcb8b9dc29661a8a4973c855cdcf73767/core/builtins/native/kotlin/String.kt#L30 kotlin/core/builtins/native/kotlin/String.kt]</ref>。

:<syntaxhighlight lang="Kotlin">
public operator fun plus(other: Any?): String
</syntaxhighlight>

加算演算子( <code>+</code> )は、文字列( this )と与えられた他のオブジェクトの文字列表現を連結して得られる文字列を返します<ref>[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/plus.html plus - Kotlin Programming Language]</ref>。
;[https://pl.kotl.in/1KlKcFKGs 文字列の+演算子]:<syntaxhighlight lang="Kotlin">
fun main() {
    val str = "ABC" + 12
    println(str + true + listOf(1,2,3))
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
ABC12true[1, 2, 3]
</syntaxhighlight>

==== テンプレートリテラル ====
既に紹介したように、Stringクラスのリテラルは "（ダブルクオーテーション）で括った文字列です。

Stringリテラルには変数や式を埋込むことが出来ます。
このように、変数や式が埋込まれたStringリテラルのことを{{Anchor|テンプレートリテラル}}といいます。

;[https://pl.kotl.in/uBCbpW7Mc テンプレートリテラル]:<syntaxhighlight lang="Kotlin">
fun main() {
    var n = 10
    println("変数 n の値は $n です。")
    println("式 n + 13 の値は ${n + 13} です。")
    println("${'$'} 自体を書きたいときは、 \\\$ と \$ の直前に \\ を置きエスケープします（\$\$ではありません）。")
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
変数 n の値は 10 です。 式 n + 13 の値は 23 です。 
$ 自体を書きたいときは、 \$ と $ の直前に \ を置きエスケープします（$$ではありません）。
</syntaxhighlight>

==== 生文字列 ====
生文字列( ''Raw strings'' )は、改行や任意のテキストを含むことができます。トリプルクォート（”””; ''triple quote'' ）で区切られ、エスケープを含まず、改行や他の任意の文字を含むことができます<ref>[https://kotlinlang.org/docs/strings.html#raw-strings Raw strings]</ref>。

;[https://pl.kotl.in/7Pqk1IwPo 生文字列]:<syntaxhighlight lang="Kotlin">
fun main() {
    var n = 10
    print(
"""
変数 n の値は $n です。
式 n + 13 の値は ${n + 13} です。
${'$'} 自体を書きたいときは、 \$ と $ の直前に \ を置きエスケープします（$$ ではありません）。
"""
    )
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
変数 n の値は 10 です。 式 n + 13 の値は 23 です。 
$ 自体を書きたいときは、 \$ と $ の直前に \ を置きエスケープします（$$ ではありません）。
</syntaxhighlight>

==== エスケープシーケンス ====
{{See|[[#エスケープシーケンス|文字型のエスケープシーケンス]]}}

==== コードポイント ====
;[https://pl.kotl.in/7Pqk1IwPo 文字列のn番目のコードポイント]:<syntaxhighlight lang="Kotlin">
fun main() {
    val str = "ABC漢字🏝𠮷"
    
    var i = 0
    while (i < str.length) {
	    println(Integer.toHexString(str.codePointAt(i)))
        i++
    }
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text highlight="7,9">
41 
42 
43 
6f22 
5b57 
1f3dd 
dfdd 
20bb7 
dfb7
</syntaxhighlight>
: codePointAt()でサロゲートペアの2ワード目を読むと…

=== Array ===
Kotlinで配列型は Array で、main() の引数でも使われています<ref>[https://kotlinlang.org/docs/arrays.html Array]</ref><ref>[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-array/ Array]</ref>。

[[#Array()|Array()]], [[#arrayOf()|arrayOf()]], arrayOfNulls() や emptyArray() で生成します。 

==== Array() ====
;[https://paiza.io/projects/sywOsCKIuSuu8x2BrbdfwQ?language=kotlin Array()を使ったArrayの生成]:<syntaxhighlight lang=Kotlin highlight=2 line>
fun main() {
    val ary = Array(5){it}
    println("ary::class.simpleName ⇒ ${ary::class.simpleName}")
    println("ary[0]::class.simpleName ⇒ ${ary[0]::class.simpleName}")
    ary.forEach{print("$it ")}
    println("")
    
    val ary2 = Array(5){(it*it).toString()}
    println("ary2[0]::class.simpleName ⇒ ${ary2[0]::class.simpleName}")
    ary2.forEach{print("$it ")}
    println("")
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
ary::class.simpleName ⇒ Array
ary[0]::class.simpleName ⇒ Int
0 1 2 3 4 
ary2[0]::class.simpleName ⇒ String 
0 1 4 9 16 
</syntaxhighlight>
: Array()はArrayのコンストラクターで、引数として要素数をとり、ブロックが初期化式になります。

==== プリミティブ型配列 ====
Kotlinには、IntArray、DoubleArray、BooleanArray、CharArrayなどのプリミティブ型を要素とする配列のクラスが用意されています。
これらを総称してプリミティブ型配列( Primitive type arrays )と呼びます<ref>[https://kotlinlang.org/docs/arrays.html#primitive-type-arrays Primitive type arrays]</ref>。
プリミティブ型配列は、機能的にはArray<T>のTにプリミティブ型を与えたものと変わりありませんが、ボックス化されないので性能向上とフットプリントの削減が期待できます。
このため、プリミティブ型配列はArrayを継承していません。

StringArray はありません。

;[https://paiza.io/projects/tgs7lwP0-La0B-TUJ--kug?language=kotlin IntArray()を使ったIntArrayの生成]:<syntaxhighlight lang=Kotlin highlight=2 line>
fun main() {
    val ary = IntArray(5){it}
    println(
"""
ary::class.simpleName ⇒ ${ary::class.simpleName}
ary[0]::class.simpleName ⇒ ${ary[0]::class.simpleName}
ary => $ary
ary.joinToString() ⇒ ${ary.joinToString()}
ary.contentToString() => ${ary.contentToString()}
"""
    )
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
ary::class.simpleName ⇒ IntArray
ary[0]::class.simpleName ⇒ Int
ary => [I@1c6b6478
ary.joinToString() ⇒ 0, 1, 2, 3, 4 
ary.contentToString() => [0, 1, 2, 3, 4]
</syntaxhighlight>

==== arrayOf() ====
;[https://paiza.io/projects/avmXjK5ilEp1Xl-_CSnMfw?language=kotlin arrayOf()を使ったArrayの生成]:<syntaxhighlight lang=Kotlin highlight=2 line>
fun main() {
    val ary = arrayOf(1, 9, 3, 5, 23, 1)
    
    println("${ary::class.simpleName}")
    println("${ary[0]::class.simpleName}")

    for (s in ary)
        if (s > 10)
            break
        else
            print("$s ")
    println("")
    
    run {
        ary.forEach{
            if (it > 10)
                return@run
            else
                print("$it ")
        }
    }
    println("")

    var i = 0
    while (i < ary.size)
        ary[i] = i++
    ary.forEach{print("$it ")}
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
Array
Int
1 9 3 5  
1 9 3 5 
</syntaxhighlight>
: arrayOf()は可変長引数の関数で、引数が生成されるArrayの要素になります。
: Arrayの要素の型は、型強制できる最小公倍数的な方になります（例えば Int と Long が混在していたら Long）。

== 特別な型 ==
{{先頭に戻る}}
基本型の他にも幾つかの特別な型があります。
これらは、基本型同様 Package kotlin で定義されています。

; 特別な型
:;Kotlinのクラス階層のルート:<code>[[#Any|Any]]</code>
:;戻値型未指定な関数の型:<code>[[#Unit|Unit]]</code>
:;存在しない値を表す型:<code>[[#Nothing|Nothing]]</code>

=== Any ===
AnyはKotlinのクラス階層のルートです。すべてのKotlinクラスはAnyをスーパークラスとして持っています。
クラス定義で継承元を指定しないと Any が暗黙の継承元になります。
また、Anyクラスのオブジェクトは、あらゆるオブジェクトを代入できます。
;[https://pl.kotl.in/k-36Q8gd6 AnyのArray]:<syntaxhighlight lang="Kotlin">
fun main() {
    arrayOf(4, "abc", 'a', listOf(2,5,6)).forEach{ println("$it(${it::class.simpleName})") }
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
4(Int) 
abc(String) 
a(Char) 
[2, 5, 6](ArrayList)
</syntaxhighlight>

=== Unit ===
Unitは、何も返さない関数の戻値の型です。JVMでは、Javaのvoid型に相当します。

:<code>pub main() : Unit {}</code>
は
:<code>pub main() {}</code>
と等価です。

=== Nothing ===
Nothingはインスタンスを持ちません。例えば、ある関数の戻り値がNothingであれば、それは決して戻らない（常に例外を投げる）ことを意味します<ref>[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-nothing.html Nothing]</ref>。

== Null安全 ==
KotlinのNULL安全性（Null safety）とNullableに関して、以下のポイントが重要です。

# Null安全性: Kotlinの目標の一つは、null参照によるエラー（The Billion Dollar Mistakeとも呼ばれる）の危険性を排除することです。Javaを含む多くのプログラミング言語で見られる最も一般的な落とし穴の一つは、null参照のメンバーにアクセスすると、null参照例外が発生することです（JavaではNullPointerException、NPEと呼ばれます）。
# Nullable型と非Nullable型: Kotlinの型システムでは、nullを保持できる参照（Nullable型）と、保持できない参照（非Nullable型）とを区別します。たとえば、String型の通常の変数はnullを保持できませんが、NullableなString型はnullを保持できます。
# Nullable型の宣言: nullを許容する型を宣言するには、型名の後ろに「?」を付けます。例えば、String型のNullableな変数を宣言する場合は、<code>String?</code>とします。
# Nullable型の安全な操作: Nullableな変数やプロパティに安全にアクセスする方法として、以下のような手法があります。
#* <code>?.</code>演算子: セーフコール演算子は、nullチェックを行い、nullでない場合にのみメンバーにアクセスします。
#* <code>?:</code>演算子: Elvis演算子は、nullでない場合には左側の値を、nullの場合には右側の値を返します。
#* <code>!!</code>演算子: null許容型の値を非Nullable型として扱い、nullの場合にはNullPointerExceptionをスローします。
# Null安全性の確認: null安全性の確認は、条件式で明示的に行うことができます。<code>if (variable != null)</code>のような形で、nullチェックを行い、それに応じた処理を行います。
# Safe casts: 安全なキャスト演算子<code>as?</code>を使用すると、通常のキャストでClassCastExceptionが発生する可能性がある場合でも、nullを返すことができます。

KotlinのNull安全性とNullable型は、プログラミングにおける安全性と信頼性を向上させるための重要な機能です。これらの機能を適切に理解し、利用することで、Nullによるエラーを最小限に抑えることができます。

Javaを含む多くのプログラミング言語における最も一般的な落とし穴の1つは、Null参照のメンバーにアクセスするとNull参照例外が発生することです。Javaでは、これはNullPointerException、略してNPEと呼ばれるものに相当します<ref>[https://kotlinlang.org/docs/null-safety.html#nullable-types-and-non-null-types Nullable types and non-null types]</ref>。

KotlinでNPEが発生する原因として考えられるのは、以下の通りです。
* NullPointerException()を明示的に呼び出した場合。
* 後述する !! 演算子の使用。
* 初期化に関するデータの不整合（以下のような場合）。
** コンストラクターで使用可能な未初期化の this がどこかで渡され使用されている (「リーキング this」)。
** スーパークラスのコンストラクターが、派生クラスの実装で未初期化の状態を使用しているオープンメンバーを呼出す場合。
* Java との相互運用。
** プラットフォーム型のNull参照のメンバにアクセスしようとする。
** Java との相互運用に使用される汎用型の Nullability の問題。例えば、ある Java コードが Kotlin の MutableList<String> に null を追加し、それを操作するために MutableList<String?> が必要になることがあります。
** その他、外部のJavaコードによって引き起こされる問題。

=== Nullable ===
Kotlinの型システムでは、nullを保持できる参照（Null可能参照; ''nullable references'' ）とそうでない参照（非Null参照; ''non-null references'' ）を区別しています。例えば、String型の通常の変数はnullを保持できません。

:<syntaxhighlight lang=kotlin line highlight=2 copy>
var a: String = "abc" // 通常の初期化ではデフォルトで非nullを意味します
// a = null // コンパイルエラー！
</syntaxhighlight>

nullを許容するには、<code>String?</code>と書いて変数をnull可能な文字列として宣言します。

:<syntaxhighlight lang=kotlin line highlight="1,2" copy>
var b: String? = "abc" // nullに設定可能
b = null // OK
prinlnt(b)
</syntaxhighlight>

さて、<var>a</var>のメンバー関数を呼び出したり、プロパティーにアクセスしたりしても、NPEが発生しないことが保証されています。

:<syntaxhighlight lang=kotlin line copy>
val l = a.length
</syntaxhighlight>

しかし、<var>b</var>のメンバー関数を呼び出したり、プロパティーにアクセスしたりすると、それは安全ではなく、コンパイラはエラーを報告します。

:<syntaxhighlight lang=kotlin line copy>
val l = b.length
</syntaxhighlight>

それでもそのプロパティにアクセスする必要がありますよね？そのためには、いくつかの方法があります。

=== 条件におけるnullのチェック ===
まず、bがnullかどうかを明示的にチェックし、2つの選択肢を別々に処理することができます。

:<syntaxhighlight lang=kotlin line copy>
val l = if (b != null) b.length else -1
</syntaxhighlight>

コンパイラーは実行したチェックの情報を記録し、ifの内部でlengthの呼出しを可能にする。より複雑な条件もサポートされています。

:<syntaxhighlight lang=kotlin line copy>
val b: String? = "Kotlin"
if (b != null && b.length > 0) {
    print("文字列の長さは ${b.length}")
} else {
    print("空文字列")
}
</syntaxhighlight>
註：b が immutable な場合 (つまり、チェックから使用までの間に変更されないローカル変数か、 バッキングフィールドを持つオーバーライド不可のメンバー変数) にのみ有効です。

=== !!演算子 ===
Not-Null断定演算子(!!)で任意の値をnullでない型に変換し、値がnullの場合は例外をスローします。<code>b!!</code>と書くと、<var>b</var>の非null値（例えばこの例ではString）を返し、<var>b</var>がnullの場合はNPEを投げます。

:<syntaxhighlight lang=kotlin line copy>
val l = b!!.length
</syntaxhighlight>

このように、NPEを発生させたい場合は、明示的に要求する必要があり、突然発生することはありません。

=== ?.演算子 ===
:<syntaxhighlight lang=kotlin line highlight=5 copy>
fun main() {
    var str: String? = "Hello" // ?を使ってnullを許容する
    str = null // 問題なくnullを代入できる
    
    val length = str?.length // 安全呼び出し演算子でnullチェックしつつプロパティにアクセス
    println("Length: $length")
}
</syntaxhighlight>

<code>?.</code> 演算子は、null安全性を保証しつつ、<code>str</code> 変数がnullでない場合に <code>length</code> プロパティにアクセスします。<code>str</code> がnullの場合、<code>length</code> には <code>null</code> が代入されます。

このように、<code>?.</code> 演算子はnull値を安全に処理するために使用されます。例えば、Javaの場合、nullチェックを行わないとNullPointerExceptionが発生しますが、Kotlinでは <code>?.</code> 演算子を使用することで、nullに対する操作を安全に行うことができます。

== 識別子 ==
{{先頭に戻る}}

変数の名前のような名前を識別子( ''identifiers'' )と呼びます<ref>[https://kotlinlang.org/spec/syntax-and-grammar.html#identifiers Identifiers]</ref>。
変数ほかに、関数、クラス、クラスのメンバー、クラスのメンバー関数、enum、ラベルなどの名前も識別子です。
* 同じ名前空間の中では識別子は重複できません。
* 識別子に使える文字は、英数字・_(アンダーバー)・Unicode文字です。
* 識別子の最初に数字を使うことはできません。
* 識別子の大文字小文字は区別されます。
* キーワードの使用には制限があります。
* キーワードや空白を含む文字列など上のルールに従わない文字列は、`（バッククオーテーション）で囲むと識別子として使うことができます。
{{See also|[[#キーワード|キーワード]]}}

== 変数 ==
{{先頭に戻る}}
Kotlinでは、変数は使う前にかならず宣言する必要があります。

=== val と var ===
==== val ====
;[https://pl.kotl.in/8PE1c8KR3 変数を使った単純なコード]:<syntaxhighlight lang=kotlin line highlight="2,3" copy>
fun main() {
    val hello = "Hello, World!"
    println(hello) 
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
Hello, World!
</syntaxhighlight>
:[[#Hello world|Hello world]]の例と結果は同じですが、変数<var>hello</var>を導入しています。
:;変数 hello の宣言:<syntaxhighlight lang=kotlin line start=2 copy>
val hello = "Hello, World!"
</syntaxhighlight>
:イミュータブル変数の宣言は、この様に:<syntaxhighlight lang=kotlin copy>
val 識別子 = 初期化式
</syntaxhighlight>
:の形式をとります。
:;変数 hello の値の参照:<syntaxhighlight lang=kotlin line start=3 copy>
println(hello) 
</syntaxhighlight>
:の様に識別子をそのまま書くことで、値（この場合は "Hello, World!"）を参照できます。
:キーワード <code>val</code> を使って宣言された変数はイミュータブル( ''Immutable'' )です。
:: イミュータブルというのは、一度値が決めたら変更できないという意味です。
:イミュータブルな変数を「定数」ということがありますが、リテラルのことを定数ということもあるので、ここでは「イミュータブルな変数」と呼びます。

==== var ====
;[https://pl.kotl.in/8z57OJeNL ミュータブルな変数を使ったコード]:<syntaxhighlight lang=kotlin line highlight="2,4" copy>
fun main() {
    var hello = "Hello, World!"
    println(hello) 
    hello = "Hello, Kotlin!"
    println(hello) 
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
Hello, World! 
Hello, Kotlin!
</syntaxhighlight>
:;変数 hello の宣言:<syntaxhighlight lang=kotlin line start=2 copy>
var hello = "Hello, World!"
</syntaxhighlight>
:ミュータブルな変数の宣言は、この様に:<syntaxhighlight lang=kotlin copy>
var 識別子 = 初期化式
</syntaxhighlight>
:の形式をとります。
:キーワード <code>var</code> を使って宣言された変数はイミュータブル( ''Immutable'' )です。
:: ミュータブルというのは、変数の値を何度でも変更できるという意味です。
:;変数 hello に新しい値を代入:<syntaxhighlight lang=kotlin line start=4 copy>
hello = "Hello, Kotlin!"
</syntaxhighlight>
:Kotlinでは <code>=</code> が代入演算子です。
:: 代入の前の <var>hello</var> の値は <code>"Hello, World!"</code> でしたが、代入の後は <code>"Hello, Kotlin!"</code> になります。

==== 型推論 ====
いままでの例で既に型推論( ''type inference'' ) は使われています。
変数を宣言するときに、特に型を明示しませんでしたが、初期化式の型から変数の型を特定していたのです。

===== 型アノテーション =====
初期化式は省略可能です。
その場合は変数の型がわからないので型アノテーション( ''type annotation'' )が必要になります。

;[https://pl.kotl.in/EW6hk7OkA 型アノテーションを伴った変数宣言]:<syntaxhighlight lang=kotlin line highlight="2" copy>
fun main() {
    var hello : String
    hello = "Hello, World!"
    println(hello) 
    hello = "Hello, Kotlin!"
    println(hello) 
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
Hello, World! 
Hello, Kotlin!
</syntaxhighlight>
:;型アノテーションを伴った変数 hello の宣言:<syntaxhighlight lang=kotlin line start=2 copy>
var hello : String
</syntaxhighlight>
::<code>: String</code>が型アノテーションで
:型アノテーションを伴った変数の宣言は、この様に:<syntaxhighlight lang=kotlin copy>
var 識別子 : 型
</syntaxhighlight>
:の形式をとります。
::型アノテーションをイミュータブルな変数の宣言でも行えますが、事実上初期化式が必須なのでドキュメント性を高める以外の意味は希薄です。

{{See also|[[#基本型|基本型]]}}

===== シャドーイング =====
シャドーイング( ''Shadowing'' )とは、スコープ内の2つの宣言が同じ名前になり、より内側の識別子が外側の識別子を隠すことです。

;[https://paiza.io/projects/etUJhoaySpr4RcwO9VwO-g?language=kotlin コード例]:<syntaxhighlight lang="Kotlin" line highlight="2,4">
fun main() {
    var i = 10
    
    for (i in 1..3)
        println("for内: i = $i")
    
    println("for外: i = $i")
}
</syntaxhighlight>
;コンパイラーの警告:<syntaxhighlight lang=text>
Main.kt:4:10: warning: name shadowed: i
    for (i in 1..3)
         ^
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
for内: i = 1
for内: i = 2
for内: i = 3 
for外: i = 10
</syntaxhighlight>
: ループ変数 <var>i</var> と、2行目で宣言された変数 <var>i</var> の名前が衝突しいています。
: この様に名前が衝突した場合、スコープの内側のオブジェクトが参照されます。
: コンパイラーはシャドーイングを発見すると<code>warning: name shadowed: 識別子</code>と（エラーでなく）警告します。

多くのシャドーイングは無害ですが…
;ありがちな間違え:<syntaxhighlight lang="Kotlin" line highlight="2,3">
fun main() {
    for (i in 1..3)
        for (i in 1..4)
            println("(i, i) = ($i, $i)")
}
</syntaxhighlight>
;コンパイラーのエラー出力:<syntaxhighlight lang=text>
Main.kt:3:14: warning: name shadowed: i
        for (i in 1..4)
             ^
</syntaxhighlight>
;修正例:<syntaxhighlight lang="Kotlin" line highlight="3,4">
fun main() {
    for (i in 1..3)
        for (j in 1..4)
            println("(i, j) = ($i, $j)")
}
</syntaxhighlight>
: 行列式を扱っていると、よくやらかします。

===== 分解宣言 =====
オブジェクトを複数の変数に分解して初期化する宣言する方法があり、分解宣言( ''Destructuring declarations'' )と呼ばれます<ref>[https://kotlinlang.org/docs/destructuring-declarations.html Destructuring declarations]</ref>。

;分解宣言の例:<syntaxhighlight lang="Kotlin" line highlight="2,4">
fun main() {
    val (a, b) = Pair(3, 4)
    val (c, d) = Pair("abc", 3.14)
    val (e, f) = 'C' to null
    val (g, h, i) = Triple(1,2,3)
    val (j, k, l, m) = List(4){it*2}
    print(
"""
a = $a, b = $b
c = $c, d = $d
e = $e, f = $f
g = $g, h = $h, i = $i
j = $j, k = $k, l = $l, m = $m
"""
    )
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>

a = 3, b = 4
c = abc, d = 3.14
e = C, f = null
g = 1, h = 2, i = 3 
j = 0, k = 2, l = 4, m = 6
</syntaxhighlight>
: to は infix 宣言された関数です。

== 演算子 ==
{{先頭に戻る}}
=== 演算子の優先順位 ===
:{| class="wikitable"
|+ 演算子の優先順位<ref>[https://kotlinlang.org/docs/reference/grammar.html#expressions Expressions]</ref>
!優先順位
!種類
!記号
|-
|高い
|後置
|<code>++</code>, <code>--</code>, <code>.</code>, <code>?.</code>, <code>?</code>
|-
|
|前置
|<code>-</code>, <code>+</code>, <code>++</code>, <code>--</code>, <code>!</code>, label
|-
|
|型
|<code>:</code>, <code>as</code>, <code>as?</code>
|-
|
|乗除算
|<code>*</code>, <code>/</code>, <code>%</code>
|-
|
|加減算
|<code>+</code>, <code>-</code>
|-
|
|範囲
|<code>..</code>, <code>..<</code>
|-
|
|中置関数(Infix function)
|simpleIdentifier
|-
|
|エルビス
|<code>?:</code>
|-
|
|Named checks
|<code>in</code>, <code>!in</code>, <code>is</code>, <code>!is</code>
|-
|
|比較
|<code><</code>, <code>></code>, <code><=</code>, <code>>=</code>
|-
|
|一致不一致
|<code>==</code>, <code>!=</code>, <code>===</code>, <code>!==</code>
|-
|
|Conjunction
|<code>&&</code>
|-
|
|Disjunction
|<code><nowiki>||</nowiki></code>
|-
|
|スプレッド演算子
|<code>*</code>
|-
|低い
|代入演算
|<code>=</code>, <code>+=</code>, <code>-=</code>, <code>*=</code>, <code>/=</code>, <code>%=</code>
|}
{{See also|[[#演算子と特殊シンボル|演算子と特殊シンボル]]}}

=== 演算子オーバーロード ===
{{先頭に戻る|style=border-top:1px solid gray;}}
Kotlinでは、演算子はメソッド形式の別名を持ちます。
例えば、<code>a + b</code> は <code>a.plus(b)</code> とも書けます。
この plus メンバー関数を再定義すると、演算子オーバーロードができます<ref>[https://kotlinlang.org/docs/operator-overloading.html Operator overloading]</ref>。
;[https://paiza.io/projects/mhnZrTY0BmuFApKNAy3oNw?language=kotlin コード例]:<syntaxhighlight lang=Kotlin highlight="4,22-25" line>
fun main() {
    class Point(val x : Int = 0, val y : Int = 0) {
        override fun toString() ="Point(x=$x, y=$y)"
        operator fun plus (other: Point) = Point(x + other.x, y + other.y)
        operator fun minus(other: Point) = Point(x - other.x, y - other.y)
        operator fun unaryMinus() = Point(-x, -y)
        override fun equals(other: Any?) = when {
            this === other -> true
            other !is Point -> false
            x != other.x -> false
            else -> y == other.y
        }
    }

    val p = Point(15, 25)
    val q = Point(20, 30)
    print(
"""
p => $p
p.x => ${p.x}, p.y => ${p.y}
q => $q
p.plus(q) => ${p.plus(q)}
p + q => ${p + q}
12 + 5 => ${12 + 5}
12.plus(5) => ${12.plus(5)}
----
p - q => ${p - q}
-p => ${-p}

p == q => ${p == q}
p != q => ${p != q}
p == Point(15,25) => ${p == Point(15,25)}
p != Point(15,25) => ${p != Point(15,25)}
"""
    )
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
p => Point(x=15, y=25)
p.x => 15, p.y => 25
q => Point(x=20, y=30)
p.plus(q) => Point(x=35, y=55)
p + q => Point(x=35, y=55)
12 + 5 => 17
12.plus(5) => 17
----
p - q => Point(x=-5, y=-5)
-p => Point(x=-15, y=-25)

p == q => false
p != q => true
p == Point(15,25) => true 
p != Point(15,25) => false
</syntaxhighlight>

演算子は、もちろん加算だけではありません。

:{| class="wikitable" style="float:left"
|+ 単項演算子
! 式
! メソッド形式
|-
|<code>+a</code>
|<code>a.unaryPlus()</code>
|-
|<code>-a</code>
|<code>a.unaryMinus()</code>
|-
|<code>!a</code>
|<code>a.not()</code>
|-
|<code>a++</code>
|<code>a.inc()</code>
|-
|<code>a--</code>
|<code>a.dec()</code>
|}

:{| class="wikitable" style="float:left"
|+ 算術演算
! 式
! メソッド形式
|-
|<code>a + b</code>
|<code>a.plus(b)</code>
|-
|<code>a - b</code>
|<code>a.minus(b)</code>
|-
|<code>a * b</code>
|<code>a.times(b)</code>
|-
|<code>a / b</code>
|<code>a.div(b)</code>
|-
|<code>a % b</code>
|<code>a.rem(b)</code>
|-
|<code>a..b</code>
|<code>a.rangeTo(b)</code>
|-
|<code>a..<b</code>
|<code>a.rangeUntil(b)</code>
|}

:{| class="wikitable" style="float:left"
|+ 包含
! 式
! メソッド形式
|-
|<code>a in b</code>
|<code>b.contains(a)</code>
|-
|<code>a !in b</code>
|<code>!b.contains(a)</code>
|}

:{| class="wikitable" style="float:left"
|+ インデックスによる要素参照
! 式
! メソッド形式
|-
|<code>a[i]</code>
|<code>a.get(i)</code>
|-
|<code>a[i, j]</code>
|<code>a.get(i, j)</code>
|-
|<code>a[i_1, ..., i_n]</code>
|<code>a.get(i_1, ..., i_n)</code>
|-
|<code>a[i] = b</code>
|<code>a.set(i, b)</code>
|-
|<code>a[i, j] = b</code>
|<code>a.set(i, j, b)</code>
|-
|<code>a[i_1, ..., i_n] = b</code>
|<code>a.set(i_1, ..., i_n, b)</code>
|}

:{| class="wikitable" style="float:left"
|+ 関数的な呼出し
! 式
! メソッド形式
|-
|<code>a()</code>
|<code>a.invoke()</code>
|-
|<code>a(i)</code>
|<code>a.invoke(i)</code>
|-
|<code>a(i, j)</code>
|<code>a.invoke(i, j)</code>
|-
|<code>a(i_1, ..., i_n)</code>
|<code>a.invoke(i_1, ..., i_n)</code>
|}

:{| class="wikitable" style="float:left"
|+ 代入演算
! 式
! メソッド形式
|-
|<code>a += b</code>
|<code>a.plusAssign(b)</code>
|-
|<code>a -= b</code>
|<code>a.minusAssign(b)</code>
|-
|<code>a *= b</code>
|<code>a.timesAssign(b)</code>
|-
|<code>a /= b</code>
|<code>a.divAssign(b)</code>
|-
|<code>a %= b</code>
|<code>a.remAssign(b)</code>
|}

:{| class="wikitable" style="float:left"
|+ 一致・不一致
! 式
! メソッド形式
|-
|<code>a == b</code>
|<code>a?.equals(b) ?: (b === null)</code>
|-
|<code>a != b</code>
|<code>!(a?.equals(b) ?: (b === null))</code>
|}

:{| class="wikitable" style="float:left"
|+ 比較演算
! 式
! メソッド形式
|-
|<code>a > b</code>
|<code>a.compareTo(b) > 0</code>
|-
|<code>a < b</code>
|<code>a.compareTo(b) < 0</code>
|-
|<code>a >= b</code>
|<code>a.compareTo(b) >= 0</code>
|-
|<code>a <= b</code>
|<code>a.compareTo(b) <= 0</code>
|}

<br style="clear:both">

{{:Kotlin/制御構造}}
{{:Kotlin/関数}}

== 拡張 ==
Kotlinでは、クラスやインターフェースを継承したり、Decoratorのようなデザインパターンを使わずに、新しい機能を拡張することができます。これは、拡張( ''extensions'' )と呼ばれる特別な宣言によって実現されます<ref>[https://kotlinlang.org/docs/extensions.html Extensions]</ref>。

=== 拡張関数 ===
拡張関数( ''Extension functions'' )を宣言するには、その名前の前に拡張される型を示すレシーバー型をつけます<ref>[https://kotlinlang.org/docs/extensions.html#extension-functions Extension functions]</ref>。以下は、Array<Int>にrotate関数を追加したものです。

;[https://pl.kotl.in/FiS-uHjPC Array<Int>にrotate()を定義]:<syntaxhighlight lang=kotlin line highlight=2 copy>
fun main() {
	fun Array<Int>.rotate() {
    	val t = this[0]
    	var i = 1
    	while (i < this.size) {
        	this[i - 1] = this[i]
        	i++
    	}
    	this[this.size - 1] = t
	}

    var ary = arrayOf(2, 3, 5, 7, 11)
    println("ary = ${ary.map{it.toString()}.joinToString(" ")}")
    ary.rotate()
    println("ary = ${ary.map{it.toString()}.joinToString(" ")}")
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
ary = 2 3 5 7 11 
ary = 3 5 7 11 2
</syntaxhighlight>

=== ジェネリックスと拡張関数 ===
拡張関数でも[[#ジェネリックス|ジェネリックス]]（型パラメーター）が使用可能です。

先の例は、Array<Int>とIntのアレイ専用でしたが、任意の型 T のアレイ Array<T> に拡張関数を拡張してみましょう。

;[https://pl.kotl.in/P4tm3lb8h <T>Array<T>にrotate()を定義]:<syntaxhighlight lang=kotlin line highlight=2 copy>
fun main() {
	fun <T> Array<T>.rotate() {
    	val t = this[0]
    	var i = 1
    	while (i < this.size) {
        	this[i - 1] = this[i]
        	i++
    	}
    	this[this.size - 1] = t
	}

    var ary = arrayOf(2, 3, 5, 7, 11)
    println("ary = ${ary.map{it.toString()}.joinToString(" ")}")
    ary.rotate()
    println("ary = ${ary.map{it.toString()}.joinToString(" ")}")
    
    var fary = Array(8){ val x = 1.0 * it; x * x }
    println("fary = ${fary.map{it.toString()}.joinToString(" ")}")
    fary.rotate()
    println("fary = ${fary.map{it.toString()}.joinToString(" ")}")
    
    var sary = arrayOf("A", "B", "C", "D", "E", "F")
    println("sary = ${sary.map{it.toString()}.joinToString(" ")}")
    sary.rotate()
    println("sary = ${sary.map{it.toString()}.joinToString(" ")}")
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
ary = 2 3 5 7 11 
ary = 3 5 7 11 2 
fary = 0.0 1.0 4.0 9.0 16.0 25.0 36.0 49.0 
fary = 1.0 4.0 9.0 16.0 25.0 36.0 49.0 0.0 
sary = A B C D E F 
sary = B C D E F A
</syntaxhighlight>

=== 拡張は静的に解決されます ===
拡張は、一見するとクラスの中に後からメンバー関数を追加しているように見えるかもしれませんが、<code>インスタンス.メソッド(実引数リスト)</code> のパターンに合致する拡張定義があるかを静的に調べ、該当する拡張関数があればそれを呼出すことで実現しています。

このため拡張関数でメンバー関数をオーバーライドすることはできません。

== クラス ==
{{先頭に戻る}}
Kotlinは関数型プログラミング言語であると同時に、クラスベースのオブジェクト指向プログラミング言語です。
クラス( ''class'' )はオブジェクトの設計図であり、インスタンスはその設計図に基づいて作成されます。

=== クラス定義 ===
クラスは、キーワード <code>{{Anchor|class}}</code>を使って定義します。

;[https://pl.kotl.in/WSxMHFtzA 空のクラスの定義とインスタンス化]:<syntaxhighlight lang=kotlin line highlight="1,4" copy>
class X									// クラス定義

fun main() {
    val x = X()							// インスタンス化
    println("${x::class.simpleName}")	// クラス名を表示
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
X
</syntaxhighlight>

;[https://pl.kotl.in/WlVaRbKmX private なプロパティ s を持つクラスの定義]:<syntaxhighlight lang=kotlin line highlight="1,4" copy>
class X constructor(s: String)			// クラス定義

fun main() {
    val x = X("abc")					// インスタンス化
    println("${x::class.simpleName}")	// クラス名を表示
    // x.s --- Unresolved reference: s ;; s は private なので、ここでは参照できません 
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
X
</syntaxhighlight>
: <syntaxhighlight lang=kotlin inline>class X constructor(s: String)</syntaxhighlight>
: この文脈での[[#ソフト・キーワード|ソフト・キーワード]] {{Anchor|constructor}} は、以下のように省略可能です。
: <syntaxhighlight lang=kotlin inline>class X(s: String)</syntaxhighlight>

;[https://pl.kotl.in/R7Fzx9K3G public でイミュータブルなプロパティ s を持つクラスの定義]:<syntaxhighlight lang=kotlin line highlight="1,4" copy>
class X(val s: String)			// クラス定義

fun main() {
    val x = X("abc")					// インスタンス化
    println("${x::class.simpleName}")	// クラス名を表示
    println("x.s = ${x.s}")				// プロパティーの値を表示
    // x.s = "xyz" --- Val cannot be reassigned ;; イミュータブルなプロパティーは書換え不可
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
X 
x.s = abc
</syntaxhighlight>
: プロパティーの値の参照はできますが、<code>val</code> なので書換えはできません。

;[https://pl.kotl.in/sAHYBVMIM public でミュータブルなプロパティ s を持つクラスの定義]:<syntaxhighlight lang=kotlin line highlight="1,4" copy>
class X(var s: String)			// クラス定義

fun main() {
    val x = X("abc")					// インスタンス化
    println("${x::class.simpleName}")	// クラス名を表示
    println("x.s = ${x.s}")				// プロパティーの値を表示
    x.s = "xyz"							// イミュータブルなプロパティーは値の書換えが可能
    println("x.s = ${x.s}")				// プロパティーの値を表示
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
X 
x.s = abc 
x.s = xyz
</syntaxhighlight>
: コンストラクターのパラメーターを <code>val</code> から <code>val</code> に変更したので、ミュータブルとなりプロパティーの値を変更できるようになりました。

;[https://pl.kotl.in/IODi_0xMo init はコンストラクターの後に呼出されるブロック]:<syntaxhighlight lang=kotlin line highlight="1-3" copy>
class X(var s: String) {			// クラス定義
    init {
        println("init: s = ${s}")
    }
}

fun main() {
    val x = X("abc")					// インスタンス化
    println("${x::class.simpleName}")	// クラス名を表示
    println("x.s = ${x.s}")				// プロパティーの値を表示
    x.s = "xyz"							// イミュータブルなプロパティーは値の書換えが可能
    println("x.s = ${x.s}")				// プロパティーの値を表示
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
init: s = abc 
X 
x.s = abc 
x.s = xyz
</syntaxhighlight>
: クラス定義冒頭のコンストラクターにはコードをかけないので init ブロックに書きます

=== クラスのメンバー ===
* [[#コンストラクター|コンストラクター]]( ''constructor'' )
* [[#メンバー関数|メンバー関数]]
* [[#プロパティー|プロパティー]]
* [[#インナークラス|インナークラス]]( ''inner class'' )
* [[#オブジェクト|オブジェクト]]の宣言

==== コンストラクター ====
Kotlinのクラスはプライマリーコンストラクターと1つまたは複数のセカンダリーコンストラクターを持つことができます。プライマリーコンストラクターはクラスヘッダの一部で、クラス名とオプションの型パラメターの後に続きます。
{{See also|クラス定義}}

==== メンバー関数 ====
メンバー関数は、クラス定義の中で定義された関数です<ref>[https://kotlinlang.org/docs/functions.html#member-functions Member functions]</ref>。
メンバー関数の呼出はドット記法で行います。
メンバー関数からは、プライベートなクラスのメンバーにアクセスできます。

==== プロパティ ====
==== オブジェクト ====
オブジェクトは、匿名クラスの定義とインスタンス化を同時に行うものです。
;[https://paiza.io/projects/HRaRjZqiJz8DxWz3gh_mEg?language=kotlin オブジェクトの例]:<syntaxhighlight lang=kotlin line copy>
fun main() {
    var obj = object {
        var a = 3
        var b = 4
        override fun toString() = "($a, $b)"
    }
    println(
"""
obj => $obj
obj.a => ${obj.a}, obj.b => ${obj.b} 
obj::class.simpleName => ${obj::class.simpleName}
"""
    )
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
obj => (3, 4)
obj.a => 3, obj.b => 4 
obj::class.simpleName => null
</syntaxhighlight>

=== 継承 ===
クラスは、明示的に継承元を指定しない場合は <code>Any</code> を継承します。

=== 継承モディファイア ===
継承モディファイア( ''inheritance modifier'' )には、次のような種類があり、これらのトークンは[[#モディファイア・キーワード|モディファイア・キーワード]]です。

==== abstract ====
[[#抽象クラス|抽象クラス]]( ''abstract class'' )は、抽象メンバー関数( ''abstract method'' )だけを持つクラスです。
モディファイア・キーワード <code>abstract</code> は、抽象メンバー関数の定義でも使われます。

==== final ====
[[#ファイナルクラス|ファイナルクラス]]( ''final class'' )は、継承を禁止したクラスです。
KotlinのクラスはJavaと異なり、ディフォルトで継承禁止なので、継承禁止を強調する意味しかありません。
モディファイア・キーワード <code>final</code> は、オーバーライド禁止メンバーの宣言でも使われます。

==== open ====
[[#オープンクラス|オープンクラス]]( ''open class'' )は、継承を許可したクラスです。
KotlinのクラスはJavaと異なり、ディフォルトで継承禁止なので、継承を行う可能性がある場合は明示的に許可する必要があります。
モディファイア・キーワード <code>open</code> は、メンバー関数のオーバーライド許可でも使われます。

{{コラム|Kotlinのクラスはディフォルトでfinal|2=
Javaと異なり、Kotlinのクラスはディフォルトでfinal（継承禁止）です。
これは、主にセキュリティー上の理由からで、クラスを継承することによりprotectedでの隠蔽に綻びが生じプログラムが「ハイジャック」されることの重要さに配慮したもので、
クラス設計に於いてのトレードオフ、「拡張性と頑強性」のディフォルトを頑強に振った言語設計になっています。

{{See also|[https://www.jpcert.or.jp/java-rules/obj00-j.html OBJ00-J. 不変条件を持つクラスやメソッドの拡張は信頼できるサブクラスのみに許す]}}
}}

=== this ===
クラスのメンバー関数が、プロパティやメンバー関数を参照するとき、クラスの外の変数や関数との間で曖昧さが生じる事があります。
このようなときには、インスタンスを表すキーワード <code>{{Anchor|this}}</code> を使います<ref>[https://kotlinlang.org/docs/this-expressions.html This expressions]</ref>。

<code>this</code> はこのほか、2 次コンストラクタから同じクラスの別のコンストラクタを呼出すときにもつかわれます。

;[https://paiza.io/projects/a6IABje1M-ZOPH4asPyCpQ?language=kotlin thisを使ったメンバー関数の限定]:<syntaxhighlight lang=kotlin line copy>
fun main() {
    fun printLine() = println("Function") 

    class Simple {
        fun printLine() = println("Method")
        fun printLineNone() = printLine()
        fun printLineThis() = this.printLine()
    }
    val s = Simple()
    s.printLine()
    s.printLineNone()
    s.printLineThis()
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
Method
Function
Method
</syntaxhighlight>
: メンバー関数から同じクラスのメンバー関数を呼出すとき、同名の関数があると関数が呼出されます。
: メンバー関数から同じクラスのメンバー関数を呼出すときには、同名の関数があると関数が呼出されます。

=== クラスモディファイア ===
クラスモディファイア( ''class modifier'' )には、次のような種類があり、これらのトークンは[[#モディファイア・キーワード|モディファイア・キーワード]]です。

==== enum ====
[[#列挙型クラス|列挙型クラス]]( ''Enum class'' )は、有限個の識別子の集合を表現するために使用されます。

:<syntaxhighlight lang=kotlin copy>
enum class DayOfWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

fun main() {
    val today = DayOfWeek.MONDAY
    println("Today is $today")
}
</syntaxhighlight>

;特性と用途
* 特定の値の集合を表現するために使用されます（例: 曜日、状態など）。
* 定数のような振る舞いを持ち、列挙型の各要素は固定された値として使用されます。

==== sealed ====
シールドクラス( ''Sealed class'' )は、制限されたクラス階層を表現するために使用されます。

:<syntaxhighlight lang=kotlin copy>
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Success: ${result.data}")
        is Result.Error -> println("Error: ${result.message}")
    }
}

fun main() {
    val successResult = Result.Success("Data")
    val errorResult = Result.Error("An error occurred")

    handleResult(successResult)
    handleResult(errorResult)
}
</syntaxhighlight>

;特性と用途
* 制限されたクラス階層を定義するために使用されます。サブクラスは通常、シールドクラス内にネストされます。
* シールドクラスのサブクラスは通常、特定の型の状態や結果を表現するために使用されます。

==== annotation ====
[[#アノテーションクラス|アノテーションクラス]]( ''annotation class'' )は、コードにメタデータを付加するための手段を提供します。

:<syntaxhighlight lang=kotlin copy>
annotation class Author(val name: String)

@Author("John Doe")
class Book {
    // ブックの定義
}

fun main() {
    val book = Book::class.java
    val authorAnnotation = book.getAnnotation(Author::class.java)
    val authorName = authorAnnotation?.name

    println("Author: $authorName")
}
</syntaxhighlight>

;特性と用途
* コードに追加情報や設定を提供するために使用されます。
* ランタイムやコンパイル時にアノテーションを処理することで、特定の動作やコード生成をトリガーすることができます。

==== data ====
[[#データクラス|データクラス]]( ''Data class'' )は、データを保持するためのクラスで、copy() などのメンバー関数がクラスを定義しただけで生えてきます。

:<syntaxhighlight lang=kotlin copy>
data class Person(val name: String, val age: Int)

fun main() {
    val person = Person("Alice", 25)
    val copyPerson = person.copy(age = 30)

    println(person)
    println(copyPerson)
}
</syntaxhighlight>

;特性と用途
* データのコンテナとして使用され、自動的にequals()、hashCode()、toString()、copy()メソッドが生成されます。
* イミュータブルなデータオブジェクトを簡潔に表現するために使用されます。

==== inner ====
[[#インナークラス|インナークラス]]( ''Inner class'' )は、入れ子になった内側になったクラスが外側のクラスのメンバーにアクセスすることを可能にします。

:<syntaxhighlight lang=kotlin copy>
class Outer {
    private val outerProperty = "Outer Property"

    inner class Inner {
        fun printOuterProperty() {
            println(outerProperty)
        }
    }
}

fun main() {
    val outer = Outer()
    val inner = outer.Inner()
    inner.printOuterProperty()
}
</syntaxhighlight>

;特性と用途
* 外側のクラスのインスタンスに紐づく内側のクラスを定義するために使用されます。
* 内側のクラスは外側のクラスの非公開メンバーやプロパティにアクセスすることができます。

==== value ====
[[#値クラス|値クラス]]( ''Value class'' )は、イミュータブルなスカラー値の型を定義します。プロポーザル段階では inline class と呼ばれていました。

:<syntaxhighlight lang=kotlin copy>
inline class Password(val value: String)

fun main() {
    val password = Password("secret")
    println("Password: ${password.value}")
}
</syntaxhighlight>

;特性と用途
* 単一の値を表すために使用されます。プリミティブ型のように振る舞い、ボックス化のオーバーヘッドを回避します。
+ ラッパークラスとして機能し、型安全性やコードの表現力を向上させます。

==== object ====
[[#オブジェクト|オブジェクト]]( ''object'' )は、モディファイア・キーワードではありませんが、特殊なクラスの一種なので併せて紹介します。
オブジェクトは一過的な匿名クラスを定義し、そのインスタンスの生成を行います。

:<syntaxhighlight lang=kotlin copy>
object Logger {
    fun log(message: String) {
        println("Log: $message")
    }
}

fun main() {
    Logger.log("Hello, World!")
}
</syntaxhighlight>

;特性と用途
* シングルトンパターンを実装するために使用されます。クラスの単一のインスタンスを表現し、グローバルなアクセスポイントとして機能します。
* 関連するメソッドやプロパティを含めることができ、特定の目的に特化したオブジェクトを表現することができます。

;まとめ
各クラスモディファイアは、異なる用途や特性を持っており、柔軟なクラス定義を可能にします。
適切なモディファイアを選択することで、コードの意図を明確に表現し、保守性や可読性を向上させることができます。

=== 可視性モディファイア ===
[[#クラス|クラス]]、[[#オブジェクト|オブジェクト]]、[[#インターフェース|インターフェース]]、[[#コンストラクター|コンストラクター]]、[[#関数|関数]]、および[[#プロパティ|プロパティ]]とその[[#セッター|セッター]]は、可視性モディファイア( ''Visibility modifiers'' )を持つことができます。ゲッターは常にそのプロパティと同じ可視性を持っています<ref>[https://kotlinlang.org/docs/visibility-modifiers.html Visibility modifiers]</ref>。

可視性モディファイアには、次のような4種類があり、これらのトークンは[[#モディファイア・キーワード|モディファイア・キーワード]]です。

* [[#private|private]]
* [[#protected|protected]]
* [[#internal|internal]]
* [[#public|public]]
デフォルトの可視性はpublicです。

==== パッケージ ====
関数、プロパティ、クラス、オブジェクト、およびインタフェースは、パッケージの中で直接「トップレベル」で宣言することができます。

* 可視性モディファイアを使用しない場合、デフォルトではpublicが使用され、宣言はどこでも見えるようになります。
* 宣言に private を指定すると、その宣言を含むファイル内でのみ可視化されます。
* internalと指定した場合は、同じモジュール内であればどこでも見えるようになります。
* protected修飾子は、トップレベルの宣言には使えません。

==== クラスのメンバー ====
クラス内部で宣言されたメンバー。

* private は、そのメンバーがこのクラスの内部でのみ可視であることを意味します（そのクラスのすべてのメンバーを含む）。
* protected は、private とマークされたメンバーと同じ可視性を持ちますが、サブクラスでも可視化されることを意味します。
* internal は、宣言したクラスを見たこのモジュール内のクライアントが、その内部のメンバーを見ることができることを意味します。
* public は、宣言クラスを見たすべてのクライアントがその public メンバを見ることができることを意味します。
protectedまたはinternalメンバーをオーバーライド( ''override'' )し、可視性を明示的に指定しない場合、オーバーライドしたメンバーも元のメンバーと同じ可視性を持つことになります。

===== コンストラクター =====
クラスの一次コンストラクタの可視性を指定するには、次の構文を使用します。

:<syntaxhighlight lang=kotlin copy>
class C private constructor(a: Int) { ... }
</syntaxhighlight>
:ここでは、コンストラクターは private です。デフォルトでは、すべてのコンストラクターは public です。これは、クラスが見えるところならどこでもコンストラクターが見えるということです（裏を返せば、内部クラスのコンストラクターは同じモジュール内でしか見えないということです）。

===== ローカル宣言 =====
ローカル変数、関数、クラスは可視性モディファイアを持つことができません。

==== モジュール ====
internal 可視性モディファイアは、そのメンバーが同じモジュール内で可視であることを意味します。具体的にモジュールとは、例えば、一緒にコンパイルされたKotlinファイルの集合のことです。

* IntelliJ IDEAモジュール。
* Mavenプロジェクト
* Gradleのソースセット（ただし、testのソースセットはmainの内部宣言にアクセスできる）。
* ''kotlinc'' Antタスクの1回の呼び出しでコンパイルされるファイル群。

=== 抽象クラス ===
抽象クラス( ''abstract class'' )は、抽象メソッド( ''abstract method'' )だけを持つクラスであり、直接のインスタンス化ができません。抽象メソッドは本体を持たず、具体的な実装はそのサブクラスに委ねられます。Kotlinでは、<code>abstract</code> キーワードを使用して抽象クラスと抽象メソッドを宣言します。

==== 抽象クラスの宣言 ====
:<syntaxhighlight lang=kotlin copy>
abstract class Shape {
    abstract fun draw()
}

class Circle : Shape() {
    override fun draw() {
        println("Drawing a circle")
    }
}

class Rectangle : Shape() {
    override fun draw() {
        println("Drawing a rectangle")
    }
}
</syntaxhighlight>
 
上記の例では、<code>Shape</code> という抽象クラスがあります。このクラスは抽象メソッド <code>draw</code> を宣言しています。サブクラスである <code>Circle</code> と <code>Rectangle</code> は、それぞれ <code>draw</code> メソッドをオーバーライドして具体的な実装を提供します。

==== 抽象クラスのインスタンス化 ====
:<syntaxhighlight lang=kotlin copy>
fun main() {
    // コンパイルエラー: Cannot create an instance of an abstract class
    // val shape = Shape()

    val circle = Circle()
    circle.draw()

    val rectangle = Rectangle()
    rectangle.draw()
}
</syntaxhighlight>
 
抽象クラスは直接インスタンス化できないため、<code>Shape</code> クラスのインスタンスを作成しようとするとコンパイルエラーが発生します。代わりに、具象サブクラスである <code>Circle</code> や <code>Rectangle</code> のインスタンスを作成して使用します。

==== 抽象プロパティとコンストラクタ ====
抽象クラスは抽象プロパティを持つこともできます。また、抽象クラス自体はコンストラクタを持つことができます。

:<syntaxhighlight lang=kotlin copy>
abstract class Shape(val name: String) {
    abstract fun draw()
}

class Circle(name: String) : Shape(name) {
    override fun draw() {
        println("Drawing a circle named $name")
    }
}

class Rectangle(name: String) : Shape(name) {
    override fun draw() {
        println("Drawing a rectangle named $name")
    }
}
</syntaxhighlight>

この例では、<code>Shape</code> クラスはコンストラクタを持ち、<code>name</code> という抽象プロパティを宣言しています。サブクラスである <code>Circle</code> と <code>Rectangle</code> は、コンストラクタで <code>name</code> を渡し、<code>draw</code> メソッドをオーバーライドしています。

抽象クラスは、クラス階層の一部として柔軟で再利用可能なコードを設計する際に役立ちます。

==== ユースケースとベストプラクティス ====
抽象クラスは、以下のようなユースケースやベストプラクティスに適しています。

;部分的な実装の提供: 抽象クラスは、一部のメソッドやプロパティの実装を提供することができます。これにより、サブクラスは抽象メソッドだけでなく、既存の実装を再利用できます。
:<syntaxhighlight lang=kotlin copy>
abstract class Shape {
    fun commonMethod() {
        // 共通の実装
    }

    abstract fun draw()
}
</syntaxhighlight>
;メソッドの強制: 抽象クラスには抽象メソッドが含まれており、これをサブクラスで実装することが義務付けられます。これにより、サブクラスが特定のメソッドを実装することが保証されます。
:<syntaxhighlight lang=kotlin copy>
abstract class Printer {
    abstract fun print()
}

class LaserPrinter : Printer() {
    override fun print() {
        // レーザープリンターの実装
    }
}
</syntaxhighlight>
;継承と拡張: 抽象クラスを使用すると、クラス階層を構築し、新しい機能を追加していくことができます。これは、将来的に変更や拡張が発生する可能性がある場合に特に役立ちます。
:<syntaxhighlight lang=kotlin copy>
abstract class Animal {
    abstract fun makeSound()
}

class Dog : Animal() {
    override fun makeSound() {
        println("Woof!")
    }
}

class Cat : Animal() {
    override fun makeSound() {
        println("Meow!")
    }
</syntaxhighlight>
;コンストラクタとプロパティ: 抽象クラスはコンストラクタを持ち、抽象プロパティを宣言できます。これにより、サブクラスが特定のプロパティを持つことが保証され、コンストラクタで初期化できます。
:<syntaxhighlight lang=kotlin copy>
abstract class Vehicle(val model: String) {
    abstract fun start()
    abstract fun stop()
}

class Car(model: String) : Vehicle(model) {
    override fun start() {
        println("Starting the car")
    }

    override fun stop() {
        println("Stopping the car")
    }
}
</syntaxhighlight>
;複数のインターフェースの代替: 抽象クラスは複数のメソッドやプロパティをまとめて提供できるため、インターフェースが多すぎる場合に、抽象クラスを使用して階層を整理することができます。
:<syntaxhighlight lang=kotlin copy>
abstract class UIControl {
    abstract fun render()
    abstract fun onClick()
}

class Button : UIControl() {
    override fun render() {
        println("Rendering button")
    }

    override fun onClick() {
        println("Button clicked")
    }
}
</syntaxhighlight>

抽象クラスは、柔軟性と再利用性を向上させるために使われますが、適切に設計される必要があります。必要以上に多くの機能を含めると、過度な依存関係が生まれる可能性があるため、慎重な設計が求められます。









=== ファイナルクラス ===
ファイナルクラス（<code>final class</code>）は、Kotlinにおいて継承を禁止したクラスを指します。Kotlinでは、デフォルトでクラスが継承不可（<code>final</code>）となっており、継承可能にするためには明示的に<code>open</code>修飾子を使用する必要があります。そのため、<code>final</code>キーワードは主にオーバーライド禁止メンバーの宣言で使用され、クラス自体に適用することは少ないです。

==== ファイナルクラスの宣言 ====
:<syntaxhighlight lang=kotlin copy>
final class MyFinalClass {
    // クラスの定義
}
</syntaxhighlight> 

上記の例では、<code>MyFinalClass</code> はファイナルクラスとして宣言されています。このクラスは他のクラスから継承できません。

==== オーバーライド禁止メンバーの宣言 ====
:<syntaxhighlight lang=kotlin copy>
open class MyBaseClass {
    final fun myFinalMethod() {
        // オーバーライド禁止のメソッド
    }
}
</syntaxhighlight> 
 
上記の例では、<code>MyBaseClass</code> の <code>myFinalMethod</code> は <code>final</code> 修飾子が付いており、このメソッドはオーバーライドできません。

==== ファイナルクラスの利用例 ====
:<syntaxhighlight lang=kotlin copy>
final class Configuration {
    // クラスの定義
}

class ApplicationSettings(config: Configuration) {
    // FinalClass を利用したクラスの定義
}
</syntaxhighlight> 
 
上記の例では、<code>Configuration</code> クラスがファイナルクラスとして定義されています。このクラスは他のクラスから継承できないため、設定情報の不正な変更や上書きを防ぐことが期待されます。<code>ApplicationSettings</code> クラスは <code>Configuration</code> を利用してアプリケーションの設定を管理しています。

ファイナルクラスは特定の状況で利用され、継承を禁止してクラスの拡張を制御するために使用されます。

=== オープンクラス ===
オープンクラス（<code>open class</code>）は、Kotlinにおいて継承を許可したクラスを指します。
Kotlinのクラスはデフォルトで継承不可（<code>final</code>）となっているため、クラスを継承可能にするには明示的に<code>open</code>修飾子を使用する必要があります。

==== オープンクラスの宣言 ====
:<syntaxhighlight lang=kotlin copy>
open class MyOpenClass {
    // クラスの定義
}
</syntaxhighlight>

上記の例では、<code>MyOpenClass</code> はオープンクラスとして宣言されています。このクラスは他のクラスから継承できます。

==== メソッドのオーバーライド許可 ====
:<syntaxhighlight lang=kotlin copy>
open class MyBaseClass {
    open fun myMethod() {
        // オーバーライド可能なメソッド
    }
}
</syntaxhighlight>

上記の例では、<code>MyBaseClass</code> の <code>myMethod</code> は <code>open</code> 修飾子が付いており、このメソッドはオーバーライド可能です。

==== オープンクラスの利用例 ====
:<syntaxhighlight lang=kotlin copy>
open class Shape {
    open fun draw() {
        println("Drawing a shape")
    }
}

class Circle : Shape() {
    override fun draw() {
        println("Drawing a circle")
    }
}

class Square : Shape() {
    override fun draw() {
        println("Drawing a square")
    }
}
</syntaxhighlight>

上記の例では、<code>Shape</code> クラスがオープンクラスとして定義されています。<code>Circle</code> と <code>Square</code> クラスが <code>Shape</code> を継承し、<code>draw</code> メソッドをオーバーライドしています。これにより、各図形クラスは自身の特定の描画方法を持つことができます。

オープンクラスは継承を許可し、クラスの拡張やカスタマイズが可能となります。ただし、使用する際には慎重に設計し、必要なメソッドやプロパティに対してのみ<code>open</code>修飾子を使用することが推奨されます。

=== 列挙型クラス ===
{{先頭に戻る}}

列挙型クラス( ''Enum classes'' )は、キーワード <code>enum</code> を <code>class</code> に前置して定義します<ref>[https://kotlinlang.org/docs/enum-classes.html Enum classes]</ref>。

[[Swift/オブジェクト指向#列挙型]]の例を Kotlin 向けにモディファイしました。
;[https://paiza.io/projects/lW6ghepnPWyQnctPdyX6Zw?language=kotlin 列挙型クラスとメソッド]:<syntaxhighlight lang=kotlin line copy>
enum class Azimuth {
  North,
  South,
  East,
  West;
  
  override fun toString() = when (this) {
    Azimuth.North -> "北"
    Azimuth.South -> "南"
    Azimuth.East -> "東"
    Azimuth.West -> "西"
    }
  fun deg() = when (this) {
    Azimuth.North -> 0 * 90
    Azimuth.South -> 2 * 90
    Azimuth.East -> 1 * 90
    Azimuth.West -> 3 * 90
    }
}

fun main() {
    val n = Azimuth.North
    println("n => $n, az.deg() => ${n.deg()}")
    println("------------------------------------")
    for (az in Azimuth.values()) {
        println("as.name =>${az.name}, as => $az, az.deg() => ${az.deg()}")
    }
    println(enumValues<Azimuth>().joinToString{it.name})
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
n => 北, az.deg() => 0
------------------------------------
as.name =>North, as => 北, az.deg() => 0
as.name =>South, as => 南, az.deg() => 180
as.name =>East, as => 東, az.deg() => 90
as.name =>West, as => 西, az.deg() => 270 
North, South, East, West
</syntaxhighlight>
: override fun toString() でEnumのディフォルトの文字列化メソッドをオーバーライドしています。

=== シールドクラス ===
シールドクラス（<code>Sealed class</code>）は、制限されたクラス階層を表現するために使用される Kotlin 特有の機能です。シールドクラスは、特定のサブクラスのみを許容し、新しいサブクラスの追加を防ぎます。これにより、特定の型に対するパターンマッチングが容易になります。

==== シールドクラスの宣言 ====
:<syntaxhighlight lang=kotlin copy>
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}
</syntaxhighlight>

上記の例では、<code>Result</code> クラスはシールドクラスとして宣言されています。このクラスには3つのサブクラスがあります：<code>Success</code>、<code>Error</code>、および <code>Loading</code>。<code>Success</code> と <code>Error</code> はデータクラスで、それぞれデータを保持します。<code>Loading</code> はオブジェクトクラスで、データを保持しません。

==== シールドクラスの利用例 ====
:<syntaxhighlight lang=kotlin copy>
fun processResult(result: Result) {
    when (result) {
        is Result.Success -> println("Success: ${result.data}")
        is Result.Error -> println("Error: ${result.message}")
        Result.Loading -> println("Loading...")
    }
}
</syntaxhighlight>

上記の例では、<code>Result</code> クラスのサブクラスごとに異なる処理を行う <code>processResult</code> 関数があります。<code>when</code> 式を使用して、特定のサブクラスに対するパターンマッチングを行っています。

==== 利点 ====
* コンパイラがすべてのサブクラスを知っているため、<code>when</code> 式などのパターンマッチングが網羅的であることを確認できます。
* 新しいサブクラスが追加された場合、コンパイラは未処理のケースがあるかどうかを検知し、警告を発生させます。

==== 制限 ====
* シールドクラスは同じファイル内で宣言されたクラスに対してしか有効ではありません。

シールドクラスは、特に固定されたクラス階層を表現する場合や、特定の型に対する安全なパターンマッチングを行う場合に便利です。

=== アノテーションクラス ===
アノテーションクラス（<code>annotation class</code>）は、Kotlinにおいてコードにメタデータを付加するための手段を提供します。これにより、コンパイラや実行時の処理で追加の情報を提供することが可能となります。

==== アノテーションクラスの宣言 ====
アノテーションクラスは、<code>@</code>シンボルを使って宣言されます。アノテーションクラスの主な目的は、アノテーションを作成し、それをコードの要素に適用することです。

:<syntaxhighlight lang=kotlin copy>
annotation class MyAnnotation(val name: String, val version: Int)
</syntaxhighlight>

上記の例では、<code>MyAnnotation</code> というアノテーションクラスが宣言されています。このアノテーションは、<code>name</code> と <code>version</code> というパラメータを持っています。

==== アノテーションの利用 ====
アノテーションは、クラスや関数、プロパティなど、さまざまな要素に適用できます。

:<syntaxhighlight lang=kotlin copy>
@MyAnnotation(name = "MyApp", version = 1)
class MyClass {
    @MyAnnotation(name = "MyFunction", version = 2)
    fun myFunction() {
        // 関数の本体
    }
}
</syntaxhighlight>

上記の例では、<code>MyClass</code> クラスとその中の <code>myFunction</code> 関数に <code>MyAnnotation</code> が適用されています。これにより、このクラスや関数に対する追加のメタデータが提供されます。

==== アノテーションのプロセッシング ====
アノテーションをプロセッシングするためには、リフレクションやKotlinのアノテーションプロセッサを使用することがあります。これにより、アノテーションに関連する処理を行うカスタムロジックを実装できます。

:<syntaxhighlight lang=kotlin copy>
// アノテーションプロセッサの例
fun processMyAnnotation(element: AnnotatedElement) {
    val myAnnotation = element.getAnnotation(MyAnnotation::class.java)
    if (myAnnotation != null) {
        println("Name: ${myAnnotation.name}, Version: ${myAnnotation.version}")
    }
}
</syntaxhighlight>

上記の例では、<code>AnnotatedElement</code>を受け取り、その要素に <code>MyAnnotation</code> が適用されているかを調べ、情報を取得しています。

アノテーションクラスは、コードにメタデータを追加し、プロセッシングや設定などの目的で使用されます。

=== データクラス ===
データクラス（<code>Data class</code>）は、Kotlinにおいてデータの保持や操作を目的としたクラスで、<code>copy()</code> メソッドなどがクラスを定義するだけで自動的に生成されます。これにより、不変性やイミュータビリティ（immutable）を維持しながら、簡潔で効果的なデータクラスを作成できます。

==== データクラスの宣言 ====
:<syntaxhighlight lang=kotlin copy>
data class Person(val name: String, val age: Int)
</syntaxhighlight>

上記の例では、<code>Person</code> クラスがデータクラスとして宣言されています。コンストラクタで定義されたプロパティ（<code>name</code> と <code>age</code>）に対して、<code>equals()</code>、<code>hashCode()</code>、<code>toString()</code> などの標準メソッドが自動的に生成されます。

==== データクラスの利用 ====
:<syntaxhighlight lang=kotlin copy>
val person1 = Person("Alice", 30)
val person2 = Person("Alice", 30)

// equals() メソッドにより、プロパティの内容が一致するか比較
println(person1 == person2) // true

// toString() メソッドにより、クラスの内容を文字列として表示
println(person1.toString()) // Person(name=Alice, age=30)

// copy() メソッドにより、一部のプロパティを変更した新しいインスタンスを作成
val modifiedPerson = person1.copy(age = 31)
println(modifiedPerson) // Person(name=Alice, age=31)
</syntaxhighlight>

上記の例では、<code>equals()</code> メソッドにより <code>person1</code> と <code>person2</code> の内容が一致するか比較され、<code>toString()</code> メソッドによりクラスの内容が文字列として表示されます。また、<code>copy()</code> メソッドを使って一部のプロパティを変更した新しいインスタンスを作成しています。

==== データクラスの生成されるメソッド ====
データクラスが生成される主なメソッドは以下の通りです。

* <code>equals()</code>: プロパティごとの内容比較を行います。
* <code>hashCode()</code>: プロパティごとにハッシュコードを生成します。
* <code>toString()</code>: クラスの内容を文字列として返します。
* <code>copy()</code>: インスタンスのコピーを作成します。一部のプロパティを変更できます。

データクラスは、イミュータブルでありながら効果的にデータを操作するための便利な手段を提供します。

=== インターフェース ===
Kotlinのインターフェース（<code>interface</code>）は、抽象的なメソッドの宣言と、メソッドの実装を含むことができます。インターフェースは、抽象クラスと異なり状態を保持することができません。プロパティを持つ場合、これらは抽象クラスであるか、アクセサーの実装を提供する必要があります<ref>[https://kotlinlang.org/docs/interfaces.html Interfaces]</ref>。

==== インターフェースの宣言 ====
:<syntaxhighlight lang=kotlin copy>
interface MyInterface {
    fun doSomething() // 抽象メソッドの宣言

    fun doSomethingElse() {
        // デフォルトのメソッド実装
        println("Default implementation of doSomethingElse")
    }

    val property: Int // 抽象プロパティの宣言
}
</syntaxhighlight>

上記の例では、<code>MyInterface</code> インターフェースが、抽象メソッド <code>doSomething()</code> とデフォルトのメソッド <code>doSomethingElse()</code>、抽象プロパティ <code>property</code> を宣言しています。

==== インターフェースの実装 ====
:<syntaxhighlight lang=kotlin copy>
class MyClass : MyInterface {
    override fun doSomething() {
        // メソッドの実装
        println("Implementation of doSomething")
    }

    override val property: Int
        get() = 42 // プロパティの実装
}
</syntaxhighlight>

上記の例では、<code>MyClass</code> クラスが <code>MyInterface</code> インターフェースを実装しています。<code>doSomething()</code> メソッドと <code>property</code> プロパティをオーバーライドしています。

==== インターフェースの複数準拠 ====
:<syntaxhighlight lang=kotlin copy>
interface A {
    fun methodA()
}

interface B {
    fun methodB()
}

class C : A, B {
    override fun methodA() {
        // A インターフェースの実装
    }

    override fun methodB() {
        // B インターフェースの実装
    }
}
</syntaxhighlight>

上記の例では、<code>C</code> クラスが <code>A</code> インターフェースと <code>B</code> インターフェースの両方を実装しています。複数のインターフェースをカンマで区切って指定することができます。

==== インターフェースの継承 ====
:<syntaxhighlight lang=kotlin copy>
interface D : A, B {
    fun methodD()
}
</syntaxhighlight>

上記の例では、<code>D</code> インターフェースが <code>A</code> インターフェースと <code>B</code> インターフェースを継承しています。これにより、<code>D</code> インターフェースは <code>A</code> と <code>B</code> のメソッドを含むことになります。

Kotlinのインターフェースは、クラスが異なる振る舞いを持つ場合に簡潔で柔軟な解決策を提供します。異なるインターフェースを実装することで、複数の振る舞いを同じクラスで組み合わせることができます。

=== インナークラス ===
インナークラス（<code>Inner class</code>）は、入れ子になった内側のクラスが外側のクラスのメンバーにアクセスすることを可能にします。これにより、外側のクラスと強い結びつきを持ちながら、内部で独自の振る舞いやデータを持つクラスを定義できます。

==== インナークラスの宣言 ====
<syntaxhighlight lang=kotlin copy>
class OuterClass {
    private val outerProperty: Int = 10

    inner class InnerClass {
        fun printOuterProperty() {
            // OuterClass のプロパティにアクセス
            println("Outer property: $outerProperty")
        }
    }
}
</syntaxhighlight>

上記の例では、<code>OuterClass</code> という外側のクラスがあり、その中に <code>InnerClass</code> というインナークラスが定義されています。<code>InnerClass</code> は <code>OuterClass</code> のプロパティにアクセスすることができます。

==== インナークラスの利用 ====
<syntaxhighlight lang=kotlin copy>
fun main() {
    val outerInstance = OuterClass()
    val innerInstance = outerInstance.InnerClass()

    innerInstance.printOuterProperty()
}
</syntaxhighlight>

上記の例では、<code>OuterClass</code> のインスタンスを作成し、そのインナークラスである <code>InnerClass</code> のインスタンスを取得しています。そして、<code>InnerClass</code> のメソッドを呼び出して外側のクラスのプロパティにアクセスしています。

==== インナークラスの特徴 ====

# 外部クラスへのアクセス: インナークラスは、外部クラスのメンバーにアクセスできます。外部クラスのプロパティやメソッドに直接アクセスできるため、疎結合な設計が可能です。
# thisキーワードの挙動: インナークラスでは、外部クラスのインスタンスにアクセスするために <code>this@OuterClass</code> のように明示的な指定ができます。これにより、外部クラスのメンバーと同じ名前のメンバーがインナークラス内にある場合に区別できます。
# 非静的なクラス: インナークラスは外部クラスのインスタンスに依存しており、非静的なクラスです。したがって、外部クラスのインスタンスが存在しないとインナークラスも存在しません。

インナークラスは、外部クラスとの緊密な連携が必要な場合や、外部クラスのプライベートなメンバーにアクセスする必要がある場合に有用です。

=== 値クラス ===
値クラス（<code>data class</code>）は、イミュータブルでスカラーな値の型を定義するための概念です。プロポーザル段階では <code>inline class</code> と呼ばれていました。値クラスは、プリミティブ型のように振る舞い、同時に型安全性を提供します。

==== 値クラスの宣言 ====
<syntaxhighlight lang=kotlin copy>
data class Email(val value: String)
</syntaxhighlight>

上記の例では、<code>Email</code> という値クラスが宣言されています。この値クラスは、イミュータブルであり、<code>value</code> というプロパティを持っています。

==== 値クラスの利用 ====
<syntaxhighlight lang=kotlin copy>
fun main() {
    val email1 = Email("john@example.com")
    val email2 = Email("jane@example.com")

    println(email1 == email2) // 値クラスの比較
}
</syntaxhighlight>

上記の例では、異なるインスタンスの <code>Email</code> クラスを作成し、その値が等しいかを比較しています。値クラスでは、プライマリコンストラクタの引数で値が確定し、その値に基づいて等価性が判定されます。

==== 値クラスの特徴 ====

# イミュータブル性: 値クラスは不変（イミュータブル）であるため、一度生成されたインスタンスの値は変更されません。これにより、安全で予測可能なコードを実現します。
# 型安全性: 値クラスは型安全性を提供します。異なる値クラス間は厳密に区別され、混同されることがありません。
# 自動生成メソッド: 値クラスは <code>equals()</code> や <code>hashCode()</code> などのメソッドを自動生成します。これにより、等価性の確認やコレクションの利用が容易になります。
# ボクシングの回避: 値クラスはプリミティブ型のように振る舞い、一部のボクシングを回避します。これにより、メモリ効率が向上します。

値クラスは、ドメインモデリングや特定のデータ型を表現する際に有用であり、プロジェクト全体でのコードの理解性や保守性を向上させる役割を果たします。

=== オブジェクト ===
オブジェクト（<code>object</code>）は、モディファイア・キーワードではありませんが、特殊なクラスの一種であり、一過的な匿名クラスを定義し、その唯一のインスタンスを生成します。オブジェクトはシングルトンのような振る舞いを持ち、一般的には特定の目的に使用されます。

==== オブジェクトの宣言 ====
<syntaxhighlight lang=kotlin copy>
object Logger {
    fun log(message: String) {
        println("Log: $message")
    }
}
</syntaxhighlight>

上記の例では、<code>Logger</code> という名前のオブジェクトが宣言されています。このオブジェクトはシングルトンであり、<code>log</code> メソッドを持っています。

==== オブジェクトの利用 ====
<syntaxhighlight lang=kotlin copy>
fun main() {
    Logger.log("This is a log message.")
}
</syntaxhighlight>

上記の例では、<code>Logger</code> オブジェクトの唯一のインスタンスにアクセスし、その <code>log</code> メソッドを呼び出しています。オブジェクトは初回のアクセス時に遅延初期化され、以降は同じインスタンスが再利用されます。

==== オブジェクトの特徴 ====

# シングルトンパターン: オブジェクトはシングルトンとして振る舞います。クラスの唯一のインスタンスを持ち、それにアクセスするために新たなインスタンスを生成することはありません。
# 遅延初期化: オブジェクトは初回のアクセス時に初期化されます。これにより、プログラムが実際に必要なときに初期化処理が行われます。
# クラスメンバー: オブジェクトはメソッドやプロパティを持つことができます。これらは通常のクラスメンバーと同じようにアクセスできます。
# 継承不可: オブジェクトは継承できません。そのため、他のクラスがこのオブジェクトを継承することはできません。

オブジェクトは特定のタスクや目的に対して唯一のインスタンスを提供する場合に利用され、例えばロギングや設定の管理などに適しています。

== ジェネリックス ==
{{先頭に戻る}}
ジェネリックス( ''Generics'' )とは、汎用的なクラス・関数やメソッドを特定の型に対応づける機能のことです<ref>[https://kotlinlang.org/docs/generics.html Generics: in, out, where]</ref>。

== キーワード一覧 ==
{{先頭に戻る}}
Kotlinの{{Anchor|キーワード}}( ''Keywords'' )は
* [[#ハード・キーワード|ハード・キーワード]]
* [[#ソフト・キーワード|ソフト・キーワード]]
* [[#モディファイア・キーワード|モディファイア・キーワード]]
* [[#特殊識別子|特殊識別子]]
* [[#演算子と特殊シンボル|演算子と特殊シンボル]]
に分類されます<ref>[https://kotlinlang.org/docs/keyword-reference.html Keywords and operators]</ref>。

=== ハード・キーワード ===
{{先頭に戻る|style=border-top:1px solid gray;}}
以下のトークンは、常にキーワードとして解釈され、識別子として使用することはできません<ref>[https://kotlinlang.org/docs/keyword-reference.html#hard-keywords Hard keywords]</ref>。
このようなキーワードをハード・キーワード( ''Hard keywords'' )と呼びます。

* <code>[[#as|as]]</code>
*# 型キャスト( ''type casts'' )に使用されます。
*# インポートの別名の指定に使用されます。
* <code>[[#as?|as?]]</code> 安全なタイプキャスト( ''safe type casts'' )に使用されます。
* <code>[[#break|break]]</code> ループの実行を終了させます。
* <code>[[#class|class]]</code> クラスを宣言します。
* <code>[[#continue|continue]]</code> 最も近いループの次のステップに進みます。
* <code>[[#do|do]]</code> do/whileループ（条件式を後置するつループ）を開始します。
* <code>[[#else|else]]</code> 条件が偽のときに実行されるif式の分岐を定義します。
* <code>[[#false|false]]</code> Boolean型の「偽」の値を表します。
* <code>[[#for|for]]</code> forループを開始します。
* <code>[[#fun|fun]]</code> 関数を宣言します。
* <code>[[#if|if]]</code> if式の先頭です。
* <code>[[#in|in]]</code>
*# forループで反復されるオブジェクトを指定します。
*# 値が範囲、コレクション、または「contains」メソッドを定義している他のエンティティに属しているかどうかを確認するための中置演算子として使用されます。
*# 同じ目的のためにwhen式で使用されます。
*# 型パラメータをcontravariantとしてマークします。
* <code>[[#!in|!in]]</code>
*# 値が範囲、コレクション、または 'contains' メソッドを定義する他のエンティティに'''属さない'''ことを確認する演算子として使用されます。
*# 同じ目的のためにwhen式で使用されます。
*: <code>!in</code>で１つのトークンなので、! と in の間に空白を挟むことはできません。 
* <code>[[#interface|interface]]</code> インターフェース( ''interfaces'' )を宣言します。
* <code>[[#is|is]]</code>
*# 値が特定の型を持つかどうかをチェックします。
*# 同じ目的のwhen式で使用されます。
* <code>[[#!is|!is]]</code>
*# 値が特定の型を持って'''いない'''かどうかをチェックします。
*# 同じ目的のwhen式で使用されます。
*: <code>!is</code>で１つのトークンなので、! と is の間に空白を挟むことはできません。 
* <code>[[#null|null]]</code> どのオブジェクトも指していないオブジェクト参照を表す定数です。
* <code>[[#object|object]]</code> クラスとそのインスタンスを同時に宣言します。
* <code>[[#package|package]]</code> 現在のファイルのパッケージを指定します。
* <code>[[#return|return]]</code> 最も近い包含関数または無名関数からの呼出し元に戻ります。
* <code>[[#super|super]]</code>
*# メソッドやプロパティのスーパークラス実装を参照します。
*# 二次コンストラクタ( ''secondary constructor'' )からスーパークラスのコンストラクタを呼び出します。
* <code>[[#this|this]]</code>
*# 現在のレシーバを指します。
*# 2 次コンストラクタから同じクラスの別のコンストラクタを呼び出します。
* <code>[[#throw|throw]]</code> 例外を投げます。
* <code>[[#true|true]]</code> Boolean型の「真」の値を表します。
* <code>[[#try|try]]</code> 例外処理ブロックを開始します。
* <code>[[#typealias|typealias]]</code> 型の別名を宣言します。
* <code>[[#typeof|typeof]]</code> 将来の使用のために予約されています。
* <code>[[#val|val]]</code> 読取り専用のプロパティまたはローカル変数を宣言します。
* <code>[[#var|var]]</code> 変更可能なプロパティまたはローカル変数を宣言します。
* <code>[[#when|when]]</code> when式を開始します（与えられた分岐のうち1つを実行します）。
* <code>[[#while|while]]</code> while ループ（条件式を前置するループ）を開始します。

=== ソフト・キーワード ===
{{先頭に戻る|style=border-top:1px solid gray;}}
以下のトークンは、それが適用される文脈( ''context'' )ではキーワードとして機能し、他の文脈では[[#識別子|識別子]]として使用することができます<ref>[https://kotlinlang.org/docs/keyword-reference.html#soft-keywords Soft keywords]</ref>。
このようなキーワードをソフト・キーワード( ''Soft keywords'' )と呼びます。

* <code>[[#by|by]]</code>
*# インターフェース( ''interface'' )の実装( ''implementation'' )を別のオブジェクトに委譲( ''delegates'' )します。
*# プロパティーのアクセッサー( ''accessors'' )の実装を別のオブジェクトに委譲します。
* <code>[[#catch|catch]]</code> 特定の例外タイプ( ''specific exception type'' )を処理( ''handles'' )するブロックを開始します。
* <code>[[#constructor|constructor]]</code> 一次または二次コンストラクタを宣言します。
* <code>[[#delegate|delegate]]</code> [[#アノテーション使用側ターゲット|アノテーション使用側ターゲット]]<sup>[仮訳]</sup>( ''annotation use-site target'' )として使用されます。
* <code>[[#dynamic|dynamic]]</code> Kotlin/JS コードで動的な型を参照します。
* <code>[[#field|field]]</code> [[#アノテーション使用側ターゲット|アノテーション使用側ターゲット]]<sup>[仮訳]</sup>として使用されます。
* <code>[[#file|file]]</code> [[#アノテーション使用側ターゲット|アノテーション使用側ターゲット]]<sup>[仮訳]</sup>として使用されます。
* <code>[[#finally|finally]]</code> tryブロックが終了したときに必ず実行されるブロックを開始します。
* <code>[[#get|get]]</code>
*# プロパティのゲッター( ''getter'' )を宣言します。
*# [[#アノテーション使用側ターゲット|アノテーション使用側ターゲット]]<sup>[仮訳]</sup>として使用されます。
* <code>[[#import|import]]</code> 他のパッケージから現在のファイルに宣言をインポートします。
* <code>[[#init|init]]</code> イニシャライザーブロックを開始します。
* <code>[[#param|param]]</code> [[#アノテーション使用側ターゲット|アノテーション使用側ターゲット]]<sup>[仮訳]</sup>として使用されます。
* <code>[[#property|property]]</code> [[#アノテーション使用側ターゲット|アノテーション使用側ターゲット]]<sup>[仮訳]</sup>として使用されます。
* <code>[[#receiver|receiver]]</code> [[#アノテーション使用側ターゲット|アノテーション使用側ターゲット]]<sup>[仮訳]</sup>として使用されます。
* <code>[[#set|set]]</code>
*# プロパティのセッター( ''setter'' )を宣言します。
*# [[#アノテーション使用側ターゲット|アノテーション使用側ターゲット]]<sup>[仮訳]</sup>として使用されます。
* <code>[[#setparam|setparam]]</code> [[#アノテーション使用側ターゲット|アノテーション使用側ターゲット]]<sup>[仮訳]</sup>として使用されます。
* <code>[[#value|value]]</code> キーワード <code>class</code> を付けてインラインクラス( ''inline class'' )を宣言します。
* <code>[[#where|where]]</code> 汎用型パラメーター( ''a generic type parameter'' )の制約( ''constraints'' )を指定します。

==== アノテーション使用側ターゲット ====
アノテーション使用側ターゲット( ''Annotation use-site target'' )は、Kotlinにおいてアノテーションが特定の要素に対して適用される位置を指定する構文です。これにより、生成されるJavaバイトコードにおいてアノテーションがどの要素に適用されるかを正確に指定できます<ref>[https://kotlinlang.org/docs/annotations.html#annotation-use-site-targets Annotation use-site targets]</ref>。

==== アノテーション使用側ターゲットの指定 ====
以下は、一般的なアノテーション使用側ターゲットの指定方法です。

# プロパティにアノテーションを指定する場合:
#:<syntaxhighlight lang=kotlin copy>
class Example {
    @get:MyAnnotation
    val myProperty: Int = 42
}
</syntaxhighlight>
#:この例では、<code>@get:MyAnnotation</code> と指定することで、プロパティのgetterメソッドに対してアノテーションを指定しています。
# 1次コンストラクタのパラメータにアノテーションを指定する場合:
#:<syntaxhighlight lang=kotlin copy>
class Example(@param:MyAnnotation val value: String)
</syntaxhighlight>
#:この例では、<code>@param:MyAnnotation</code> と指定することで、1次コンストラクタのパラメータに対してアノテーションを指定しています。

==== よく使われるアノテーション使用側ターゲット ====
# <code>@get</code>: プロパティのgetterメソッドに対してアノテーションを指定する。
# <code>@set</code>: プロパティのsetterメソッドに対してアノテーションを指定する。
# <code>@field</code>: プロパティ自体に対してアノテーションを指定する。

これらの使用側ターゲットを使うことで、アノテーションが生成される場所を明確に指定することができ、柔軟性を保ちつつ、正確な挙動を得ることができます。

=== モディファイア・キーワード ===
{{先頭に戻る|style=border-top:1px solid gray;}}
以下のトークンは、宣言の修飾語リスト( ''modifier lists of declarations'' )のキーワードとして機能し、他のコンテキストでは識別子として使用することができます<ref>[https://kotlinlang.org/docs/keyword-reference.html#modifier-keywords Modifier keywords]</ref>。
このようなキーワードをモディファイア・キーワード( ''Modifier keywords'' )と呼びます。

* <code>[[#abstract|abstract]]</code> クラスやメンバが抽象的( ''as abstract'' )であることを表します。
* <code>[[#actual|actual]]</code> マルチプラットフォーム・プロジェクト( ''multiplatform projects'' )におけるプラットフォーム固有の実装( ''platform-specific implementation'' )を意味します。
* <code>[[#annotation|annotation]]</code> アノテーションクラス( ''an annotation class'' )を宣言します。
* <code>[[#companion|companion]]</code> コンパニオンオブジェクト( ''a companion object'' )を宣言します。
* <code>[[#const|const]]</code> プロパティをコンパイル時の定数( ''a compile-time constant'' )としてマークします。
* <code>[[#crossinline|crossinline]]</code> インライン関数に渡されるラムダで、ローカルでない返り値を禁止します。
* <code>[[#data|data]]</code> クラスの正規メンバー( ''canonical members'' )を生成するようにコンパイラーに指示します。
* <code>[[#enum|enum]]</code> 列挙型( ''an enumeration'' )を宣言します。
* <code>[[#expect|expect]]</code> 宣言がプラットフォーム固有( ''as platform-specific'' )のものであり、プラットフォーム・モジュール(platform modules  )で実装されることを期待するものとしてマークします。
* <code>[[#external|external]]</code> Kotlin の外部で実装される宣言であることを示します（JNI または JavaScript でアクセス可能）。
* <code>[[#final|final]]</code> メンバーのオーバーライドを禁止します。
* <code>[[#infix|infix]]</code> 中置記法( ''infix notation'' )で関数を呼び出すことを許可します。
* <code>[[#inline|inline]]</code> 関数とその関数に渡されたラムダを呼出し先でインライン化することをコンパイラに指示します。
* <code>[[#inner|inner]]</code> ネストされたクラスから外側のクラスのインスタンスを参照できるようにします。
* <code>[[#internal|internal]]</code> 現在のモジュールで可視( ''as visible'' )となる宣言をマークします。
* <code>[[#lateinit|lateinit]]</code> コンストラクターの外部で非 null プロパティを初期化します。
* <code>[[#noinline|noinline]]</code> インライン関数に渡されたラムダをインライン化しないようにします。
* <code>[[#open|open]]</code> クラスのサブクラス化またはメンバーのオーバーライドを許可します。
* <code>[[#operator|operator]]</code> 関数が演算子をオーバーロードしているか、または規約を実装( ''implementing a convention'' )しているかをマークします。
* <code>[[#out|out]]</code> 型パラメータを共変( ''covariant'' )としてマークします。
* <code>[[#override|override]]</code> スーパークラスのメンバーのオーバーライドとしてメンバーにマークを付けます。
* <code>[[#private|private]]</code> 現在のクラスまたはファイル内で宣言が可視化( as visible )されるようにマークします。
* <code>[[#protected|protected]]</code> 現在のクラスとそのサブクラスで宣言が可視化されるようにマークします。
* <code>[[#public|public]]</code> 宣言がどこでも可視化されるようにマークします。
* <code>[[#reified|reified]]</code> インライン関数の型パラメーター( ''type parameter'' )を、実行時にアクセス可能なものとしてマークします。
* <code>[[#sealed|sealed]]</code> シールされたクラス（ ''sealed class'' ; サブクラス化が制限されたクラス）を宣言します。
* <code>[[#suspend|suspend]]</code> 関数やラムダをサスペンド（コルーチンとして使用可能）するようにマークします。
* <code>[[#tailrec|tailrec]]</code> 関数を末尾再帰としてマークします (コンパイラーが再帰を反復に置換えることができます)。
* <code>[[#vararg|vararg]]</code> パラメーターに可変数の引数を渡せるようにします。

=== 特殊識別子 ===
{{先頭に戻る|style=border-top:1px solid gray;}}
以下の識別子は，コンパイラーが特定の文脈で定義したもので、他の文脈では通常の識別子として使用することができます<ref>[https://kotlinlang.org/docs/keyword-reference.html#special-identifiers Special identifiers]</ref>。
このような識別子を特殊識別子( ''Special identifiers'' )と呼びます。

* <code>[[#field|field]]</code> プロパティーアクセサー( ''a property accessor'' )の内部で、プロパティーのバッキングフィールドを参照するために使用します。
* <code>[[#it|it]]</code> ラムダの内部で暗黙のうちにパラメーターを参照するために使用されます。

=== 演算子と特殊シンボル ===
{{先頭に戻る|style=border-top:1px solid gray;}}
Kotlinは以下の演算子( ''Operators'' )や特殊特殊シンボル( ''special symbols'' )をサポートしています<ref>[https://kotlinlang.org/docs/keyword-reference.html#operators-and-special-symbols Operators and special symbols]</ref>。

* <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>%</code> {{---}} 算術演算子
*# <code>*</code> は、vararg パラメーターに配列を渡す場合にも使用されます。
* <code>=</code>
*# 代入演算子
*# パラメーターのデフォルト値を指定するために使用されます。
* <code>+=</code>, <code>-=</code>, <code>*=</code>, <code>/=</code>, <code>%=</code> {{---}} 拡張された代入演算子。
* <code>++</code>, <code>--</code> {{---}} インクリメントおよびデクリメント演算子
* <code>&&</code>, <code>||</code>, <code>!</code> {{---}}  論理 'and', 'or', 'not' 演算子 (ビット演算には、対応する infix 関数を使用してください)。
* <code>==</code>, <code>!=</code> {{---}} 等号演算子 (非プリミティブ型では equals() に変換される)。
* <code>===</code>, <code>!==</code> {{---}} 参照系等号演算子( ''referential equality operators'' )
* <code><</code>, <code>></code>, <code><=</code>, <code>>=</code> {{---}} 比較演算子 (非プリミティブ型に対する compareTo() の呼出しに変換されます)
* <code>[</code>, <code>]</code> {{---}} インデックス付きアクセス演算子（getとsetの呼び出しに変換されます）
* <code>!!</code> 式が非nullであることを保証します。
* <code>?.</code> 安全な呼び出しを行います（レシーバーが非NULLの場合、メソッドを呼び出したり、プロパティにアクセスしたりします）。
* <code>?:</code> 左辺の値がNULLの場合、右辺の値を取ります（エルビス演算子）。
* <code>::</code> メンバー参照またはクラス参照を作成します。
* <code>..</code> 範囲( ''a range'' )を生成します。
* <code>:</code> 宣言の中で、名前と型を分離します。
* <code>?</code> 型をnull可能( ''as nullable'' )であるとマークします。
* <code>-></code>
*# ラムダ式のパラメーターと本体を分離します。
*# 関数型のパラメーターと戻値の型宣言を分離します。
*# when式の条件分岐と本体を分離します。
* <code>@</code>
*# アノテーションを導入します。
*# ループラベルを導入または参照します。
*# ラムダ・ラベルを導入または参照します。
*# 外部スコープから 'this' 式を参照します。
*# 外部のスーパークラスを参照します。
* <code>;</code> 同じ行にある複数のステートメントを区切ります。
* <code>$</code> 文字列テンプレート内で変数または式を参照します。
* <code>_</code>
*# ラムダ式で使用しないパラメーターを置換えます。
*# 構造化宣言の未使用のパラメーターを代入します。
{{See also|[[#演算子の優先順位|演算子の優先順位]]}}

== Kotlin標準ライブラリー ==
{{先頭に戻る}}
Kotlin標準ライブラリー( ''Kotlin Standard Library'' )は、以下のような機能を提供します<ref>[https://kotlinlang.org/api/latest/jvm/stdlib/ Kotlin Standard Library]</ref>。

* 慣用的なパターン（let、apply、use、synchronizedなど）を実装した高階関数。
* コレクション（eager）やシーケンス（lazy）に対するクエリ操作を提供する拡張関数。
* 文字列や文字列列を扱うための各種ユーティリティ
* ファイル、IO、スレッドを便利に扱うための JDK クラスの拡張。

Kotlin標準ライブラリーはKotlin自身で書かれています。

;[[ディフォルトインポート]]されるパッケージ
* kotlin.*
* [[#アノテーション|アノテーション]]
* [[#コレクション|コレクション]]
* [[#比較|比較]]
* [[#入出力|入出力]]
* [[#範囲|範囲]]
* [[#シーケンス|シーケンス]]
* [[#テキスト|テキスト]]

=== アノテーション ===
{{先頭に戻る|title=Kotlin標準ライブラリーに戻る|label=Kotlin標準ライブラリー}}
kotlin.annotation.*

=== コレクション ===
{{先頭に戻る|title=Kotlin標準ライブラリーに戻る|label=Kotlin標準ライブラリー}}
Kotlinには、Arrayから始まり、Iterable, Collection, List, Set, Mapなどのコレクション型が豊富に用意されています。これらは主に <code>kotlin.collections</code> パッケージで提供されており、[[#ディフォルトインポート|ディフォルトインポート]]なので追加のインポートなしで利用できます<ref>[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/ Package kotlin.collections]</ref>。

:{| class=wikitable
|+ 主要なパッケージとその機能の一覧
!パッケージ!!機能
|-
!Iterable
|要素の反復処理をサポート
|-
!Collection
|要素のコレクションを表現
|-
!List
|要素数が固定で、要素の値を変更不可
|-
!ArrayList
|可変長の動的な配列
|-
!MutableList
|要素の変更が可能なリスト
|-
!Set
|要素の重複を許さない
|-
!Map
|キーと値のペアを保持する
|-
!MutableMap
|要素の変更が可能なMap
|-
!LinkedHashSet
|要素の挿入順を保持するSet
|-
!LinkedHashMap
|要素の挿入順を保持するMap
|}

==== Iterable ====
<code>Iterable</code> インターフェースは、Kotlinの標準ライブラリで使用される反復可能なコレクションの基本的なインターフェースです。このインターフェースは、コレクションが要素の反復処理を可能にするために必要な機能を提供します。

以下に、<code>Iterable</code> インターフェースの主な要素と使用法を示します：

# <code>iterator()</code> メソッド:
#* <code>iterator</code> メソッドは、コレクション内の要素を反復処理するためのイテレータを返します。
#* イテレータは、<code>hasNext()</code> メソッドで次の要素の有無を確認し、<code>next()</code> メソッドで次の要素を取得します。
#* 通常、<code>for</code> ループや <code>forEach</code> 関数を使用して、このメソッドを呼び出すことなくコレクションを反復処理できます。   
#:<syntaxhighlight lang=kotlin copy>
val iterable: Iterable<Int> = listOf(1, 2, 3, 4, 5)

// for ループを使用した反復処理
for (element in iterable) {
    println(element)
}

// forEach 関数を使用した反復処理
iterable.forEach { element ->
    println(element)
}
</syntaxhighlight>
# <code>forEach</code> 拡張関数:
#* <code>Iterable</code> インターフェースには、<code>forEach</code> という拡張関数があります。これはラムダ式を使用して各要素に対する処理を行います。   
#:<syntaxhighlight lang=kotlin copy>
val iterable: Iterable<Int> = listOf(1, 2, 3, 4, 5)

// forEach 関数を使用した反復処理
iterable.forEach { element ->
    println(element)
}
</syntaxhighlight>
#使用例:
#* <code>Iterable</code> は多くの Kotlin のコレクションで使用されます。例えば、<code>List</code>、<code>Set</code>、<code>Map</code> などが <code>Iterable</code> インターフェースを実装しています。
#* <code>Iterable</code> を実装することで、コレクションが要素の反復処理をサポートし、<code>for</code> ループや <code>forEach</code> 関数などで簡単に使用できます。   
#:<syntaxhighlight lang=kotlin copy>
// List は Iterable インターフェースを実装している
val list: Iterable<Int> = listOf(1, 2, 3, 4, 5)

// for ループを使用した反復処理
for (element in list) {
    println(element)
}
</syntaxhighlight>

<code>Iterable</code> インターフェースは、Kotlinでコレクションを扱う際に非常に重要であり、様々な反復処理操作を可能にします。

==== Collection ====
<code>Collection</code> インターフェースは、Kotlinの標準ライブラリで提供されるコレクション型の基本インターフェースの一つです。このインターフェースは、複数の要素を保持するデータ構造を表現し、それらの要素に対する基本的な操作を提供します。

以下に、<code>Collection</code> インターフェースの主な特徴と使用法を示します：

# 要素の追加と削除:
#* <code>Collection</code> インターフェースは、要素の追加や削除といった基本的な操作を提供します。
#* <code>add(element: E)</code> メソッドを使用して要素を追加し、<code>remove(element: E)</code> メソッドを使用して指定した要素を削除します。   
#:<syntaxhighlight lang=kotlin copy>
val collection: Collection<Int> = listOf(1, 2, 3, 4, 5)

// 要素の追加はサポートされない
// collection.add(6)  // エラー

// 要素の削除
val modifiedCollection = collection - 3
println(modifiedCollection)  // [1, 2, 4, 5]
</syntaxhighlight>
# 要素の存在確認:
#* <code>contains(element: E)</code> メソッドを使用して、指定した要素がコレクション内に存在するかどうかを確認できます。   
#:<syntaxhighlight lang=kotlin copy>
val collection: Collection<Int> = listOf(1, 2, 3, 4, 5)

// 要素の存在確認
val containsThree = collection.contains(3)
println(containsThree)  // true
</syntaxhighlight>
# サイズの取得:
#* <code>size</code> プロパティを使用して、コレクション内の要素の総数を取得できます。   
#:<syntaxhighlight lang=kotlin copy>
val collection: Collection<Int> = listOf(1, 2, 3, 4, 5)

// コレクションのサイズ取得
val size = collection.size
println(size)  // 5
</syntaxhighlight>
# 反復処理:
#* <code>Iterable</code> インターフェースを継承しているため、<code>forEach</code> 関数などを使用してコレクション内の要素を反復処理できます。   
#:<syntaxhighlight lang=kotlin copy>
val collection: Collection<Int> = listOf(1, 2, 3, 4, 5)

// forEach 関数を使用した反復処理
collection.forEach { element ->
    println(element)
}
</syntaxhighlight>
# 他のコレクションとの操作:
#* <code>Collection</code> インターフェースを実装するコレクションは、他のコレクションとの操作を行うための便利な関数を提供します。例えば、和集合、差集合、共通要素などを計算できます。   
#:<syntaxhighlight lang=kotlin copy>
val collection1: Collection<Int> = listOf(1, 2, 3, 4, 5)
val collection2: Collection<Int> = listOf(4, 5, 6, 7, 8)

// 和集合
val unionResult = collection1 union collection2
println(unionResult)  // [1, 2, 3, 4, 5, 6, 7, 8]

// 差集合
val subtractResult = collection1 subtract collection2
println(subtractResult)  // [1, 2, 3]

// 共通要素
val intersectResult = collection1 intersect collection2
println(intersectResult)  // [4, 5]
</syntaxhighlight>

<code>Collection</code> インターフェースは、Kotlinのコレクションの基本的な機能を提供し、様々な種類のコレクションがこれを実装しています。これにより、異なる種類のコレクションを一貫して扱うことができます。

==== List ====
Listは、要素数が固定で要素の値を変更できないコレクションです。

===== List() =====
;[https://paiza.io/projects/vmrFKnU_3qj5d04hJPmuWA?language=kotlin List()を使ったListの生成]:<syntaxhighlight lang=Kotlin highlight=2 line>
fun main() {
    val list = List(5){it}
    println("list::class.simpleName ⇒ ${list::class.simpleName}")
    println("list[0]::class.simpleName ⇒ ${list[0]::class.simpleName}")
    list.forEach{print("$it ")}
    println("")

    val list2 = List(5){(it*it).toString()}
    println("list2[0]::class.simpleName ⇒ ${list2[0]::class.simpleName}")
    list2.forEach{print("$it ")}
    println("")
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
list::class.simpleName ⇒ ArrayList
list[0]::class.simpleName ⇒ Int
0 1 2 3 4 
list2[0]::class.simpleName ⇒ String 
0 1 4 9 16 
</syntaxhighlight>
: List()はListのコンストラクターで、引数として要素数をとり、ブロックが初期化式になります。

===== listOf =====
;[https://paiza.io/projects/D17B4n-k7dGdKdxlrw5m2Q?language=kotlin listOf()を使ったListの生成]
:<syntaxhighlight lang=Kotlin highlight=2 line>
fun main() {
    val list = listOf(1, 9, 3, 5, 23, 1)
    
    println("${list::class.simpleName}")
    println("${list[0]::class.simpleName}")

    for (s in list)
        if (s > 10)
            break
        else
            print("$s ")
    println("")
    
    run {
        list.forEach{
            if (it > 10)
                return@run
            else
                print("$it ")
        }
    }
    println("")
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
ArrayList
Int
1 9 3 5  
1 9 3 5 
</syntaxhighlight>
: ListOf()は可変長引数の関数で、引数が生成されるListの要素になります。
: Listの要素の型は、型強制できる最小公倍数的な方になります（例えば Int と Long が混在していたら Long）。

==== ArrayList ====
:<syntaxhighlight lang=Kotlin line>
fun main() {
    // ArrayListを使ったListの生成
    val arrayList = ArrayList<String>()
    arrayList.add("Kotlin")
    arrayList.add("Java")
    arrayList.add("Python")
    
    println("${arrayList::class.simpleName}")
    
    for (lang in arrayList) {
        println(lang)
    }
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
ArrayList
Kotlin
Java
Python
</syntaxhighlight>
上記の例では、<code>ArrayList</code> を使ってListを生成しています。ArrayListは要素の順序が保持され、可変長の動的な配列を表現します。<code>add</code> メソッドを使用して要素を追加することができます。

==== MutableList ====
<syntaxhighlight lang=kotlin copy>
fun main() {
    // MutableListを使ったListの生成
    val mutableList = mutableListOf(1, 2, 3, 4, 5)
    mutableList.add(6)
    
    println("${mutableList::class.simpleName}")

    for (num in mutableList) {
        print("$num ")
    }
    println("")
}
</syntaxhighlight>
;実行結果
:<syntaxhighlight lang=text>
ArrayList
1 2 3 4 5 6 
</syntaxhighlight>
<code>mutableListOf()</code> を使って <code>MutableList</code> を生成し、<code>add</code> メソッドを使用して要素を追加しています。MutableListは要素の変更が可能なListです。

これらの例から分かるように、Kotlinのコレクションは型安全で、読み取り専用と可変なコレクションの違いが明確になっています。リストの他にも、SetやMapも用意されており、それぞれの特徴に応じて適切なものを選択できます。

==== ユースケース ====
<code>kotlin.collections</code> パッケージのコレクションクラスや関連機能は、さまざまなプログラミングシナリオで利用されます。以下は、<code>kotlin.collections</code> の主なユースケースのいくつかです：

# データの格納と操作: List、Set、Mapなどのコレクションは、データを効果的に格納し、操作するために使用されます。例えば、リストは順序つきのデータの集合を表現し、セットは一意な要素の集合を表現します。
# 反復処理とフィルタリング: Iterable インターフェースを使用してコレクションを反復処理し、必要なデータを抽出することができます。これは、フィルタリングや変換などの操作に役立ちます。
# 不変性と可変性の管理: List と MutableList、Set と MutableSet、Map と MutableMap など、各コレクションには不変なバージョンと可変なバージョンがあります。これにより、不変性を保ちながら必要に応じてデータを変更できます。
# 関数型プログラミング: コレクション操作には関数型プログラミングのアプローチがあり、<code>filter</code>、<code>map</code>、<code>reduce</code> などの関数を使用してデータを処理できます。

以下は、これらのユースケースの簡単な例です：
<syntaxhighlight lang=kotlin copy>
// データの格納と操作
val list = listOf(1, 2, 3, 4, 5)
val set = setOf(1, 2, 3, 4, 5)
val map = mapOf(1 to "one", 2 to "two", 3 to "three")

// 反復処理とフィルタリング
val filteredList = list.filter { it > 2 }

// 不変性と可変性の管理
val mutableList = mutableListOf(1, 2, 3)
mutableList.add(4)

// 関数型プログラミング
val squaredValues = list.map { it * it }
val sum = list.reduce { acc, value -> acc + value }
</syntaxhighlight>

これらの例は一部の機能を示すものであり、<code>kotlin.collections</code> のコレクションは、さまざまなプログラミングニーズに対応する強力なツールセットを提供します。

==== ベストプラクティス ====
<code>kotlin.collections</code> を使用する際のベストプラクティスはいくつかあります。以下にいくつか挙げてみましょう：

# 不変性の推奨: 不変なコレクション（<code>List</code>、<code>Set</code>、<code>Map</code>など）を使用することを検討してください。不変なコレクションは変更不可能でスレッドセーフであり、プログラムの安全性を向上させるのに役立ちます。  
#:<syntaxhighlight lang=kotlin copy>
// 不変なリスト
val immutableList = listOf(1, 2, 3)

// 不変なセット
val immutableSet = setOf("apple", "orange", "banana")

// 不変なマップ
val immutableMap = mapOf(1 to "one", 2 to "two", 3 to "three")
</syntaxhighlight>
# Nullableなコレクションの適切な扱い: コレクション内の要素が <code>null</code> になりうる場合、Nullableなコレクション（<code>List?</code>、<code>Set?</code>、<code>Map?</code>など）を使用して適切にハンドリングしましょう。  
#:<syntaxhighlight lang=kotlin copy>
// Nullableなリスト
val nullableList: List<Int>? = // ...

// Nullableなセット
val nullableSet: Set<String>? = // ...

// Nullableなマップ
val nullableMap: Map<Int, String>? = // ...
</syntaxhighlight>
# 関数型プログラミングの活用: <code>filter</code>、<code>map</code>、<code>reduce</code>、<code>fold</code> などの関数型プログラミングの機能を活用して、コードを簡潔で読みやすくしましょう。  
#:<syntaxhighlight lang=kotlin copy>
val numbers = listOf(1, 2, 3, 4, 5)

val evenSquared = numbers
    .filter { it % 2 == 0 }
    .map { it * it }
    .sum()
</syntaxhighlight>
# 適切なコレクションの選択: 使用ケースによって適切なコレクションを選択しましょう。例えば、要素の順序が重要な場合は <code>List</code>、一意性が必要な場合は <code>Set</code>、キーと値のペアが必要な場合は <code>Map</code> を使用します。  
#:<syntaxhighlight lang=kotlin copy>
// 要素の順序が重要
val orderedList = listOf(1, 2, 3, 4, 5)

// 一意性が必要
val uniqueSet = setOf("apple", "orange", "banana")

// キーと値のペアが必要
val keyValueMap = mapOf(1 to "one", 2 to "two", 3 to "three")
</syntaxhighlight>

これらのベストプラクティスは、コードの品質、パフォーマンス、保守性を向上させるのに役立ちます。使用ケースによって最適なアプローチを選択することが重要です。

=== 比較 ===
{{先頭に戻る|title=Kotlin標準ライブラリーに戻る|label=Kotlin標準ライブラリー}}
kotlin.comparisons.*

=== 入出力 ===
{{先頭に戻る|title=Kotlin標準ライブラリーに戻る|label=Kotlin標準ライブラリー}}
kotlin.io.*

=== 範囲 ===
{{先頭に戻る|title=Kotlin標準ライブラリーに戻る|label=Kotlin標準ライブラリー}}
kotlin.ranges.*

=== シーケンス ===
{{先頭に戻る|title=Kotlin標準ライブラリーに戻る|label=Kotlin標準ライブラリー}}
kotlin.sequences.*

=== テキスト ===
{{先頭に戻る|title=Kotlin標準ライブラリーに戻る|label=Kotlin標準ライブラリー}}
kotlin.text.*


----

=== コレクション類似クラス ===
{{先頭に戻る}}
[TODO:Rangeはコレクションではないので再分類が必要]

<code>println((1..5).javaClass.kotlin)</code>の結果が示す通り、範囲リテラル<code>1..5</code>は<code>class kotlin.ranges.IntRange</code>です。
コレクションは、Ranges以外にも、Sequences・Ranges・Lists・Arrays・Sets・Mapsなどがあります。これは網羅していませんし、上記の forプロトコルに従ったクラスを作れば、ユーザー定義のコレクションも作成できます。

;[https://paiza.io/projects/zw6faeOmsjuZVF3D3WY_-g?language=kotlin 様々なコレクション]:<syntaxhighlight lang="Kotlin">
fun main(args: Array<String>) {
  val collections = arrayOf(
    1..5,
    1..8 step 2, 
    5 downTo 1,
    8 downTo 1 step 2,
    'A'..'Z', 
    listOf(2,3,5),
    setOf(7,11,13))
  println("$collections(${collections.javaClass.kotlin})")

  for (collection in collections) {
      print(collection)
      print(": ")
      for (x in collection) {
          print(x)
          print(" ")
      }
      print(": ")
      println(collection.javaClass.kotlin)
  }
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
class kotlin.Array
1..5: 1 2 3 4 5 : class kotlin.ranges.IntRange
1..7 step 2: 1 3 5 7 : class kotlin.ranges.IntProgression
5 downTo 1 step 1: 5 4 3 2 1 : class kotlin.ranges.IntProgression
8 downTo 2 step 2: 8 6 4 2 : class kotlin.ranges.IntProgression
A..Z: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z : class kotlin.ranges.CharRange
[2, 3, 5]: 2 3 5 : class java.util.Arrays$ArrayList 
[7, 11, 13]: 7 11 13 : class java.util.LinkedHashSet
</syntaxhighlight>
: 二重のforループで、外周はコレクションのコレクションで、内周は個々のコレクションの要素をイテレーションしています。

=== スコープ関数 ===
{{先頭に戻る|style=border-top:1px solid gray;}}
==== repeat関数 ====
Kotlinの標準ライブラリーにあるrepeat関数は、定数回の繰返しが必要な時に便利です<ref>[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/repeat.html repeat - Kotlin Programming Language]</ref>。

;[https://paiza.io/projects/LHnnORcAjUhvb_qW9ysIvw?language=kotlin repeat関数]:<syntaxhighlight lang="kotlin">
fun main() {
    repeat(5) {
        println("it = $it")
    }

    run {
        repeat(3) { i ->
            repeat(4) { j ->
                println("(i, j) = ($i, $j)")
                if (i == 1 && j == 2) {
                    return@run
                }
            }
        }
    }
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
it = 0
it = 1
it = 2
it = 3
it = 4
(i, j) = (0, 0)
(i, j) = (0, 1)
(i, j) = (0, 2)
(i, j) = (0, 3)
(i, j) = (1, 0)
(i, j) = (1, 1) 
(i, j) = (1, 2)
</syntaxhighlight>
:<var>it</var>は、暗黙のループ変数です。
:多重ループでは、ループ変数の名前が固定では都合が悪いので、ブロックの先頭で<code>識別子名 -></code> とすることで明示的に名前をつけることができます。
:多重ループを run 関数で括ることで多重ループからの大域脱出を実現しています。

==== ブロックを受取る関数 ====
repeat関数もそうですが、Kotlinにはブロックを受取る関数（やメソッド）があります。

;[https://paiza.io/projects/AZT2juUGcUnyjqgDx4G85g?language=kotlin ブロックを受取る関数]:<syntaxhighlight lang="kotlin">
fun main(args: Array<String>) {
    val ary = Array(5) { 2 * it + 1 }
    ary.forEach{ println(it) }
    println(ary.map{ it.toString() }.joinToString(" "))
    println(ary.reduce{ sum, el -> sum  + el })
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
1
3
5
7
9
1 3 5 7 9 
25
</syntaxhighlight>
:ブロックで配列の初期化を行う場合、<var>it</var>は順位になります。
:コレクションのforEachメソッドもブロックを取ります。
:コレクションのreduceメソッドもブロックを取りますが、累算値と要素の2つを取るので、名付けが必要です。

このように、ブロックを取るメソッドを使うとコレクションに関する操作を簡素に書けます。

== Coroutine ==
{{先頭に戻る}}
Kotlinは、言語レベルでコルーチンをサポートし、機能の大部分をライブラリに委ねることで、この問題を柔軟に解決しています。

;Shell:<syntaxhighlight lang=console>
$ cat coroutine.kt 
import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(500L)
        for (ch in "World!\n") {
            print(ch)
            delay(100L)
        }
    }
    print("Hello ")
}
$ locate /kotlinx-coroutines
/usr/local/share/kotlin/lib/kotlinx-coroutines-core-jvm.jar
$ kotlinc -cp /usr/local/share/kotlin/lib/kotlinx-coroutines-core-jvm.jar coroutine.kt -include-runtime -d coroutine.jar
$ java -cp ./coroutine.jar:/usr/local/share/kotlin/lib/kotlinx-coroutines-core-jvm.jar CoroutineKt
Hello World!
</syntaxhighlight>

== Kotlin Script ==
{{先頭に戻る}}
Kotlin Script では、.jar を生成せず、そのままコードが実行されます。
また、main 関数をエントリーポイントはぜず、スクリプトの書かれた順に評価します。
;Shell:<syntaxhighlight lang=console>
% cat hello.kts
println("Hello, World!")
% kotlinc -script hello.kts
Hello, World!
% _
</syntaxhighlight>

ビルドツールの Gradle では、従来は Groovy がビルド構成ファイルに使われていましたが、Kotlin Script への移行が進んでいます。

;ワンライナー:<syntaxhighlight lang=console>
% kotlin -e 'repeat(3){println("Hello!($it)")}'
Hello!(0)
Hello!(1)
Hello!(2)
% _
</syntaxhighlight>

== 改廃された技術 ==  
Kotlinの改廃された技術や利用が推奨されない技術は、言語やエコシステムの進化、新しい要求、セキュリティ上の懸念などにより置き換えられます。以下に、代表的な技術を示します。  

=== Kotlin Android Extensions ===  
* '''サポート開始年:''' 2015年  
* '''サポート終了年:''' 2021年（Kotlin 1.6.20で非推奨化）  
; 廃止または衰退の理由 : View BindingやJetpack Composeなど、より安全で効率的なUI開発ツールが普及したため、利用が非推奨化されました。  
; 代替技術 : View BindingやJetpack Composeを使用することが推奨されます。  

=== Synthetic Properties for Views ===  
* '''サポート開始年:''' 2015年  
* '''サポート終了年:''' 2021年（非推奨化）  
; 廃止または衰退の理由 : Null安全性やビルドプロセスの問題から、公式に非推奨となりました。  
; 代替技術 : View Bindingを使用することで、同様の機能を安全に実現できます。  

=== Kotlin Scripting旧形式 (kotlin.script.experimental) ===  
* '''対象:''' kotlin.script.experimental APIの旧バージョン  
; 利用推奨されない理由 : 新しいAPI（kotlin.script.experimental.jvmなど）がより柔軟で強力であるため、旧形式は非推奨となりました。  
; 代替技術 : 最新のKotlin Scripting APIを使用してください。  

=== Kotlin Coroutinesの旧形式 ===  
* '''対象:''' kotlinx.coroutinesの旧バージョン（0.x系）  
; 利用推奨されない理由 : 古いバージョンではAPIが安定しておらず、最新の1.x系バージョンでは大幅な改善と安定化が図られています。  
; 推奨バージョン : 最新の1.x系またはそれ以降を使用してください。  

=== Experimental API ===  
* '''対象:''' <code>@Experimental</code>や<code>@UseExperimental</code>アノテーションでラベル付けされたAPI  
; 利用推奨されない理由 : 将来のリリースで仕様変更や削除が行われる可能性があるため、慎重に利用する必要があります。  
; 代替技術 : 安定版APIがリリースされた場合、それに切り替えることが推奨されます。  

=== Kotlin/NativeのC Interop旧形式 ===  
* '''対象:''' Kotlin/NativeにおけるC Interopの旧形式  
; 利用推奨されない理由 : 最新のKotlin/NativeバージョンでInteropが改善され、旧形式は非推奨となりました。  
; 代替技術 : 最新のC Interop形式や公式ドキュメントに基づいた方法を使用してください。  

=== Kotlin Multiplatform Pluginの旧形式 ===  
* '''対象:''' Kotlin Multiplatform Pluginの旧バージョン  
; 利用推奨されない理由 : 最新バージョンではモジュール分割や依存関係管理の改善が行われ、旧バージョンの利用は推奨されなくなりました。  
; 代替技術 : 最新のKotlin Multiplatform Pluginを利用してください。  

=== Java 6および7向けのサポート ===  
* '''サポート開始年:''' 2011年（初期Kotlin）  
* '''サポート終了年:''' 2020年（Kotlin 1.6以降で非推奨化）  
; 廃止または衰退の理由 : 古いJavaバージョンの市場シェアが低下したため、KotlinチームはJava 8以降に焦点を当てています。  
; 代替技術 : Java 8以降を対象にKotlinを使用することが推奨されます。  

== 脚註 ==
<references />

== 外部リンク ==
{{Wikipedia}}
* [https://kotlinlang.org/ Kotlin Programming Language] - 公式サイト
** [https://kotlinlang.org/spec/introduction.html Kotlin language specification]
** [https://play.kotlinlang.org/ Kotlin Playground: Edit, Run, Share Kotlin Code Online]

[[Category:Kotlin|*]]
[[Category:プログラミング言語]]
{{NDC|007.64}}