----
__TOC__ 
Kotlinは、JetBrains社によって開発された静的型付けされたオブジェクト指向のプログラミング言語で、Java仮想マシン(JVM)上で動作します。LLVMフレームワークを介して多くのプラットフォームで実行可能なコードにもコンパイルできます。
また、Kotlin/Wasmは、Kotlinの新しいコンパイルターゲットであり、WebAssemblyをサポートする環境やデバイス上で実行可能なアプリケーションを作成することができます。これにより、Kotlinの強力な機能と柔軟性を活用して、Webアプリケーションやクライアントサイドのプログラミングにも取り組むことができます。
KotlinはJavaよりも簡潔で型安全性が高く、Scalaよりもシンプルな言語を目指して開発されました。Scalaと比較して、簡略化された結果、コンパイルが高速化され、IDEでの言語サポートも充実しています。また、KotlinはJavaと完全な互換性があり、Java開発者は徐々に導入することができます。特に、KotlinはAndroidにも組み込まれており、既存のAndroidアプリケーションは、アプリケーション全体を書き換えることなくKotlinで新機能を実装することができます。Kotlin FoundationがKotlin™商標を守っています。
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やプログラミングに関するコミュニティやフォーラムに参加すると、他の学習者や経験者からのアドバイスやサポートを得ることができます。質問をしてコミュニケーションをとることも大切です。
継続的な学習と興味を持つ:
プログラミングは絶え間ない学習が求められる分野です。新しい技術やツールに興味を持ち、継続的に学び続けることでスキルを向上させることができます。
プログラミングはスキルの向上に時間がかかるものですが、継続的な努力と実践を通じて着実に成長していきます。最初は小さなステップから始め、徐々に進んでいくことが大切です。
他の多くのチュートリアルがそうであるように、 私たちもまずはKotlinの世界にあいさつすることから始めましょう。hello.ktというファイルを作り、次のように書いて保存して下さい(Kotlinのソースファイルの拡張子は .kt です)。
[https://pl.kotl.in/JCCTJjX4_ hello.kt]:
fun main() = println("Hello, World!")
それでは、ソースプログラムをコンパイルして実行してみましょう。
% kotlinc hello.kt -include-runtime -d hello.jar
% java -jar hello.jar
Hello, World!
% _
funは関数（function）を宣言するためのキーワードです。
mainはプログラムのエントリーポイントとなる特別な関数の名前です。通常、プログラムの実行が始まるところです。
このイコール記号は、関数の本体が始まることを示します。Kotlinでは、単一の式の関数を記述する際に、本体とイコールを省略して1行で記述できます。
printlnはコンソールに文字列を表示するための関数です。("Hello, World!")は引数として渡される文字列です。
この行全体は、関数の呼び出しとして、文字列 "Hello, World!" をコンソールに表示するものです。
これにより、この一行のコードは「mainという関数を宣言し、その中で 'Hello, World!' という文字列をコンソールに表示する」という単純なプログラムを実現しています。Kotlinはこのようにシンプルかつ読みやすい構文を持っており、初学者にも優れた学習言語となっています。
Kotlinのクイックツアーでは、基本的な構文や機能に焦点を当て、簡単なコード例を通じて言語の特徴を理解していきます。
fun main() {
    // 変数の宣言
    val message: String = "Hello, Kotlin!"
    // 自動型推論も可能
    val number = 42
    // 文字列テンプレート
    println("$message The answer is $number")
}
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")
    }
}
fun main() {
    // 関数の呼び出し
    greet("Alice")
    // 関数の定義
    fun greet(name: String) {
        println("Hello, $name!")
    }
}
fun main() {
    // クラスの定義
    class Person(val name: String, val age: Int)
    // オブジェクトの作成
    val person = Person("John", 25)
    // プロパティへのアクセス
    println("${person.name} is ${person.age} years old.")
}
fun main() {
    // Null許容型
    var name: String? = "Bob"
    // 安全呼び出し演算子
    val length: Int? = name?.length
    // Elvis演算子
    val result = name ?: "Guest"
    println("Name length: $length")
    println("Result: $result")
}
fun main() {
    // 拡張関数の定義
    fun String.addExclamation(): String {
        return "$this!"
    }
    // 拡張関数の呼び出し
    val greeting = "Hello".addExclamation()
    println(greeting)
}
import kotlinx.coroutines.*
fun main() {
    // コルーチンの起動
    GlobalScope.launch {
        delay(1000) // 1秒待つ
        println("World!")
    }
    println("Hello, ")
    // プログラムを待機して終了しないようにする
    Thread.sleep(2000) // 2秒待つ
}
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)
}
この例では、Kotlin DSLを使用して、特定のドメイン（ここではPersonオブジェクトの構築）に特化した言語拡張を行っています。
これらの例はKotlinの基本を紹介するものであり、より高度な概念や機能も学ぶことができます。
コンパイル型言語 : Kotlinはコンパイラーとして実装されています。REPLやスクリプティングエンジンもあります。
Kotlin/JVM: １つまたは複数のソースコードをコンパイルしてJavaバイトコードを生成し、生成したJavaバイトコードを実行します。
Kotlin/JS: １つまたは複数のソースコードをコンパイルしてJavaScriptを生成し、生成したJavaScriptを実行します。
Kotlin/Native: １つまたは複数のソースコードをコンパイルしてLLVMインフラストラクチャーをバックエンドに実行形式を生成し、生成した実行形式を実行します。
Kotlin/Wasm: １つまたは複数のソースコードをコンパイルしてWebAssembly（Wasm）バイナリを生成し、WebAssembly仮想マシン上で実行します。
静的型付け : 値・変数・関数のパラメーター・関数の戻値などの型はコンパイル時に検証され、型安全性が担保されます。
例外 : try-catch-finally 形の例外処理をサポートします。
演算子オーバーロード: サポートします。a + b は、メソッド形式 a.plus(b) と同義です。
関数オーバーロード : 同じ名前で引数の数が異なる関数を定義することが可能です。
ラムダ式: サポートします。{ a: Int, b: Int -> a + b }
無名関数: サポートします。fun(a: Int, b: int) = a + b
拡張関数: 既存のクラスに新しいメソッドを生やすことができます。これは Java のクラスライブラリーのクラスも例外ではありません。
宣言や定義にはキーワードを伴う: 関数定義なら fun、定数宣言なら val、変数宣言なら var、クラス定義なら class など、明示的にキーワードを使い宣言するので grep フレンドリーです。また、列挙型は enum ではなく、enum class で列挙だと知らなくても class で検索すれば見落としません。C/C++は、int f(int ch){...}, int i = 9;のように、よく読まないと関数定義なのか変数宣言かわからないのとは対照的です。特にC++は、int a(3)が関数定義なのか変数宣言なのかに曖昧さがあり、パースの時点では確定せずコンパイラーもプログラマーも悩まされます。
型推論 : サポートします。
ガベージコレクション : サポートします。
クラス : クラスベースのオブジェクト指向言語です。
全てがオブジェクト : Javaで言うプリミティブもオブジェクトで、メソッドを持ちます。
コンストラクター : プライマリーコンストラクター・セカンダリコンストラクター・init の３つのメソッドがインスタンス化の機能が割振られます。
デストラクター : ありません。
継承 : 単一継承をサポートします。
抽象クラス : Java や Go の interface や Swift の protocol はありませんが、abstract class があります。
Mix-in : サポートします。
名前空間 : パッケージが名前空間を持ちます。
defer : ありません。
分岐構造は式 : if, whenは式です。
文末の;（セミコロン）: 必要ありません。
エラトステネスの篩を、若干 Kotlin らしく書いてみました。
[https://pl.kotl.in/ZIj3KGfFH エラトステネスの篩]:
fun eratosthenes(n: Int) {
    var sieve = BooleanArray(n + 1){ it >= 2 }
    for (i in 2..
実行結果:
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 
使用頻度の高い sieve は、実行効率の良いプリミティブ型配列の BooleanArray として、初期化式を it >= 2 として宣言と同時に素数候補をマークしました。
i のループはオーソドックスな IntRange をコレクションにした for ですが、j のループは少し変則的で until は制御構造に見えますが、メソッド infix Int.until(to: Int) : IntProgression で、infix 修飾による中置構文です。
最大公約数と最小公倍数を、若干 Kotlin らしく書いてみました。
[https://pl.kotl.in/eumYGumM7 最大公約数と最小公倍数]:
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)}")
}
実行結果:
gcd2(30, 45) => 15
gcd(30, 72, 12) => 6
lcm2(30, 72) => 360 
lcm(30,42,72) => 2520
関数 gcd2() は、2つの整数の最大公約数をユークリッドの互除法で求めています。
gcd2() の修飾子 tailrec は、コンパイラーに末尾再帰が行なわれていることを教え、再帰をループにするヒントを与えています。
関数 gcd() は可変引数関数で、全ての引数に gcd2() を適用し最大公約数を返します。
関数 lcm2() は、2つの整数の最小公倍数を、GCD(m,n) \cdot LCM(m,n)=m \cdot nを利用して求めています。
関数 lcm() は可変引数関数で、全ての引数に lcm2 を適用し最小公倍数を返します。
それぞれの関数定義は式形式で１行なので拍子抜けですが、概念を簡素にかけていると思います。
二分法を、若干 Kotlin らしく書いてみました。
[https://paiza.io/projects/HwIg-40sBXp5GOFWFTLKMA?language=kotlin 二分法]:
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})
}
実行結果:
0.9999999999417923 
1.0000000000291038
旧課程(-2012年度)高等学校数学B/数値計算とコンピューター#2分法の例を Kotlin に移植しました。
bisection(0, 3){x : Double -> x - 1}のような表現ができます。
引数で受取った範囲を一旦varに移替えているのは、関数の引数がイミュータブルなためです。
また、どうせローカル変数に移すならパラメータは Number 型としてIntなども受け入れるようにし、.toDouble()で型を揃えています。
このコードはまた、tailrec の好例にもなっています。
オーソドックスな複素数型の実装（Kotlinの標準ライブラリーには複素数型が見当たらなかったので）
[https://paiza.io/projects/9XyNAIQyFNLCewZO020A6Q?language=kotlin シンプルなクラス定義]:
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}
"""
    )
}
実行結果:
Hello world!
world
Hello my friend!
my friend
Hello::class.simpleName => Hello
hello1 => Hello world! 
hello2.s => my friend
Ruby#クラスの例を、Kotlin に移植しました。
冒頭4行がクラス定義です。
クラス定義に、他のオブジェクト指向言語ならコンストラクタに渡すような引数が渡されています。
メンバーを公開するケースなら、この様に宣言的な引数リストを使うとメンバー定義と暗黙の初期値を与えられます。
toString は、オブジェクトを文字列化するメンバー関数で、Anyの同名のメンバー関数をオーバーライドしています。
print は、このクラスに独自なメンバー関数で、println() の戻値型(= Unit)を戻値型としています。
[https://paiza.io/projects/C2zvgreLywbWQvIGSzHGug?language=kotlin JavaのI/Oシステムを使いファイルを読込む]:
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()
    }
}
[https://paiza.io/projects/cfZOI-b1YK5S36_bao5Isw?language=kotlin readText版]:
import java.io.File
fun main(args: Array) {
    print(File("/etc/hosts").readText())
}
エントリーポイント
fun main() {
    // ...
}
fun main(args: Array) {
    println(args.contentToString()) 
}
コメント:
// Kotlinには、行末で終わるコメントと
fun main() { /*
              * 複数行に渡ることと
              * /*
                 * 入れ子にすることができる
                 * コメントがあります
                 */
               */
    println("Hello, World!") 
}
プリミティブデータ型
変数宣言
リテラル
"""
複数行に渡る場合は
この様に
３つの"（ダブルクオーテーションマーク）で囲むことで記述できます。
"""
制御構造
else節のないifは、値を取ろうとするとコンパイルエラーになります。
when ( 式 ) {
    値0 -> 式０
    値1, 値2... , 値n-> 式１
    in 範囲式 -> 式２
    !in 範囲式 -> 式３
    is 型 -> 式４
    !is 型 -> 式５
elase -> 式ｘ
}
when {
    式０ -> 式０ｘ
    式１, 式２... , 式n-> 式１ｘ
elase -> 式ｘ
}
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)
}
var i = 0
while (i < 5) {
    println(i)
    i++
}
var i = 0
do {
    println(i)
    i++
} while (i < 5)
for (i in 0 until 5) {
    println(i)
}
コレクション
クラス
関数
KotlinとJavaは、どちらもJava Virtual Machine（JVM）上で動作するプログラミング言語です。以下は、KotlinとJavaの主な比較ポイントです。
Kotlin: Kotlinはnull安全性を重視しており、デフォルトで変数がnullになる可能性がある場合、その変数をnullableとして扱います。これにより、nullによる実行時のエラーを減少させます。
Java: 近年のJavaバージョンでは、OptionalやNullableなどの概念が導入され、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は、どちらも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は、それぞれ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:
fun main() {}
なにもしないプログラムはこの様になります。
use-args.kt:
fun main(args: Array) {
    println(args.contentToString())
}
Shell:
% kotlinc use-args.kt -include-runtime -d use-args.jar
% java -jar use-args.jar 123 abc 漢字
[123, abc, 漢字]
% _
パッケージの指定は、ソースファイルの冒頭（shebang!の次）で行ってください[https://kotlinlang.org/docs/basic-syntax.html#package-definition-and-imports Package definition and imports﻿]。
package my.demo
import kotlin.text.* 
// Imprementation
ディレクトリとパッケージの一致は必須ではなく、ソースファイルはファイルシステム上に任意に配置することができます。
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関連の機能が含まれています。
上記のパッケージは、明示的にインポートすることなく既にインポートされています[https://kotlinlang.org/docs/packages.html#default-imports Default imports﻿]。
このようなデフォルトのインポートにより、開発者は冗長なコードを書かずに済み、効率的にKotlinの機能を利用することができます。
----
以下は、デフォルトでインポートされる主要なパッケージの概要を表形式でまとめたものです。
また、ターゲットプラットフォームによっては、追加のデフォルトインポートが行われます。
これらのデフォルトインポートは、通常のKotlinプロジェクトで基本的な操作や機能を利用するための便利な手段となります。
デフォルトインポートとは別に、各ファイルは独自の import ディレクティブを含むことができます。
単一の名前でインポートすることができます。
 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 キーワードは、クラスのインポートに限定されません。他の宣言をインポートするためにも使用することができます。
トップレベル宣言が private とマークされている場合、その宣言が行われたファイルに対してプライベートとなります。
いかなる関数スコープにも属さないオブジェクトのことを、トップレベルオブジェクト( ''top level object'' )と言います[https://kotlinlang.org/spec/syntax-and-grammar.html#grammar-rule-topLevelObject topLevelObject]。
[https://paiza.io/projects/jKQiCwDXdUOhVY7dIoDmKg?language=kotlin トップレベルオブジェクトの前方参照は許される]:
val a = 10
fun main() {
    println("a =$a, b = $b")
}
val b = 32
実行結果:
a = 10, b = 32
この例では変数 b の参照が前方参照になっていますが、b はトップレベルオブジェクトなので参照解決されます。
Kotlinには、行末で終わるコメントと、複数行に渡ることと、入れ子にすることができるコメントがあります。
[https://pl.kotl.in/F-bmww7Bt comments.kt]:
// Kotlinには、行末で終わるコメントと
fun main() { /*
              * 複数行に渡ることと
              * /*
                 * 入れ子にすることができる
                 * コメントがあります
                 */
               */
    println("Hello, World!")
}
/* ... */タイプのコメントは、入れ子にできるのが多くのプログラミング言語と異なります。
Kotlinの他には、ScalaとD言語がコメントを入れ子にできます。
Kotlinでは、任意のインスタンスに対してプロパティーを参照したりメンバー関数を呼出すことができるという意味で、すべてのインスタンスがクラスに属しています。
いくつかの型は特別な内部表現を持つことができます。例えば、数字、文字、ブール値は実行時にプリミティブ値として表現できますが、ユーザーからは参照されるときに自動的にボックス化されるので普通のクラスのインスタンスのように見えます。
これらの型は基本的にJavaのプリミティブに一対一に対応しますが、Stringだけはjava.lang.Stringクラスに対応しています。
基本型は Package kotlin で定義されています。
Kotlinの基本型
 true, false
[https://pl.kotl.in/sePeMiW1A primitive.kt]:
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}")
  }
}
実行結果:
値 : 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
 で
の２つの値以外は取りえません。
JVMでは、この型の非Nullable値は、プリミティブ型のbooleanの値として表現されます。
論理型と数値型は可換ではないので、制御構造の条件式などでもゼロとの比較を行う必要があります。
Kotlinの数値型は、整数型と浮動小数点数型に分かれています。
 クラスから派生しており、具象クラスとして利用されます。
なお、文字型は数値型と可換ではありません。
Kotlinの整数型には、符号付き整数型と符号なし整数型があります。
符号なし整数型の名前は、対応する符号付き整数型の名前の先頭に U を補ったものになります。以下が主な整数型です：
Kotlinの浮動小数点数型には、以下の２つがあります：
これらの数値型は、数学的な演算や精密な計算に利用され、Kotlin言語において数値処理をサポートする基本的な要素となっています。
クラスは文字を表すクラスです。'a' のようなKotlinプログラム内の文字リテラルはすべてこのクラスのインスタンスとして実装されています[https://kotlinlang.org/docs/characters.html Characters﻿][https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-char/ Char]。
Charは、16ビットのUnicode文字を表します。これは、Charがすべての文字をユニコード文字を表すことが出来ない事をしめしています。
[https://pl.kotl.in/KRFm8vVVb Charで表現できない文字]:
fun main() {
    val ascii = 'A'
    val kanji = '漢'
    val emoji = '🏝'
}
コンパイル結果:
Too many characters in a character literal ''🏝''
🏝のUnicodeはU+1F3DDと16ビットを超えているので Char には収容できません。
絵文字以外にもサロゲートペアはあり、サロゲートペア以外にも合成文字も16ビットを超えるものがあります。
Kotlinは、Javaの文字エンコーディングシステムを引継いだので、Charの収まらない文字の問題に限らずUnicodeを内部エンコーディングに使っていることに起因する厄介ごとと付き合い続ければなりません。
Charでは、いくつかの演算子が定義されています。
[https://pl.kotl.in/pQ82wUEc_ Charクラスの演算子]:
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"}")
}
実行結果:
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
特殊文字は、エスケープする \（バックスラッシュ）から始まります。以下のエスケープシーケンスに対応しています。
その他の文字をエンコードする場合は、Unicodeエスケープシーケンス構文を使用します。'\uFF00' を使用します。
クラスは文字列を表すクラスです。"abc" のようなKotlinプログラム内の文字列リテラルはすべてこのクラスのインスタンスとして実装されています[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/ String]。
Kotlinでは、文字列( String )と文字( Char )とは直接の関係はありません（StringはCharの配列ではありません）。
Stringでは、加算演算子を連結として定義されています[https://github.com/JetBrains/kotlin/blob/f3385fbdcb8b9dc29661a8a4973c855cdcf73767/core/builtins/native/kotlin/String.kt#L30 kotlin/core/builtins/native/kotlin/String.kt]。
public operator fun plus(other: Any?): String
加算演算子( + )は、文字列( this )と与えられた他のオブジェクトの文字列表現を連結して得られる文字列を返します[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/plus.html plus - Kotlin Programming Language]。
[https://pl.kotl.in/1KlKcFKGs 文字列の+演算子]:
fun main() {
    val str = "ABC" + 12
    println(str + true + listOf(1,2,3))
}
実行結果:
ABC12true[1, 2, 3]
既に紹介したように、Stringクラスのリテラルは "（ダブルクオーテーション）で括った文字列です。
Stringリテラルには変数や式を埋込むことが出来ます。
といいます。
[https://pl.kotl.in/uBCbpW7Mc テンプレートリテラル]:
fun main() {
    var n = 10
    println("変数 n の値は $n です。")
    println("式 n + 13 の値は ${n + 13} です。")
    println("${'$'} 自体を書きたいときは、 \\\$ と \$ の直前に \\ を置きエスケープします（\$\$ではありません）。")
}
実行結果:
変数 n の値は 10 です。 式 n + 13 の値は 23 です。 
$ 自体を書きたいときは、 \$ と $ の直前に \ を置きエスケープします（$$ではありません）。
生文字列( ''Raw strings'' )は、改行や任意のテキストを含むことができます。トリプルクォート（”””; ''triple quote'' ）で区切られ、エスケープを含まず、改行や他の任意の文字を含むことができます[https://kotlinlang.org/docs/strings.html#raw-strings Raw strings]。
[https://pl.kotl.in/7Pqk1IwPo 生文字列]:
fun main() {
    var n = 10
    print(
"""
変数 n の値は $n です。
式 n + 13 の値は ${n + 13} です。
${'$'} 自体を書きたいときは、 \$ と $ の直前に \ を置きエスケープします（$$ ではありません）。
"""
    )
}
実行結果:
変数 n の値は 10 です。 式 n + 13 の値は 23 です。 
$ 自体を書きたいときは、 \$ と $ の直前に \ を置きエスケープします（$$ ではありません）。
[https://pl.kotl.in/7Pqk1IwPo 文字列のn番目のコードポイント]:
fun main() {
    val str = "ABC漢字🏝𠮷"
    
    var i = 0
    while (i < str.length) {
	    println(Integer.toHexString(str.codePointAt(i)))
        i++
    }
}
実行結果:
41 
42 
43 
6f22 
5b57 
1f3dd 
dfdd 
20bb7 
dfb7
Kotlinで配列型は Array で、main() の引数でも使われています[https://kotlinlang.org/docs/arrays.html Array][https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-array/ Array]。
Array(), arrayOf(), arrayOfNulls() や emptyArray() で生成します。 
[https://paiza.io/projects/sywOsCKIuSuu8x2BrbdfwQ?language=kotlin Array()を使ったArrayの生成]:
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("")
}
実行結果:
ary::class.simpleName ⇒ Array
ary[0]::class.simpleName ⇒ Int
0 1 2 3 4 
ary2[0]::class.simpleName ⇒ String 
0 1 4 9 16 
Array()はArrayのコンストラクターで、引数として要素数をとり、ブロックが初期化式になります。
Kotlinには、IntArray、DoubleArray、BooleanArray、CharArrayなどのプリミティブ型を要素とする配列のクラスが用意されています。
これらを総称してプリミティブ型配列( Primitive type arrays )と呼びます[https://kotlinlang.org/docs/arrays.html#primitive-type-arrays Primitive type arrays﻿]。
プリミティブ型配列は、機能的にはArrayのTにプリミティブ型を与えたものと変わりありませんが、ボックス化されないので性能向上とフットプリントの削減が期待できます。
このため、プリミティブ型配列はArrayを継承していません。
StringArray はありません。
[https://paiza.io/projects/tgs7lwP0-La0B-TUJ--kug?language=kotlin IntArray()を使ったIntArrayの生成]:
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()}
"""
    )
}
実行結果:
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]
[https://paiza.io/projects/avmXjK5ilEp1Xl-_CSnMfw?language=kotlin arrayOf()を使ったArrayの生成]:
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 ")}
}
実行結果:
Array
Int
1 9 3 5  
1 9 3 5 
arrayOf()は可変長引数の関数で、引数が生成されるArrayの要素になります。
Arrayの要素の型は、型強制できる最小公倍数的な方になります（例えば Int と Long が混在していたら Long）。
基本型の他にも幾つかの特別な型があります。
これらは、基本型同様 Package kotlin で定義されています。
特別な型
AnyはKotlinのクラス階層のルートです。すべてのKotlinクラスはAnyをスーパークラスとして持っています。
クラス定義で継承元を指定しないと Any が暗黙の継承元になります。
また、Anyクラスのオブジェクトは、あらゆるオブジェクトを代入できます。
[https://pl.kotl.in/k-36Q8gd6 AnyのArray]:
fun main() {
    arrayOf(4, "abc", 'a', listOf(2,5,6)).forEach{ println("$it(${it::class.simpleName})") }
}
実行結果:
4(Int) 
abc(String) 
a(Char) 
[2, 5, 6](ArrayList)
Unitは、何も返さない関数の戻値の型です。JVMでは、Javaのvoid型に相当します。
は
と等価です。
Nothingはインスタンスを持ちません。例えば、ある関数の戻り値がNothingであれば、それは決して戻らない（常に例外を投げる）ことを意味します[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-nothing.html Nothing]。
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な変数を宣言する場合は、String?とします。
Nullable型の安全な操作: Nullableな変数やプロパティに安全にアクセスする方法として、以下のような手法があります。
?.演算子: セーフコール演算子は、nullチェックを行い、nullでない場合にのみメンバーにアクセスします。
?:演算子: Elvis演算子は、nullでない場合には左側の値を、nullの場合には右側の値を返します。
!!演算子: null許容型の値を非Nullable型として扱い、nullの場合にはNullPointerExceptionをスローします。
Null安全性の確認: null安全性の確認は、条件式で明示的に行うことができます。if (variable != null)のような形で、nullチェックを行い、それに応じた処理を行います。
Safe casts: 安全なキャスト演算子as?を使用すると、通常のキャストでClassCastExceptionが発生する可能性がある場合でも、nullを返すことができます。
KotlinのNull安全性とNullable型は、プログラミングにおける安全性と信頼性を向上させるための重要な機能です。これらの機能を適切に理解し、利用することで、Nullによるエラーを最小限に抑えることができます。
Javaを含む多くのプログラミング言語における最も一般的な落とし穴の1つは、Null参照のメンバーにアクセスするとNull参照例外が発生することです。Javaでは、これはNullPointerException、略してNPEと呼ばれるものに相当します[https://kotlinlang.org/docs/null-safety.html#nullable-types-and-non-null-types Nullable types and non-null types﻿]。
KotlinでNPEが発生する原因として考えられるのは、以下の通りです。
NullPointerException()を明示的に呼び出した場合。
後述する !! 演算子の使用。
初期化に関するデータの不整合（以下のような場合）。
コンストラクターで使用可能な未初期化の this がどこかで渡され使用されている (「リーキング this」)。
スーパークラスのコンストラクターが、派生クラスの実装で未初期化の状態を使用しているオープンメンバーを呼出す場合。
Java との相互運用。
プラットフォーム型のNull参照のメンバにアクセスしようとする。
Java との相互運用に使用される汎用型の Nullability の問題。例えば、ある Java コードが Kotlin の MutableList に null を追加し、それを操作するために MutableList が必要になることがあります。
その他、外部のJavaコードによって引き起こされる問題。
Kotlinの型システムでは、nullを保持できる参照（Null可能参照; ''nullable references'' ）とそうでない参照（非Null参照; ''non-null references'' ）を区別しています。例えば、String型の通常の変数はnullを保持できません。
var a: String = "abc" // 通常の初期化ではデフォルトで非nullを意味します
// a = null // コンパイルエラー！
nullを許容するには、String?と書いて変数をnull可能な文字列として宣言します。
var b: String? = "abc" // nullに設定可能
b = null // OK
prinlnt(b)
さて、aのメンバー関数を呼び出したり、プロパティーにアクセスしたりしても、NPEが発生しないことが保証されています。
val l = a.length
しかし、bのメンバー関数を呼び出したり、プロパティーにアクセスしたりすると、それは安全ではなく、コンパイラはエラーを報告します。
val l = b.length
それでもそのプロパティにアクセスする必要がありますよね？そのためには、いくつかの方法があります。
まず、bがnullかどうかを明示的にチェックし、2つの選択肢を別々に処理することができます。
val l = if (b != null) b.length else -1
コンパイラーは実行したチェックの情報を記録し、ifの内部でlengthの呼出しを可能にする。より複雑な条件もサポートされています。
val b: String? = "Kotlin"
if (b != null && b.length > 0) {
    print("文字列の長さは ${b.length}")
} else {
    print("空文字列")
}
註：b が immutable な場合 (つまり、チェックから使用までの間に変更されないローカル変数か、 バッキングフィールドを持つオーバーライド不可のメンバー変数) にのみ有効です。
Not-Null断定演算子(!!)で任意の値をnullでない型に変換し、値がnullの場合は例外をスローします。b!!と書くと、bの非null値（例えばこの例ではString）を返し、bがnullの場合はNPEを投げます。
val l = b!!.length
このように、NPEを発生させたい場合は、明示的に要求する必要があり、突然発生することはありません。
fun main() {
    var str: String? = "Hello" // ?を使ってnullを許容する
    str = null // 問題なくnullを代入できる
    
    val length = str?.length // 安全呼び出し演算子でnullチェックしつつプロパティにアクセス
    println("Length: $length")
}
?. 演算子は、null安全性を保証しつつ、str 変数がnullでない場合に length プロパティにアクセスします。str がnullの場合、length には null が代入されます。
このように、?. 演算子はnull値を安全に処理するために使用されます。例えば、Javaの場合、nullチェックを行わないとNullPointerExceptionが発生しますが、Kotlinでは ?. 演算子を使用することで、nullに対する操作を安全に行うことができます。
変数の名前のような名前を識別子( ''identifiers'' )と呼びます[https://kotlinlang.org/spec/syntax-and-grammar.html#identifiers Identifiers]。
変数ほかに、関数、クラス、クラスのメンバー、クラスのメンバー関数、enum、ラベルなどの名前も識別子です。
同じ名前空間の中では識別子は重複できません。
識別子に使える文字は、英数字・_(アンダーバー)・Unicode文字です。
識別子の最初に数字を使うことはできません。
識別子の大文字小文字は区別されます。
キーワードの使用には制限があります。
キーワードや空白を含む文字列など上のルールに従わない文字列は、`（バッククオーテーション）で囲むと識別子として使うことができます。
Kotlinでは、変数は使う前にかならず宣言する必要があります。
[https://pl.kotl.in/8PE1c8KR3 変数を使った単純なコード]:
fun main() {
    val hello = "Hello, World!"
    println(hello) 
}
実行結果:
Hello, World!
Hello worldの例と結果は同じですが、変数helloを導入しています。
val hello = "Hello, World!"
val 識別子 = 初期化式
の形式をとります。
println(hello) 
の様に識別子をそのまま書くことで、値（この場合は "Hello, World!"）を参照できます。
キーワード val を使って宣言された変数はイミュータブル( ''Immutable'' )です。
イミュータブルというのは、一度値が決めたら変更できないという意味です。
イミュータブルな変数を「定数」ということがありますが、リテラルのことを定数ということもあるので、ここでは「イミュータブルな変数」と呼びます。
[https://pl.kotl.in/8z57OJeNL ミュータブルな変数を使ったコード]:
fun main() {
    var hello = "Hello, World!"
    println(hello) 
    hello = "Hello, Kotlin!"
    println(hello) 
}
実行結果:
Hello, World! 
Hello, Kotlin!
var hello = "Hello, World!"
var 識別子 = 初期化式
の形式をとります。
キーワード var を使って宣言された変数はイミュータブル( ''Immutable'' )です。
ミュータブルというのは、変数の値を何度でも変更できるという意味です。
hello = "Hello, Kotlin!"
Kotlinでは = が代入演算子です。
代入の前の hello の値は "Hello, World!" でしたが、代入の後は "Hello, Kotlin!" になります。
いままでの例で既に型推論( ''type inference'' ) は使われています。
変数を宣言するときに、特に型を明示しませんでしたが、初期化式の型から変数の型を特定していたのです。
初期化式は省略可能です。
その場合は変数の型がわからないので型アノテーション( ''type annotation'' )が必要になります。
[https://pl.kotl.in/EW6hk7OkA 型アノテーションを伴った変数宣言]:
fun main() {
    var hello : String
    hello = "Hello, World!"
    println(hello) 
    hello = "Hello, Kotlin!"
    println(hello) 
}
実行結果:
Hello, World! 
Hello, Kotlin!
var hello : String
var 識別子 : 型
の形式をとります。
型アノテーションをイミュータブルな変数の宣言でも行えますが、事実上初期化式が必須なのでドキュメント性を高める以外の意味は希薄です。
シャドーイング( ''Shadowing'' )とは、スコープ内の2つの宣言が同じ名前になり、より内側の識別子が外側の識別子を隠すことです。
[https://paiza.io/projects/etUJhoaySpr4RcwO9VwO-g?language=kotlin コード例]:
fun main() {
    var i = 10
    
    for (i in 1..3)
        println("for内: i = $i")
    
    println("for外: i = $i")
}
コンパイラーの警告:
Main.kt:4:10: warning: name shadowed: i
    for (i in 1..3)
         ^
実行結果:
for内: i = 1
for内: i = 2
for内: i = 3 
for外: i = 10
ループ変数 i と、2行目で宣言された変数 i の名前が衝突しいています。
この様に名前が衝突した場合、スコープの内側のオブジェクトが参照されます。
コンパイラーはシャドーイングを発見するとwarning: name shadowed: 識別子と（エラーでなく）警告します。
多くのシャドーイングは無害ですが…
ありがちな間違え:
fun main() {
    for (i in 1..3)
        for (i in 1..4)
            println("(i, i) = ($i, $i)")
}
コンパイラーのエラー出力:
Main.kt:3:14: warning: name shadowed: i
        for (i in 1..4)
             ^
修正例:
fun main() {
    for (i in 1..3)
        for (j in 1..4)
            println("(i, j) = ($i, $j)")
}
行列式を扱っていると、よくやらかします。
オブジェクトを複数の変数に分解して初期化する宣言する方法があり、分解宣言( ''Destructuring declarations﻿'' )と呼ばれます[https://kotlinlang.org/docs/destructuring-declarations.html Destructuring declarations﻿]。
分解宣言の例:
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
"""
    )
}
実行結果:
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
to は infix 宣言された関数です。
Kotlinでは、演算子はメソッド形式の別名を持ちます。
例えば、a + b は a.plus(b) とも書けます。
この plus メンバー関数を再定義すると、演算子オーバーロードができます[https://kotlinlang.org/docs/operator-overloading.html Operator overloading﻿]。
[https://paiza.io/projects/mhnZrTY0BmuFApKNAy3oNw?language=kotlin コード例]:
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)}
"""
    )
}
実行結果:
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
演算子は、もちろん加算だけではありません。
Kotlinでは、クラスやインターフェースを継承したり、Decoratorのようなデザインパターンを使わずに、新しい機能を拡張することができます。これは、拡張( ''extensions'' )と呼ばれる特別な宣言によって実現されます[https://kotlinlang.org/docs/extensions.html Extensions]。
拡張関数( ''Extension functions﻿'' )を宣言するには、その名前の前に拡張される型を示すレシーバー型をつけます[https://kotlinlang.org/docs/extensions.html#extension-functions Extension functions]。以下は、Arrayにrotate関数を追加したものです。
[https://pl.kotl.in/FiS-uHjPC Arrayにrotate()を定義]:
fun main() {
	fun Array.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(" ")}")
}
実行結果:
ary = 2 3 5 7 11 
ary = 3 5 7 11 2
拡張関数でもジェネリックス（型パラメーター）が使用可能です。
先の例は、ArrayとIntのアレイ専用でしたが、任意の型 T のアレイ Array に拡張関数を拡張してみましょう。
[https://pl.kotl.in/P4tm3lb8h Arrayにrotate()を定義]:
fun main() {
	fun  Array.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(" ")}")
}
実行結果:
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
拡張は、一見するとクラスの中に後からメンバー関数を追加しているように見えるかもしれませんが、インスタンス.メソッド(実引数リスト) のパターンに合致する拡張定義があるかを静的に調べ、該当する拡張関数があればそれを呼出すことで実現しています。
このため拡張関数でメンバー関数をオーバーライドすることはできません。
Kotlinは関数型プログラミング言語であると同時に、クラスベースのオブジェクト指向プログラミング言語です。
クラス( ''class'' )はオブジェクトの設計図であり、インスタンスはその設計図に基づいて作成されます。
を使って定義します。
[https://pl.kotl.in/WSxMHFtzA 空のクラスの定義とインスタンス化]:
class X									// クラス定義
fun main() {
    val x = X()							// インスタンス化
    println("${x::class.simpleName}")	// クラス名を表示
}
実行結果:
X
[https://pl.kotl.in/WlVaRbKmX private なプロパティ s を持つクラスの定義]:
class X constructor(s: String)			// クラス定義
fun main() {
    val x = X("abc")					// インスタンス化
    println("${x::class.simpleName}")	// クラス名を表示
    // x.s --- Unresolved reference: s ;; s は private なので、ここでは参照できません 
}
実行結果:
X
 は、以下のように省略可能です。
[https://pl.kotl.in/R7Fzx9K3G public でイミュータブルなプロパティ s を持つクラスの定義]:
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 ;; イミュータブルなプロパティーは書換え不可
}
実行結果:
X 
x.s = abc
プロパティーの値の参照はできますが、val なので書換えはできません。
[https://pl.kotl.in/sAHYBVMIM public でミュータブルなプロパティ s を持つクラスの定義]:
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}")				// プロパティーの値を表示
}
実行結果:
X 
x.s = abc 
x.s = xyz
コンストラクターのパラメーターを val から val に変更したので、ミュータブルとなりプロパティーの値を変更できるようになりました。
[https://pl.kotl.in/IODi_0xMo init はコンストラクターの後に呼出されるブロック]:
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}")				// プロパティーの値を表示
}
実行結果:
init: s = abc 
X 
x.s = abc 
x.s = xyz
Kotlinのクラスはプライマリーコンストラクターと1つまたは複数のセカンダリーコンストラクターを持つことができます。プライマリーコンストラクターはクラスヘッダの一部で、クラス名とオプションの型パラメターの後に続きます。
メンバー関数は、クラス定義の中で定義された関数です[https://kotlinlang.org/docs/functions.html#member-functions Member functions]。
メンバー関数の呼出はドット記法で行います。
メンバー関数からは、プライベートなクラスのメンバーにアクセスできます。
オブジェクトは、匿名クラスの定義とインスタンス化を同時に行うものです。
[https://paiza.io/projects/HRaRjZqiJz8DxWz3gh_mEg?language=kotlin オブジェクトの例]:
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}
"""
    )
}
実行結果:
obj => (3, 4)
obj.a => 3, obj.b => 4 
obj::class.simpleName => null
クラスは、明示的に継承元を指定しない場合は Any を継承します。
継承モディファイア( ''inheritance modifier'' )には、次のような種類があり、これらのトークンはモディファイア・キーワードです。
抽象クラス( ''abstract class'' )は、抽象メンバー関数( ''abstract method'' )だけを持つクラスです。
モディファイア・キーワード abstract は、抽象メンバー関数の定義でも使われます。
ファイナルクラス( ''final class'' )は、継承を禁止したクラスです。
KotlinのクラスはJavaと異なり、ディフォルトで継承禁止なので、継承禁止を強調する意味しかありません。
モディファイア・キーワード final は、オーバーライド禁止メンバーの宣言でも使われます。
オープンクラス( ''open class'' )は、継承を許可したクラスです。
KotlinのクラスはJavaと異なり、ディフォルトで継承禁止なので、継承を行う可能性がある場合は明示的に許可する必要があります。
モディファイア・キーワード open は、メンバー関数のオーバーライド許可でも使われます。
{{コラム|Kotlinのクラスはディフォルトでfinal|2=
Javaと異なり、Kotlinのクラスはディフォルトでfinal（継承禁止）です。
これは、主にセキュリティー上の理由からで、クラスを継承することによりprotectedでの隠蔽に綻びが生じプログラムが「ハイジャック」されることの重要さに配慮したもので、
クラス設計に於いてのトレードオフ、「拡張性と頑強性」のディフォルトを頑強に振った言語設計になっています。
クラスのメンバー関数が、プロパティやメンバー関数を参照するとき、クラスの外の変数や関数との間で曖昧さが生じる事があります。
 を使います[https://kotlinlang.org/docs/this-expressions.html This expressions]。
this はこのほか、2 次コンストラクタから同じクラスの別のコンストラクタを呼出すときにもつかわれます。
[https://paiza.io/projects/a6IABje1M-ZOPH4asPyCpQ?language=kotlin thisを使ったメンバー関数の限定]:
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()
}
実行結果:
Method
Function
Method
メンバー関数から同じクラスのメンバー関数を呼出すとき、同名の関数があると関数が呼出されます。
メンバー関数から同じクラスのメンバー関数を呼出すときには、同名の関数があると関数が呼出されます。
クラスモディファイア( ''class modifier'' )には、次のような種類があり、これらのトークンはモディファイア・キーワードです。
列挙型クラス( ''Enum class'' )は、有限個の識別子の集合を表現するために使用されます。
enum class DayOfWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}
fun main() {
    val today = DayOfWeek.MONDAY
    println("Today is $today")
}
特性と用途
特定の値の集合を表現するために使用されます（例: 曜日、状態など）。
定数のような振る舞いを持ち、列挙型の各要素は固定された値として使用されます。
シールドクラス( ''Sealed class'' )は、制限されたクラス階層を表現するために使用されます。
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)
}
特性と用途
制限されたクラス階層を定義するために使用されます。サブクラスは通常、シールドクラス内にネストされます。
シールドクラスのサブクラスは通常、特定の型の状態や結果を表現するために使用されます。
アノテーションクラス( ''annotation class'' )は、コードにメタデータを付加するための手段を提供します。
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")
}
特性と用途
コードに追加情報や設定を提供するために使用されます。
ランタイムやコンパイル時にアノテーションを処理することで、特定の動作やコード生成をトリガーすることができます。
データクラス( ''Data class'' )は、データを保持するためのクラスで、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)
}
特性と用途
データのコンテナとして使用され、自動的にequals()、hashCode()、toString()、copy()メソッドが生成されます。
イミュータブルなデータオブジェクトを簡潔に表現するために使用されます。
インナークラス( ''Inner class'' )は、入れ子になった内側になったクラスが外側のクラスのメンバーにアクセスすることを可能にします。
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()
}
特性と用途
外側のクラスのインスタンスに紐づく内側のクラスを定義するために使用されます。
内側のクラスは外側のクラスの非公開メンバーやプロパティにアクセスすることができます。
値クラス( ''Value class'' )は、イミュータブルなスカラー値の型を定義します。プロポーザル段階では inline class と呼ばれていました。
inline class Password(val value: String)
fun main() {
    val password = Password("secret")
    println("Password: ${password.value}")
}
特性と用途
単一の値を表すために使用されます。プリミティブ型のように振る舞い、ボックス化のオーバーヘッドを回避します。
+ ラッパークラスとして機能し、型安全性やコードの表現力を向上させます。
オブジェクト( ''object'' )は、モディファイア・キーワードではありませんが、特殊なクラスの一種なので併せて紹介します。
オブジェクトは一過的な匿名クラスを定義し、そのインスタンスの生成を行います。
object Logger {
    fun log(message: String) {
        println("Log: $message")
    }
}
fun main() {
    Logger.log("Hello, World!")
}
特性と用途
シングルトンパターンを実装するために使用されます。クラスの単一のインスタンスを表現し、グローバルなアクセスポイントとして機能します。
関連するメソッドやプロパティを含めることができ、特定の目的に特化したオブジェクトを表現することができます。
まとめ
各クラスモディファイアは、異なる用途や特性を持っており、柔軟なクラス定義を可能にします。
適切なモディファイアを選択することで、コードの意図を明確に表現し、保守性や可読性を向上させることができます。
クラス、オブジェクト、インターフェース、コンストラクター、関数、およびプロパティとそのセッターは、可視性モディファイア( ''Visibility modifiers﻿'' )を持つことができます。ゲッターは常にそのプロパティと同じ可視性を持っています[https://kotlinlang.org/docs/visibility-modifiers.html Visibility modifiers]。
可視性モディファイアには、次のような4種類があり、これらのトークンはモディファイア・キーワードです。
デフォルトの可視性はpublicです。
関数、プロパティ、クラス、オブジェクト、およびインタフェースは、パッケージの中で直接「トップレベル」で宣言することができます。
可視性モディファイアを使用しない場合、デフォルトではpublicが使用され、宣言はどこでも見えるようになります。
宣言に private を指定すると、その宣言を含むファイル内でのみ可視化されます。
internalと指定した場合は、同じモジュール内であればどこでも見えるようになります。
protected修飾子は、トップレベルの宣言には使えません。
クラス内部で宣言されたメンバー。
private は、そのメンバーがこのクラスの内部でのみ可視であることを意味します（そのクラスのすべてのメンバーを含む）。
protected は、private とマークされたメンバーと同じ可視性を持ちますが、サブクラスでも可視化されることを意味します。
internal は、宣言したクラスを見たこのモジュール内のクライアントが、その内部のメンバーを見ることができることを意味します。
public は、宣言クラスを見たすべてのクライアントがその public メンバを見ることができることを意味します。
protectedまたはinternalメンバーをオーバーライド( ''override'' )し、可視性を明示的に指定しない場合、オーバーライドしたメンバーも元のメンバーと同じ可視性を持つことになります。
クラスの一次コンストラクタの可視性を指定するには、次の構文を使用します。
class C private constructor(a: Int) { ... }
ここでは、コンストラクターは private です。デフォルトでは、すべてのコンストラクターは public です。これは、クラスが見えるところならどこでもコンストラクターが見えるということです（裏を返せば、内部クラスのコンストラクターは同じモジュール内でしか見えないということです）。
ローカル変数、関数、クラスは可視性モディファイアを持つことができません。
internal 可視性モディファイアは、そのメンバーが同じモジュール内で可視であることを意味します。具体的にモジュールとは、例えば、一緒にコンパイルされたKotlinファイルの集合のことです。
IntelliJ IDEAモジュール。
Gradleのソースセット（ただし、testのソースセットはmainの内部宣言にアクセスできる）。
''kotlinc'' Antタスクの1回の呼び出しでコンパイルされるファイル群。
抽象クラス( ''abstract class'' )は、抽象メソッド( ''abstract method'' )だけを持つクラスであり、直接のインスタンス化ができません。抽象メソッドは本体を持たず、具体的な実装はそのサブクラスに委ねられます。Kotlinでは、abstract キーワードを使用して抽象クラスと抽象メソッドを宣言します。
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")
    }
}
 
上記の例では、Shape という抽象クラスがあります。このクラスは抽象メソッド draw を宣言しています。サブクラスである Circle と Rectangle は、それぞれ draw メソッドをオーバーライドして具体的な実装を提供します。
fun main() {
    // コンパイルエラー: Cannot create an instance of an abstract class
    // val shape = Shape()
    val circle = Circle()
    circle.draw()
    val rectangle = Rectangle()
    rectangle.draw()
}
 
抽象クラスは直接インスタンス化できないため、Shape クラスのインスタンスを作成しようとするとコンパイルエラーが発生します。代わりに、具象サブクラスである Circle や Rectangle のインスタンスを作成して使用します。
抽象クラスは抽象プロパティを持つこともできます。また、抽象クラス自体はコンストラクタを持つことができます。
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")
    }
}
この例では、Shape クラスはコンストラクタを持ち、name という抽象プロパティを宣言しています。サブクラスである Circle と Rectangle は、コンストラクタで name を渡し、draw メソッドをオーバーライドしています。
抽象クラスは、クラス階層の一部として柔軟で再利用可能なコードを設計する際に役立ちます。
抽象クラスは、以下のようなユースケースやベストプラクティスに適しています。
部分的な実装の提供: 抽象クラスは、一部のメソッドやプロパティの実装を提供することができます。これにより、サブクラスは抽象メソッドだけでなく、既存の実装を再利用できます。
abstract class Shape {
    fun commonMethod() {
        // 共通の実装
    }
    abstract fun draw()
}
メソッドの強制: 抽象クラスには抽象メソッドが含まれており、これをサブクラスで実装することが義務付けられます。これにより、サブクラスが特定のメソッドを実装することが保証されます。
abstract class Printer {
    abstract fun print()
}
class LaserPrinter : Printer() {
    override fun print() {
        // レーザープリンターの実装
    }
}
継承と拡張: 抽象クラスを使用すると、クラス階層を構築し、新しい機能を追加していくことができます。これは、将来的に変更や拡張が発生する可能性がある場合に特に役立ちます。
abstract class Animal {
    abstract fun makeSound()
}
class Dog : Animal() {
    override fun makeSound() {
        println("Woof!")
    }
}
class Cat : Animal() {
    override fun makeSound() {
        println("Meow!")
    }
コンストラクタとプロパティ: 抽象クラスはコンストラクタを持ち、抽象プロパティを宣言できます。これにより、サブクラスが特定のプロパティを持つことが保証され、コンストラクタで初期化できます。
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")
    }
}
複数のインターフェースの代替: 抽象クラスは複数のメソッドやプロパティをまとめて提供できるため、インターフェースが多すぎる場合に、抽象クラスを使用して階層を整理することができます。
abstract class UIControl {
    abstract fun render()
    abstract fun onClick()
}
class Button : UIControl() {
    override fun render() {
        println("Rendering button")
    }
    override fun onClick() {
        println("Button clicked")
    }
}
抽象クラスは、柔軟性と再利用性を向上させるために使われますが、適切に設計される必要があります。必要以上に多くの機能を含めると、過度な依存関係が生まれる可能性があるため、慎重な設計が求められます。
ファイナルクラス（final class）は、Kotlinにおいて継承を禁止したクラスを指します。Kotlinでは、デフォルトでクラスが継承不可（final）となっており、継承可能にするためには明示的にopen修飾子を使用する必要があります。そのため、finalキーワードは主にオーバーライド禁止メンバーの宣言で使用され、クラス自体に適用することは少ないです。
final class MyFinalClass {
    // クラスの定義
}
 
上記の例では、MyFinalClass はファイナルクラスとして宣言されています。このクラスは他のクラスから継承できません。
open class MyBaseClass {
    final fun myFinalMethod() {
        // オーバーライド禁止のメソッド
    }
}
 
 
上記の例では、MyBaseClass の myFinalMethod は final 修飾子が付いており、このメソッドはオーバーライドできません。
final class Configuration {
    // クラスの定義
}
class ApplicationSettings(config: Configuration) {
    // FinalClass を利用したクラスの定義
}
 
 
上記の例では、Configuration クラスがファイナルクラスとして定義されています。このクラスは他のクラスから継承できないため、設定情報の不正な変更や上書きを防ぐことが期待されます。ApplicationSettings クラスは Configuration を利用してアプリケーションの設定を管理しています。
ファイナルクラスは特定の状況で利用され、継承を禁止してクラスの拡張を制御するために使用されます。
オープンクラス（open class）は、Kotlinにおいて継承を許可したクラスを指します。
Kotlinのクラスはデフォルトで継承不可（final）となっているため、クラスを継承可能にするには明示的にopen修飾子を使用する必要があります。
open class MyOpenClass {
    // クラスの定義
}
上記の例では、MyOpenClass はオープンクラスとして宣言されています。このクラスは他のクラスから継承できます。
open class MyBaseClass {
    open fun myMethod() {
        // オーバーライド可能なメソッド
    }
}
上記の例では、MyBaseClass の myMethod は open 修飾子が付いており、このメソッドはオーバーライド可能です。
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")
    }
}
上記の例では、Shape クラスがオープンクラスとして定義されています。Circle と Square クラスが Shape を継承し、draw メソッドをオーバーライドしています。これにより、各図形クラスは自身の特定の描画方法を持つことができます。
オープンクラスは継承を許可し、クラスの拡張やカスタマイズが可能となります。ただし、使用する際には慎重に設計し、必要なメソッドやプロパティに対してのみopen修飾子を使用することが推奨されます。
列挙型クラス( ''Enum classes'' )は、キーワード enum を class に前置して定義します[https://kotlinlang.org/docs/enum-classes.html Enum classes]。
Swift/オブジェクト指向#列挙型の例を Kotlin 向けにモディファイしました。
[https://paiza.io/projects/lW6ghepnPWyQnctPdyX6Zw?language=kotlin 列挙型クラスとメソッド]:
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().joinToString{it.name})
}
実行結果:
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
override fun toString() でEnumのディフォルトの文字列化メソッドをオーバーライドしています。
シールドクラス（Sealed class）は、制限されたクラス階層を表現するために使用される Kotlin 特有の機能です。シールドクラスは、特定のサブクラスのみを許容し、新しいサブクラスの追加を防ぎます。これにより、特定の型に対するパターンマッチングが容易になります。
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}
上記の例では、Result クラスはシールドクラスとして宣言されています。このクラスには3つのサブクラスがあります：Success、Error、および Loading。Success と Error はデータクラスで、それぞれデータを保持します。Loading はオブジェクトクラスで、データを保持しません。
fun processResult(result: Result) {
    when (result) {
        is Result.Success -> println("Success: ${result.data}")
        is Result.Error -> println("Error: ${result.message}")
        Result.Loading -> println("Loading...")
    }
}
上記の例では、Result クラスのサブクラスごとに異なる処理を行う processResult 関数があります。when 式を使用して、特定のサブクラスに対するパターンマッチングを行っています。
コンパイラがすべてのサブクラスを知っているため、when 式などのパターンマッチングが網羅的であることを確認できます。
新しいサブクラスが追加された場合、コンパイラは未処理のケースがあるかどうかを検知し、警告を発生させます。
シールドクラスは同じファイル内で宣言されたクラスに対してしか有効ではありません。
シールドクラスは、特に固定されたクラス階層を表現する場合や、特定の型に対する安全なパターンマッチングを行う場合に便利です。
アノテーションクラス（annotation class）は、Kotlinにおいてコードにメタデータを付加するための手段を提供します。これにより、コンパイラや実行時の処理で追加の情報を提供することが可能となります。
アノテーションクラスは、@シンボルを使って宣言されます。アノテーションクラスの主な目的は、アノテーションを作成し、それをコードの要素に適用することです。
annotation class MyAnnotation(val name: String, val version: Int)
上記の例では、MyAnnotation というアノテーションクラスが宣言されています。このアノテーションは、name と version というパラメータを持っています。
アノテーションは、クラスや関数、プロパティなど、さまざまな要素に適用できます。
@MyAnnotation(name = "MyApp", version = 1)
class MyClass {
    @MyAnnotation(name = "MyFunction", version = 2)
    fun myFunction() {
        // 関数の本体
    }
}
上記の例では、MyClass クラスとその中の myFunction 関数に MyAnnotation が適用されています。これにより、このクラスや関数に対する追加のメタデータが提供されます。
アノテーションをプロセッシングするためには、リフレクションやKotlinのアノテーションプロセッサを使用することがあります。これにより、アノテーションに関連する処理を行うカスタムロジックを実装できます。
// アノテーションプロセッサの例
fun processMyAnnotation(element: AnnotatedElement) {
    val myAnnotation = element.getAnnotation(MyAnnotation::class.java)
    if (myAnnotation != null) {
        println("Name: ${myAnnotation.name}, Version: ${myAnnotation.version}")
    }
}
上記の例では、AnnotatedElementを受け取り、その要素に MyAnnotation が適用されているかを調べ、情報を取得しています。
アノテーションクラスは、コードにメタデータを追加し、プロセッシングや設定などの目的で使用されます。
データクラス（Data class）は、Kotlinにおいてデータの保持や操作を目的としたクラスで、copy() メソッドなどがクラスを定義するだけで自動的に生成されます。これにより、不変性やイミュータビリティ（immutable）を維持しながら、簡潔で効果的なデータクラスを作成できます。
data class Person(val name: String, val age: Int)
上記の例では、Person クラスがデータクラスとして宣言されています。コンストラクタで定義されたプロパティ（name と age）に対して、equals()、hashCode()、toString() などの標準メソッドが自動的に生成されます。
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)
上記の例では、equals() メソッドにより person1 と person2 の内容が一致するか比較され、toString() メソッドによりクラスの内容が文字列として表示されます。また、copy() メソッドを使って一部のプロパティを変更した新しいインスタンスを作成しています。
データクラスが生成される主なメソッドは以下の通りです。
equals(): プロパティごとの内容比較を行います。
hashCode(): プロパティごとにハッシュコードを生成します。
toString(): クラスの内容を文字列として返します。
copy(): インスタンスのコピーを作成します。一部のプロパティを変更できます。
データクラスは、イミュータブルでありながら効果的にデータを操作するための便利な手段を提供します。
Kotlinのインターフェース（interface）は、抽象的なメソッドの宣言と、メソッドの実装を含むことができます。インターフェースは、抽象クラスと異なり状態を保持することができません。プロパティを持つ場合、これらは抽象クラスであるか、アクセサーの実装を提供する必要があります[https://kotlinlang.org/docs/interfaces.html Interfaces]。
interface MyInterface {
    fun doSomething() // 抽象メソッドの宣言
    fun doSomethingElse() {
        // デフォルトのメソッド実装
        println("Default implementation of doSomethingElse")
    }
    val property: Int // 抽象プロパティの宣言
}
上記の例では、MyInterface インターフェースが、抽象メソッド doSomething() とデフォルトのメソッド doSomethingElse()、抽象プロパティ property を宣言しています。
class MyClass : MyInterface {
    override fun doSomething() {
        // メソッドの実装
        println("Implementation of doSomething")
    }
    override val property: Int
        get() = 42 // プロパティの実装
}
上記の例では、MyClass クラスが MyInterface インターフェースを実装しています。doSomething() メソッドと property プロパティをオーバーライドしています。
interface A {
    fun methodA()
}
interface B {
    fun methodB()
}
class C : A, B {
    override fun methodA() {
        // A インターフェースの実装
    }
    override fun methodB() {
        // B インターフェースの実装
    }
}
上記の例では、C クラスが A インターフェースと B インターフェースの両方を実装しています。複数のインターフェースをカンマで区切って指定することができます。
interface D : A, B {
    fun methodD()
}
上記の例では、D インターフェースが A インターフェースと B インターフェースを継承しています。これにより、D インターフェースは A と B のメソッドを含むことになります。
Kotlinのインターフェースは、クラスが異なる振る舞いを持つ場合に簡潔で柔軟な解決策を提供します。異なるインターフェースを実装することで、複数の振る舞いを同じクラスで組み合わせることができます。
インナークラス（Inner class）は、入れ子になった内側のクラスが外側のクラスのメンバーにアクセスすることを可能にします。これにより、外側のクラスと強い結びつきを持ちながら、内部で独自の振る舞いやデータを持つクラスを定義できます。
class OuterClass {
    private val outerProperty: Int = 10
    inner class InnerClass {
        fun printOuterProperty() {
            // OuterClass のプロパティにアクセス
            println("Outer property: $outerProperty")
        }
    }
}
上記の例では、OuterClass という外側のクラスがあり、その中に InnerClass というインナークラスが定義されています。InnerClass は OuterClass のプロパティにアクセスすることができます。
fun main() {
    val outerInstance = OuterClass()
    val innerInstance = outerInstance.InnerClass()
    innerInstance.printOuterProperty()
}
上記の例では、OuterClass のインスタンスを作成し、そのインナークラスである InnerClass のインスタンスを取得しています。そして、InnerClass のメソッドを呼び出して外側のクラスのプロパティにアクセスしています。
外部クラスへのアクセス: インナークラスは、外部クラスのメンバーにアクセスできます。外部クラスのプロパティやメソッドに直接アクセスできるため、疎結合な設計が可能です。
thisキーワードの挙動: インナークラスでは、外部クラスのインスタンスにアクセスするために this@OuterClass のように明示的な指定ができます。これにより、外部クラスのメンバーと同じ名前のメンバーがインナークラス内にある場合に区別できます。
非静的なクラス: インナークラスは外部クラスのインスタンスに依存しており、非静的なクラスです。したがって、外部クラスのインスタンスが存在しないとインナークラスも存在しません。
インナークラスは、外部クラスとの緊密な連携が必要な場合や、外部クラスのプライベートなメンバーにアクセスする必要がある場合に有用です。
値クラス（data class）は、イミュータブルでスカラーな値の型を定義するための概念です。プロポーザル段階では inline class と呼ばれていました。値クラスは、プリミティブ型のように振る舞い、同時に型安全性を提供します。
data class Email(val value: String)
上記の例では、Email という値クラスが宣言されています。この値クラスは、イミュータブルであり、value というプロパティを持っています。
fun main() {
    val email1 = Email("john@example.com")
    val email2 = Email("jane@example.com")
    println(email1 == email2) // 値クラスの比較
}
上記の例では、異なるインスタンスの Email クラスを作成し、その値が等しいかを比較しています。値クラスでは、プライマリコンストラクタの引数で値が確定し、その値に基づいて等価性が判定されます。
イミュータブル性: 値クラスは不変（イミュータブル）であるため、一度生成されたインスタンスの値は変更されません。これにより、安全で予測可能なコードを実現します。
型安全性: 値クラスは型安全性を提供します。異なる値クラス間は厳密に区別され、混同されることがありません。
自動生成メソッド: 値クラスは equals() や hashCode() などのメソッドを自動生成します。これにより、等価性の確認やコレクションの利用が容易になります。
ボクシングの回避: 値クラスはプリミティブ型のように振る舞い、一部のボクシングを回避します。これにより、メモリ効率が向上します。
値クラスは、ドメインモデリングや特定のデータ型を表現する際に有用であり、プロジェクト全体でのコードの理解性や保守性を向上させる役割を果たします。
オブジェクト（object）は、モディファイア・キーワードではありませんが、特殊なクラスの一種であり、一過的な匿名クラスを定義し、その唯一のインスタンスを生成します。オブジェクトはシングルトンのような振る舞いを持ち、一般的には特定の目的に使用されます。
object Logger {
    fun log(message: String) {
        println("Log: $message")
    }
}
上記の例では、Logger という名前のオブジェクトが宣言されています。このオブジェクトはシングルトンであり、log メソッドを持っています。
fun main() {
    Logger.log("This is a log message.")
}
上記の例では、Logger オブジェクトの唯一のインスタンスにアクセスし、その log メソッドを呼び出しています。オブジェクトは初回のアクセス時に遅延初期化され、以降は同じインスタンスが再利用されます。
シングルトンパターン: オブジェクトはシングルトンとして振る舞います。クラスの唯一のインスタンスを持ち、それにアクセスするために新たなインスタンスを生成することはありません。
遅延初期化: オブジェクトは初回のアクセス時に初期化されます。これにより、プログラムが実際に必要なときに初期化処理が行われます。
クラスメンバー: オブジェクトはメソッドやプロパティを持つことができます。これらは通常のクラスメンバーと同じようにアクセスできます。
継承不可: オブジェクトは継承できません。そのため、他のクラスがこのオブジェクトを継承することはできません。
オブジェクトは特定のタスクや目的に対して唯一のインスタンスを提供する場合に利用され、例えばロギングや設定の管理などに適しています。
ジェネリックス( ''Generics'' )とは、汎用的なクラス・関数やメソッドを特定の型に対応づける機能のことです[https://kotlinlang.org/docs/generics.html Generics: in, out, where]。
( ''Keywords'' )は
に分類されます[https://kotlinlang.org/docs/keyword-reference.html Keywords and operators﻿]。
以下のトークンは、常にキーワードとして解釈され、識別子として使用することはできません[https://kotlinlang.org/docs/keyword-reference.html#hard-keywords Hard keywords﻿]。
このようなキーワードをハード・キーワード( ''Hard keywords'' )と呼びます。
型キャスト( ''type casts'' )に使用されます。
インポートの別名の指定に使用されます。
as? 安全なタイプキャスト( ''safe type casts'' )に使用されます。
break ループの実行を終了させます。
class クラスを宣言します。
continue 最も近いループの次のステップに進みます。
do do/whileループ（条件式を後置するつループ）を開始します。
else 条件が偽のときに実行されるif式の分岐を定義します。
false Boolean型の「偽」の値を表します。
for forループを開始します。
fun 関数を宣言します。
if if式の先頭です。
forループで反復されるオブジェクトを指定します。
値が範囲、コレクション、または「contains」メソッドを定義している他のエンティティに属しているかどうかを確認するための中置演算子として使用されます。
同じ目的のためにwhen式で使用されます。
型パラメータをcontravariantとしてマークします。
値が範囲、コレクション、または 'contains' メソッドを定義する他のエンティティに属さないことを確認する演算子として使用されます。
同じ目的のためにwhen式で使用されます。
interface インターフェース( ''interfaces'' )を宣言します。
値が特定の型を持つかどうかをチェックします。
同じ目的のwhen式で使用されます。
値が特定の型を持っていないかどうかをチェックします。
同じ目的のwhen式で使用されます。
null どのオブジェクトも指していないオブジェクト参照を表す定数です。
object クラスとそのインスタンスを同時に宣言します。
package 現在のファイルのパッケージを指定します。
return 最も近い包含関数または無名関数からの呼出し元に戻ります。
メソッドやプロパティのスーパークラス実装を参照します。
二次コンストラクタ( ''secondary constructor'' )からスーパークラスのコンストラクタを呼び出します。
現在のレシーバを指します。
2 次コンストラクタから同じクラスの別のコンストラクタを呼び出します。
throw 例外を投げます。
true Boolean型の「真」の値を表します。
try 例外処理ブロックを開始します。
typealias 型の別名を宣言します。
typeof 将来の使用のために予約されています。
val 読取り専用のプロパティまたはローカル変数を宣言します。
var 変更可能なプロパティまたはローカル変数を宣言します。
when when式を開始します（与えられた分岐のうち1つを実行します）。
while while ループ（条件式を前置するループ）を開始します。
以下のトークンは、それが適用される文脈( ''context'' )ではキーワードとして機能し、他の文脈では識別子として使用することができます[https://kotlinlang.org/docs/keyword-reference.html#soft-keywords Soft keywords﻿﻿]。
このようなキーワードをソフト・キーワード( ''Soft keywords﻿'' )と呼びます。
インターフェース( ''interface'' )の実装( ''implementation'' )を別のオブジェクトに委譲( ''delegates'' )します。
プロパティーのアクセッサー( ''accessors'' )の実装を別のオブジェクトに委譲します。
catch 特定の例外タイプ( ''specific exception type'' )を処理( ''handles'' )するブロックを開始します。
constructor 一次または二次コンストラクタを宣言します。
delegate アノテーション使用側ターゲット[仮訳]( ''annotation use-site target'' )として使用されます。
dynamic Kotlin/JS コードで動的な型を参照します。
field アノテーション使用側ターゲット[仮訳]として使用されます。
file アノテーション使用側ターゲット[仮訳]として使用されます。
finally tryブロックが終了したときに必ず実行されるブロックを開始します。
プロパティのゲッター( ''getter'' )を宣言します。
アノテーション使用側ターゲット[仮訳]として使用されます。
import 他のパッケージから現在のファイルに宣言をインポートします。
init イニシャライザーブロックを開始します。
param アノテーション使用側ターゲット[仮訳]として使用されます。
property アノテーション使用側ターゲット[仮訳]として使用されます。
receiver アノテーション使用側ターゲット[仮訳]として使用されます。
プロパティのセッター( ''setter'' )を宣言します。
アノテーション使用側ターゲット[仮訳]として使用されます。
setparam アノテーション使用側ターゲット[仮訳]として使用されます。
value キーワード class を付けてインラインクラス( ''inline class'' )を宣言します。
where 汎用型パラメーター( ''a generic type parameter'' )の制約( ''constraints'' )を指定します。
アノテーション使用側ターゲット( ''Annotation use-site target'' )は、Kotlinにおいてアノテーションが特定の要素に対して適用される位置を指定する構文です。これにより、生成されるJavaバイトコードにおいてアノテーションがどの要素に適用されるかを正確に指定できます[https://kotlinlang.org/docs/annotations.html#annotation-use-site-targets Annotation use-site targets﻿﻿﻿]。
以下は、一般的なアノテーション使用側ターゲットの指定方法です。
class Example {
    @get:MyAnnotation
    val myProperty: Int = 42
}
この例では、@get:MyAnnotation と指定することで、プロパティのgetterメソッドに対してアノテーションを指定しています。
class Example(@param:MyAnnotation val value: String)
この例では、@param:MyAnnotation と指定することで、1次コンストラクタのパラメータに対してアノテーションを指定しています。
@get: プロパティのgetterメソッドに対してアノテーションを指定する。
@set: プロパティのsetterメソッドに対してアノテーションを指定する。
@field: プロパティ自体に対してアノテーションを指定する。
これらの使用側ターゲットを使うことで、アノテーションが生成される場所を明確に指定することができ、柔軟性を保ちつつ、正確な挙動を得ることができます。
以下のトークンは、宣言の修飾語リスト( ''modifier lists of declarations'' )のキーワードとして機能し、他のコンテキストでは識別子として使用することができます[https://kotlinlang.org/docs/keyword-reference.html#modifier-keywords Modifier keywords﻿]。
このようなキーワードをモディファイア・キーワード( ''Modifier keywords﻿'' )と呼びます。
abstract クラスやメンバが抽象的( ''as abstract'' )であることを表します。
actual マルチプラットフォーム・プロジェクト( ''multiplatform projects'' )におけるプラットフォーム固有の実装( ''platform-specific implementation'' )を意味します。
annotation アノテーションクラス( ''an annotation class'' )を宣言します。
companion コンパニオンオブジェクト( ''a companion object'' )を宣言します。
const プロパティをコンパイル時の定数( ''a compile-time constant'' )としてマークします。
crossinline インライン関数に渡されるラムダで、ローカルでない返り値を禁止します。
data クラスの正規メンバー( ''canonical members'' )を生成するようにコンパイラーに指示します。
enum 列挙型( ''an enumeration'' )を宣言します。
expect 宣言がプラットフォーム固有( ''as platform-specific'' )のものであり、プラットフォーム・モジュール(platform modules  )で実装されることを期待するものとしてマークします。
external Kotlin の外部で実装される宣言であることを示します（JNI または JavaScript でアクセス可能）。
final メンバーのオーバーライドを禁止します。
infix 中置記法( ''infix notation'' )で関数を呼び出すことを許可します。
inline 関数とその関数に渡されたラムダを呼出し先でインライン化することをコンパイラに指示します。
inner ネストされたクラスから外側のクラスのインスタンスを参照できるようにします。
internal 現在のモジュールで可視( ''as visible'' )となる宣言をマークします。
lateinit コンストラクターの外部で非 null プロパティを初期化します。
noinline インライン関数に渡されたラムダをインライン化しないようにします。
open クラスのサブクラス化またはメンバーのオーバーライドを許可します。
operator 関数が演算子をオーバーロードしているか、または規約を実装( ''implementing a convention'' )しているかをマークします。
out 型パラメータを共変( ''covariant'' )としてマークします。
override スーパークラスのメンバーのオーバーライドとしてメンバーにマークを付けます。
private 現在のクラスまたはファイル内で宣言が可視化( as visible )されるようにマークします。
protected 現在のクラスとそのサブクラスで宣言が可視化されるようにマークします。
public 宣言がどこでも可視化されるようにマークします。
reified インライン関数の型パラメーター( ''type parameter'' )を、実行時にアクセス可能なものとしてマークします。
sealed シールされたクラス（ ''sealed class'' ; サブクラス化が制限されたクラス）を宣言します。
suspend 関数やラムダをサスペンド（コルーチンとして使用可能）するようにマークします。
tailrec 関数を末尾再帰としてマークします (コンパイラーが再帰を反復に置換えることができます)。
vararg パラメーターに可変数の引数を渡せるようにします。
以下の識別子は，コンパイラーが特定の文脈で定義したもので、他の文脈では通常の識別子として使用することができます[https://kotlinlang.org/docs/keyword-reference.html#special-identifiers Special identifiers﻿﻿]。
このような識別子を特殊識別子( ''Special identifiers﻿﻿'' )と呼びます。
field プロパティーアクセサー( ''a property accessor'' )の内部で、プロパティーのバッキングフィールドを参照するために使用します。
it ラムダの内部で暗黙のうちにパラメーターを参照するために使用されます。
Kotlinは以下の演算子( ''Operators'' )や特殊特殊シンボル( ''special symbols﻿'' )をサポートしています[https://kotlinlang.org/docs/keyword-reference.html#operators-and-special-symbols Operators and special symbols﻿﻿]。
 算術演算子
* は、vararg パラメーターに配列を渡す場合にも使用されます。
パラメーターのデフォルト値を指定するために使用されます。
 拡張された代入演算子。
 インクリメントおよびデクリメント演算子
  論理 'and', 'or', 'not' 演算子 (ビット演算には、対応する infix 関数を使用してください)。
 等号演算子 (非プリミティブ型では equals() に変換される)。
 参照系等号演算子( ''referential equality operators'' )
 比較演算子 (非プリミティブ型に対する compareTo() の呼出しに変換されます)
 インデックス付きアクセス演算子（getとsetの呼び出しに変換されます）
!! 式が非nullであることを保証します。
?. 安全な呼び出しを行います（レシーバーが非NULLの場合、メソッドを呼び出したり、プロパティにアクセスしたりします）。
?: 左辺の値がNULLの場合、右辺の値を取ります（エルビス演算子）。
:: メンバー参照またはクラス参照を作成します。
.. 範囲( ''a range'' )を生成します。
: 宣言の中で、名前と型を分離します。
? 型をnull可能( ''as nullable'' )であるとマークします。
ラムダ式のパラメーターと本体を分離します。
関数型のパラメーターと戻値の型宣言を分離します。
when式の条件分岐と本体を分離します。
アノテーションを導入します。
ループラベルを導入または参照します。
ラムダ・ラベルを導入または参照します。
外部スコープから 'this' 式を参照します。
外部のスーパークラスを参照します。
; 同じ行にある複数のステートメントを区切ります。
$ 文字列テンプレート内で変数または式を参照します。
ラムダ式で使用しないパラメーターを置換えます。
構造化宣言の未使用のパラメーターを代入します。
Kotlin標準ライブラリー( ''Kotlin Standard Library'' )は、以下のような機能を提供します[https://kotlinlang.org/api/latest/jvm/stdlib/ Kotlin Standard Library]。
慣用的なパターン（let、apply、use、synchronizedなど）を実装した高階関数。
コレクション（eager）やシーケンス（lazy）に対するクエリ操作を提供する拡張関数。
ファイル、IO、スレッドを便利に扱うための JDK クラスの拡張。
Kotlin標準ライブラリーはKotlin自身で書かれています。
ディフォルトインポートされるパッケージ
kotlin.annotation.*
Kotlinには、Arrayから始まり、Iterable, Collection, List, Set, Mapなどのコレクション型が豊富に用意されています。これらは主に kotlin.collections パッケージで提供されており、ディフォルトインポートなので追加のインポートなしで利用できます[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/ Package kotlin.collections]。
Iterable インターフェースは、Kotlinの標準ライブラリで使用される反復可能なコレクションの基本的なインターフェースです。このインターフェースは、コレクションが要素の反復処理を可能にするために必要な機能を提供します。
以下に、Iterable インターフェースの主な要素と使用法を示します：
iterator メソッドは、コレクション内の要素を反復処理するためのイテレータを返します。
イテレータは、hasNext() メソッドで次の要素の有無を確認し、next() メソッドで次の要素を取得します。
val iterable: Iterable = listOf(1, 2, 3, 4, 5)
// for ループを使用した反復処理
for (element in iterable) {
    println(element)
}
// forEach 関数を使用した反復処理
iterable.forEach { element ->
    println(element)
}
val iterable: Iterable = listOf(1, 2, 3, 4, 5)
// forEach 関数を使用した反復処理
iterable.forEach { element ->
    println(element)
}
Iterable は多くの Kotlin のコレクションで使用されます。例えば、List、Set、Map などが Iterable インターフェースを実装しています。
// List は Iterable インターフェースを実装している
val list: Iterable = listOf(1, 2, 3, 4, 5)
// for ループを使用した反復処理
for (element in list) {
    println(element)
}
Iterable インターフェースは、Kotlinでコレクションを扱う際に非常に重要であり、様々な反復処理操作を可能にします。
Collection インターフェースは、Kotlinの標準ライブラリで提供されるコレクション型の基本インターフェースの一つです。このインターフェースは、複数の要素を保持するデータ構造を表現し、それらの要素に対する基本的な操作を提供します。
以下に、Collection インターフェースの主な特徴と使用法を示します：
Collection インターフェースは、要素の追加や削除といった基本的な操作を提供します。
val collection: Collection = listOf(1, 2, 3, 4, 5)
// 要素の追加はサポートされない
// collection.add(6)  // エラー
// 要素の削除
val modifiedCollection = collection - 3
println(modifiedCollection)  // [1, 2, 4, 5]
val collection: Collection = listOf(1, 2, 3, 4, 5)
// 要素の存在確認
val containsThree = collection.contains(3)
println(containsThree)  // true
val collection: Collection = listOf(1, 2, 3, 4, 5)
// コレクションのサイズ取得
val size = collection.size
println(size)  // 5
val collection: Collection = listOf(1, 2, 3, 4, 5)
// forEach 関数を使用した反復処理
collection.forEach { element ->
    println(element)
}
val collection1: Collection = listOf(1, 2, 3, 4, 5)
val collection2: Collection = 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]
Collection インターフェースは、Kotlinのコレクションの基本的な機能を提供し、様々な種類のコレクションがこれを実装しています。これにより、異なる種類のコレクションを一貫して扱うことができます。
Listは、要素数が固定で要素の値を変更できないコレクションです。
[https://paiza.io/projects/vmrFKnU_3qj5d04hJPmuWA?language=kotlin List()を使ったListの生成]:
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("")
}
実行結果:
list::class.simpleName ⇒ ArrayList
list[0]::class.simpleName ⇒ Int
0 1 2 3 4 
list2[0]::class.simpleName ⇒ String 
0 1 4 9 16 
List()はListのコンストラクターで、引数として要素数をとり、ブロックが初期化式になります。
[https://paiza.io/projects/D17B4n-k7dGdKdxlrw5m2Q?language=kotlin listOf()を使ったListの生成]
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("")
}
実行結果:
ArrayList
Int
1 9 3 5  
1 9 3 5 
ListOf()は可変長引数の関数で、引数が生成されるListの要素になります。
Listの要素の型は、型強制できる最小公倍数的な方になります（例えば Int と Long が混在していたら Long）。
fun main() {
    // ArrayListを使ったListの生成
    val arrayList = ArrayList()
    arrayList.add("Kotlin")
    arrayList.add("Java")
    arrayList.add("Python")
    
    println("${arrayList::class.simpleName}")
    
    for (lang in arrayList) {
        println(lang)
    }
}
実行結果:
ArrayList
Kotlin
Java
Python
上記の例では、ArrayList を使ってListを生成しています。ArrayListは要素の順序が保持され、可変長の動的な配列を表現します。add メソッドを使用して要素を追加することができます。
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("")
}
実行結果
ArrayList
1 2 3 4 5 6 
mutableListOf() を使って MutableList を生成し、add メソッドを使用して要素を追加しています。MutableListは要素の変更が可能なListです。
これらの例から分かるように、Kotlinのコレクションは型安全で、読み取り専用と可変なコレクションの違いが明確になっています。リストの他にも、SetやMapも用意されており、それぞれの特徴に応じて適切なものを選択できます。
kotlin.collections パッケージのコレクションクラスや関連機能は、さまざまなプログラミングシナリオで利用されます。以下は、kotlin.collections の主なユースケースのいくつかです：
データの格納と操作: List、Set、Mapなどのコレクションは、データを効果的に格納し、操作するために使用されます。例えば、リストは順序つきのデータの集合を表現し、セットは一意な要素の集合を表現します。
反復処理とフィルタリング: Iterable インターフェースを使用してコレクションを反復処理し、必要なデータを抽出することができます。これは、フィルタリングや変換などの操作に役立ちます。
不変性と可変性の管理: List と MutableList、Set と MutableSet、Map と MutableMap など、各コレクションには不変なバージョンと可変なバージョンがあります。これにより、不変性を保ちながら必要に応じてデータを変更できます。
関数型プログラミング: コレクション操作には関数型プログラミングのアプローチがあり、filter、map、reduce などの関数を使用してデータを処理できます。
以下は、これらのユースケースの簡単な例です：
// データの格納と操作
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 }
これらの例は一部の機能を示すものであり、kotlin.collections のコレクションは、さまざまなプログラミングニーズに対応する強力なツールセットを提供します。
kotlin.collections を使用する際のベストプラクティスはいくつかあります。以下にいくつか挙げてみましょう：
// 不変なリスト
val immutableList = listOf(1, 2, 3)
// 不変なセット
val immutableSet = setOf("apple", "orange", "banana")
// 不変なマップ
val immutableMap = mapOf(1 to "one", 2 to "two", 3 to "three")
// Nullableなリスト
val nullableList: List? = // ...
// Nullableなセット
val nullableSet: Set? = // ...
// Nullableなマップ
val nullableMap: Map? = // ...
val numbers = listOf(1, 2, 3, 4, 5)
val evenSquared = numbers
    .filter { it % 2 == 0 }
    .map { it * it }
    .sum()
// 要素の順序が重要
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")
これらのベストプラクティスは、コードの品質、パフォーマンス、保守性を向上させるのに役立ちます。使用ケースによって最適なアプローチを選択することが重要です。
kotlin.comparisons.*
kotlin.io.*
kotlin.ranges.*
kotlin.sequences.*
kotlin.text.*
----
[TODO:Rangeはコレクションではないので再分類が必要]
println((1..5).javaClass.kotlin)の結果が示す通り、範囲リテラル1..5はclass kotlin.ranges.IntRangeです。
コレクションは、Ranges以外にも、Sequences・Ranges・Lists・Arrays・Sets・Mapsなどがあります。これは網羅していませんし、上記の forプロトコルに従ったクラスを作れば、ユーザー定義のコレクションも作成できます。
[https://paiza.io/projects/zw6faeOmsjuZVF3D3WY_-g?language=kotlin 様々なコレクション]:
fun main(args: Array) {
  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)
  }
}
実行結果:
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
二重のforループで、外周はコレクションのコレクションで、内周は個々のコレクションの要素をイテレーションしています。
Kotlinの標準ライブラリーにあるrepeat関数は、定数回の繰返しが必要な時に便利です[https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/repeat.html repeat - Kotlin Programming Language]。
[https://paiza.io/projects/LHnnORcAjUhvb_qW9ysIvw?language=kotlin repeat関数]:
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
                }
            }
        }
    }
}
実行結果:
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)
itは、暗黙のループ変数です。
多重ループでは、ループ変数の名前が固定では都合が悪いので、ブロックの先頭で識別子名 -> とすることで明示的に名前をつけることができます。
多重ループを run 関数で括ることで多重ループからの大域脱出を実現しています。
repeat関数もそうですが、Kotlinにはブロックを受取る関数（やメソッド）があります。
[https://paiza.io/projects/AZT2juUGcUnyjqgDx4G85g?language=kotlin ブロックを受取る関数]:
fun main(args: Array) {
    val ary = Array(5) { 2 * it + 1 }
    ary.forEach{ println(it) }
    println(ary.map{ it.toString() }.joinToString(" "))
    println(ary.reduce{ sum, el -> sum  + el })
}
実行結果:
1
3
5
7
9
1 3 5 7 9 
25
ブロックで配列の初期化を行う場合、itは順位になります。
コレクションのforEachメソッドもブロックを取ります。
コレクションのreduceメソッドもブロックを取りますが、累算値と要素の2つを取るので、名付けが必要です。
このように、ブロックを取るメソッドを使うとコレクションに関する操作を簡素に書けます。
Kotlinは、言語レベルでコルーチンをサポートし、機能の大部分をライブラリに委ねることで、この問題を柔軟に解決しています。
Shell:
$ 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!
Kotlin Script では、.jar を生成せず、そのままコードが実行されます。
また、main 関数をエントリーポイントはぜず、スクリプトの書かれた順に評価します。
Shell:
% cat hello.kts
println("Hello, World!")
% kotlinc -script hello.kts
Hello, World!
% _
ビルドツールの Gradle では、従来は Groovy がビルド構成ファイルに使われていましたが、Kotlin Script への移行が進んでいます。
ワンライナー:
% kotlin -e 'repeat(3){println("Hello!($it)")}'
Hello!(0)
Hello!(1)
Hello!(2)
% _