今すぐ始めるKotlin：開発環境構築から基本まで

By /

今すぐ始めるKotlin：開発環境構築から基本まで

はじめに：Kotlinの世界へようこそ

プログラミングの世界は日々進化しており、新しい言語や技術が次々と登場しています。その中でも、近年特に注目を集め、多くの開発者から支持されている言語があります。それが Kotlin です。

Kotlinは、JetBrains社によって開発された静的型付けのプログラミング言語です。Java仮想マシン（JVM）上で動作するだけでなく、JavaScriptへのコンパイルやネイティブコードへのコンパイルも可能です。この高い互換性と柔軟性により、Androidアプリ開発、サーバーサイド開発、デスクトップアプリケーション開発、さらにはクロスプラットフォーム開発など、非常に幅広い分野で活用されています。

なぜ今、Kotlinを学ぶべきなのでしょうか？その理由はいくつかあります。

  • 簡潔さと表現力: KotlinはJavaと比較してコード量が少なく、より expressive（表現力豊か）にコードを書くことができます。冗長な記述が減り、コードが読みやすく、書きやすくなります。
  • 安全性: 特に「ヌル安全」という強力な機能により、多くのプログラマーを悩ませる NullPointerException を根本から排除できます。これは開発中のバグを減らし、アプリケーションの安定性を高める上で非常に重要です。
  • Javaとの高い互換性: KotlinはJVM上で動作するため、既存のJavaライブラリやフレームワークをそのまま利用できます。JavaプロジェクトにKotlinのコードを少しずつ導入することも容易です。
  • Android開発の公式言語: 2017年にGoogleがKotlinをAndroid開発の公式言語として発表して以来、Android開発コミュニティではKotlinがデファクトスタンダードになりつつあります。最新のAndroid開発手法やライブラリはKotlinでの利用を強く推奨しています。
  • 成長するエコシステム: サーバーサイドフレームワーク（Ktor、Spring Bootなど）や、Webフロントエンド（Kotlin/JS）、デスティブ（TornadoFX）、マルチプラットフォーム開発（Kotlin Multiplatform Mobile, Kotlin Multiplatform）など、Kotlinのエコシステムは急速に拡大しています。

この記事は、「Kotlinに興味を持ったけれど、何から始めれば良いか分からない」「プログラミングは初めて、あるいは他の言語の経験はあるけれど、Kotlinの第一歩を踏み出したい」という方に向けて書かれています。Kotlinの開発環境の構築から始め、基本的な文法、変数、データ型、制御構造、関数、そしてクラスとオブジェクトといった、Kotlinプログラミングの土台となる要素を、分かりやすく丁寧に解説していきます。

この記事を読み終える頃には、あなたはKotlinでのプログラミングを始めるための確固たる基盤を築いていることでしょう。さあ、Kotlin学習の旅を始めましょう！

ステップ１：Kotlin開発環境を構築する

Kotlinでプログラムを書くためには、まず開発環境を準備する必要があります。ここでは、最も一般的で推奨される統合開発環境（IDE）である IntelliJ IDEA を使用した環境構築方法を詳しく説明します。IntelliJ IDEAはKotlinの開発元であるJetBrains社が提供しており、Kotlinのコード補完、エラーチェック、デバッグなどの機能が非常に強力です。

必要なもの:

  1. IntelliJ IDEA: Kotlin開発に最適なIDEです。無料版の「Community Edition」で十分な機能が利用できます。
  2. JDK (Java Development Kit): KotlinはJVM上で動作するため、Java実行環境が必要です。IntelliJ IDEAにはJDKが同梱されていることが多いですが、別途インストールが必要な場合もあります。

IntelliJ IDEAのダウンロードとインストール:

  1. IntelliJ IDEA公式サイトにアクセス:
    ウェブブラウザで以下のURLにアクセスしてください。
    https://www.jetbrains.com/ja-jp/idea/

  2. ダウンロード:
    公式サイトのダウンロードページに移動し、「Community」版を探してダウンロードボタンをクリックします。OS（Windows, macOS, Linux）を選択するオプションがある場合は、お使いのOSに合ったものを選択してください。

  3. インストーラーの実行:
    ダウンロードしたファイル（Windowsなら .exe、macOSなら .dmg、Linuxなら .tar.gz）を実行します。

    • Windows:
      インストーラーの指示に従って進めます。「Next」をクリックし、インストール場所を選択します。インストールオプションで「Create Desktop Shortcut」や「Add ‘Open Folder as Project'”」などにチェックを入れると便利です。また、「Update PATH variable」にチェックを入れるとコマンドラインからIntelliJ IDEAを起動できるようになります（必須ではありません）。「Install」をクリックしてインストールを開始します。インストール完了後、「Run IntelliJ IDEA Community Edition」にチェックを入れてFinishをクリックすると、IDEが起動します。

    • macOS:
      .dmg ファイルを開くと、IntelliJ IDEAのアプリケーションアイコンが表示されます。このアイコンを「Applications」フォルダにドラッグ＆ドロップしてください。これでインストールは完了です。「Applications」フォルダからIntelliJ IDEAを起動できます。初めて起動する際には、セキュリティの警告が表示されることがありますが、許可して開いてください。

    • Linux:
      ダウンロードした .tar.gz ファイルを展開し、展開されたディレクトリ内の bin フォルダにある idea.sh スクリプトを実行します。より簡単に起動するために、デスクトップエントリを作成することもできます。

  4. 初回起動時の設定:
    IntelliJ IDEAを初めて起動すると、利用規約の同意やUIテーマの選択、プラグインの設定などを求められる場合があります。基本的にデフォルト設定で問題ありません。キーマップなど、使い慣れた設定があればカスタマイズしても良いでしょう。

    IntelliJ IDEAにはKotlinプラグインが標準でバンドルされているため、別途プラグインをインストールする必要はありません。

JDKの確認とインストール (必要であれば):

IntelliJ IDEAの新しいバージョンは、多くの場合、同梱のJDKを使用するように設定されます。しかし、明示的にJDKのインストールや設定が必要な場合もあります。

  1. JDKのダウンロード:
    Oracle JDKやOpenJDKなど、いくつかの選択肢があります。無料で利用できるOpenJDKがおすすめです。例えば、Adoptium TemurinやAmazon Correttoなどがあります。ここではAdoptium Temurinを例に挙げます。
    Adoptium公式サイトにアクセス: https://adoptium.net/
    お使いのOSとアーキテクチャに合ったJDKをダウンロードします（通常はLatest LTS Releaseの「Temurin X JDK」というものを選択します。Xはバージョン番号で、Java 11以降であればKotlin開発には問題ありません）。

  2. JDKのインストール:
    ダウンロードしたインストーラーを実行し、指示に従ってインストールします。環境変数 JAVA_HOME の設定を求められる場合がありますが、最近のインストーラーは自動で設定してくれることも多いです。

  3. IntelliJ IDEAでのJDK設定:
    IntelliJ IDEAを起動し、Welcome画面またはメニューからプロジェクトを開いた状態で、「File」 -> 「Project Structure…」を選択します。
    「Project Settings」の「Project」を選択し、「SDK」のドロップダウンリストを確認します。インストールしたJDKが表示されていればそれを選択します。表示されていない場合は、「Add SDK」 -> 「JDK」を選択し、インストールしたJDKのパスを指定します。
    同様に、「Platform Settings」の「SDKs」でもインストール済みのJDKを確認・設定できます。

これで、Kotlin開発を始めるための環境が整いました！

ステップ２：最初のKotlinプロジェクトを作成し、「Hello, World!」を実行する

開発環境が整ったので、実際にKotlinのコードを書いて実行してみましょう。IntelliJ IDEAを使って新しいKotlinプロジェクトを作成し、おなじみの「Hello, World!」を表示するプログラムを作成します。

  1. IntelliJ IDEAを起動:
    インストールしたIntelliJ IDEAを起動します。

  2. 新しいプロジェクトを作成:
    Welcome画面が表示されたら、「New Project」をクリックします。
    プロジェクトが開いている場合は、メニューバーから「File」-> 「New」 -> 「Project…」を選択します。

  3. プロジェクトタイプと設定の選択:
    「New Project」ウィンドウが表示されます。

    • 左側のリストから「New Project」を選択します（テンプレートから作成するのではなく、ゼロから新しいプロジェクトを作成する場合）。
    • プロジェクトの名前（Name）を入力します。例えば MyFirstKotlinProject としましょう。
    • プロジェクトの保存場所（Location）を指定します。
    • 「Language」で「Kotlin」を選択します。
    • 「Build system」で「Gradle Kotlin」を選択することをおすすめします（より本格的なプロジェクト管理に適しています）。シンプルな単一ファイルのスクリプト実行だけであれば「IntelliJ」でも構いませんが、ここではGradleを選びます。
    • 「JDK」で、前述のステップで設定したJDKが選択されていることを確認します。
    • 「Add sample code」にチェックを入れると、main関数を含む簡単なサンプルコードが自動的に生成されます。学習のためにはチェックを入れておくと便利です。
    • 他の設定はデフォルトのままで構いません。

  4. プロジェクトの作成:
    「Create」ボタンをクリックします。IntelliJ IDEAが新しいプロジェクトを作成し、必要なファイルをダウンロード（Gradleを選択した場合）します。これには少し時間がかかる場合があります。

  5. プロジェクト構造の確認:
    プロジェクトが作成され、IntelliJ IDEAのメインウィンドウが表示されます。左側の「Project」ビューを確認してください。
    通常、以下のような構造になっています。
    MyFirstKotlinProject
    ├── .gradle/
    ├── .idea/
    ├── gradle/
    ├── src/
    │ └── main/
    │ └── kotlin/
    │ └── Main.kt <-- ここにコードを書きます
    ├── build.gradle.kts <-- Gradleの設定ファイル (Kotlin DSL)
    ├── gradlew
    ├── gradlew.bat
    └── settings.gradle.kts
    「src/main/kotlin」フォルダの中に、Main.kt というファイルが作成されているはずです（「Add sample code」にチェックを入れた場合）。

  6. Main.kt ファイルを開く:
    「Project」ビューで src -> main -> kotlin -> Main.kt をダブルクリックして開きます。
    「Add sample code」にチェックを入れた場合、以下のようなコードが書かれています。

    kotlin
    fun main() {
    println("Hello World!")
    }

  7. コードの確認と実行:
    このコードは、main という名前の関数を定義しています。Kotlinプログラムのエントリーポイント（最初に実行される場所）は、通常この main 関数です。
    println() は、引数として渡された文字列を標準出力（コンソール）に表示する関数です。ここでは “Hello World!” という文字列を表示しています。

    このコードを実行するには、いくつかの方法があります。
    * エディタのガター（行番号の横の領域）にある緑色の再生ボタンをクリック: fun main() の左側に表示される緑色の再生ボタン（または三角形）をクリックし、「Run ‘MainKt’」を選択します。
    * メインメニューから実行: 「Run」-> 「Run ‘MainKt’」を選択します。
    * Shift + F10 キーを押す: （デフォルトのショートカットキー）

  8. 実行結果の確認:
    コードを実行すると、IntelliJ IDEAの下部に「Run」ツールウィンドウが表示され、プログラムの出力が表示されます。

    Hello World!
    と表示されていれば成功です！これで、Kotlinプログラムを開発し、実行するための基本的なワークフローを体験しました。

ステップ３：Kotlinの基本的な文法と要素を学ぶ

開発環境の構築と最初のプログラム実行ができたところで、いよいよKotlinの基本的な文法を学んでいきましょう。ここでは、Kotlinのコードを書く上で必要不可欠な要素について解説します。

3.1. コメント

プログラムの中に、実行には影響しない覚え書きや説明などを記述したい場合があります。そのようなときに使用するのがコメントです。Kotlinでは2種類のコメントの書き方があります。

  • 単一行コメント: // から行末までがコメントになります。

    “`kotlin
    // これは単一行コメントです

    fun main() {
    println(“Hello!”) // この行の後半もコメントです
    }
    “`

  • 複数行コメント: /* から */ の間がコメントになります。複数行にわたるコメントや、コードの一部を一時的に無効にしたい場合などに使用します。

    “`kotlin
    /
    これは
    複数行の
    コメントです
    /

    fun main() {
    /
    println(“この行はコメントアウトされています”)
    /
    println(“Hello!”)
    }
    “`
    複数行コメントはネスト（入れ子）にすることも可能です。

3.2. パッケージとインポート

Kotlinのソースファイルは、通常パッケージに属します。パッケージは、関連するクラスや関数などをまとめるための仕組みで、名前の衝突を防ぐ役割も果たします。

ファイルの先頭に package キーワードを使ってパッケージ名を宣言します。

“`kotlin
package com.example.myapp

fun main() {
// …
}
“`
パッケージ名を省略した場合、そのファイルはデフォルトパッケージに属します。しかし、実際の開発では名前の衝突を避けるために明示的なパッケージ名を付けるのが一般的です。

他のパッケージで定義されているクラスや関数を利用したい場合は、import キーワードを使ってインポートします。

“`kotlin
package com.example.myapp

// Kotlinの標準ライブラリからListクラスをインポート
import kotlin.collections.List

// Javaの標準ライブラリからArrayListクラスをインポート
import java.util.ArrayList

fun main() {
val list: List = ArrayList()
// …
}
``
Kotlinの標準ライブラリにある多くのクラスや関数、あるいはjava.lang` パッケージにあるクラスなどは、明示的にインポートしなくても利用できます。

3.3. main 関数

Kotlinアプリケーションのエントリーポイント（プログラムの実行が開始される場所）は、main という名前の関数です。main 関数はトップレベル（どのクラスにも属さないファイル直下）に定義されます。

main 関数は、引数なしで定義することも、コマンドライン引数を受け取るように定義することもできます。

  • 引数なしの main 関数:

    kotlin
    fun main() {
    println("引数なしのmain関数")
    }

  • コマンドライン引数を受け取る main 関数: Array<String> 型の引数を1つ取ります。

    kotlin
    fun main(args: Array<String>) {
    println("引数を取るmain関数")
    if (args.isNotEmpty()) {
    println("渡された引数:")
    for (arg in args) {
    println(arg)
    }
    } else {
    println("引数は渡されませんでした。")
    }
    }
    通常、簡単なスクリプトや引数が必要ないプログラムでは引数なしの main 関数を使用します。

3.4. 文と式

プログラミング言語には「文（statement）」と「式（expression）」という概念があります。

  • 文: 何らかの処理を実行する単位です。特定の処理を実行しますが、それ自体が値を持ちません。
    例: 変数宣言 (val x = 10)、代入 (x = 20)、ループ (for (...) { ... }) など。

  • 式: 何らかの値を評価して生成する単位です。計算結果や値そのものを持ちます。
    例: 算術演算 (a + b)、関数呼び出し（戻り値がある場合）、リテラル値 (10, "Hello") など。

多くの言語では、if や when (Javaの switch に相当) は文ですが、Kotlinでは if や when は式としても使用できます。 これはKotlinの大きな特徴の一つで、より簡潔なコードを書くのに役立ちます。

例: if を式として使用する場合

“`kotlin
fun main() {
val a = 10
val b = 20

// if を式として使用し、その結果を変数に代入
val max = if (a > b) {
    println("a is larger")
    a // if ブロックの最後の式が結果となる
} else {
    println("b is larger or equal")
    b // else ブロックの最後の式が結果となる
}

println("Max is $max") // 出力例: b is larger or equal, Max is 20

}
``
この例では、ifブロックとelseブロックの最後の行の式（それぞれaとb）がif式全体の評価結果となり、それがmax` 変数に代入されます。

同様に、when も式として利用できます。

ステップ４：変数とデータ型を学ぶ

プログラムでは、データを一時的に保存したり、処理したりするために変数を使用します。Kotlinには変数を宣言する方法が2種類あり、また様々なデータ型が用意されています。

4.1. var と val：ミュータブル変数とイミュータブル変数

Kotlinで変数を宣言するには、var または val キーワードを使用します。この2つには重要な違いがあります。

  • var (variable): 変更可能な変数を宣言します。宣言後に別の値を再代入できます。

    “`kotlin
    var count = 10 // count は Int 型と推論される
    count = 15 // 後から別の値を代入できる

    var message = “Hello” // message は String 型と推論される
    message = “World” // 後から別の値を代入できる
    “`

  • val (value): 読み取り専用の（イミュータブルな）変数を宣言します。宣言時に初期値を代入すると、その後は別の値を再代入することはできません。Javaにおける final 変数に似ています。

    “`kotlin
    val PI = 3.14159 // PI は Double 型と推論される
    // PI = 3.0 // エラー！ val は再代入できない

    val name = “Alice” // name は String 型と推論される
    // name = “Bob” // エラー！ val は再代入できない
    ``
    ただし、    val` で宣言された変数が参照するオブジェクトの中身がミュータブルな場合は、そのオブジェクトの状態は変更可能です。

    kotlin
    val mutableList = mutableListOf("Apple", "Banana") // mutableListOf は変更可能なリストを作成
    mutableList.add("Cherry") // mutableList 自体は再代入できないが、リストの中身は変更できる
    println(mutableList) // 出力: [Apple, Banana, Cherry]

どちらを使うべきか？: Kotlinでは、可能な限り val を使うことが推奨されています。値が変更されないことで、コードの理解が容易になり、意図しない値の変更によるバグを防ぐことができます。本当に値が変更される必要がある場合にのみ var を使用しましょう。これはKotlinプログラミングにおける重要なベストプラクティスです。

4.2. 型の推定

Kotlinでは、多くの場面で変数の型を明示的に指定する必要がありません。初期値からコンパイラが自動的に型を判断してくれる型の推定（Type Inference）機能があるからです。

kotlin
val age = 30 // 初期値が整数のリテラルなので、age は Int 型と推論される
val price = 19.99 // 初期値が小数を含むリテラルなので、price は Double 型と推論される
val isActive = true // 初期値が真偽値リテラルなので、isActive は Boolean 型と推論される
val city = "Tokyo" // 初期値が文字列リテラルなので、city は String 型と推論される
もちろん、明示的に型を指定することもできます。これは特に、型推定が難しい場合や、コードの可読性を高めたい場合に有用です。型は変数名の後ろにコロン : を付け、続けて型名を記述します。

kotlin
val count: Int = 10
val temperature: Double = 25.5
val isFinished: Boolean = false
val greeting: String = "Hello, Kotlin!"

初期値を指定せずに変数を宣言する場合は、型を明示的に指定する必要があります。

kotlin
var result: Int // 初期値を指定しない場合は型が必要
result = 100 // 後で値を代入

4.3. 基本的なデータ型

Kotlinには、数値、文字、真偽値などを扱うための基本的なデータ型が組み込まれています。これらの型は、JVM上で動作する際にはJavaのプリミティブ型（int, double, booleanなど）やそのラッパー型（Integer, Double, Booleanなど）に対応付けられますが、Kotlinでは一貫したオブジェクトとして扱えます。

  • 数値型:

    • 整数型: サイズの小さい順に Byte, Short, Int, Long があります。

      • Byte: -128 から 127 (-2^7 から 2^7 – 1)
      • Short: -32768 から 32767 (-2^15 から 2^15 – 1)
      • Int: -2,147,483,648 から 2,147,483,647 (-2^31 から 2^31 – 1)。最も一般的に使用される整数型です。
      • Long: -9,223,372,036,854,775,808 から 9,223,372,036,854,775,807 (-2^63 から 2^63 – 1)。大きな整数を扱う場合に使用します。リテラルに L を付けてLong型であることを明示できます（必須ではありませんが推奨）。

      kotlin
      val byteValue: Byte = 10
      val shortValue: Short = 100
      val intValue: Int = 100000
      val longValue: Long = 10000000000L // L を付けてLong型であることを明示
      val inferredLong = 1234567890123 // Int の範囲を超える場合は自動的に Long に推論される

    • 浮動小数点型: 小数を扱うための型です。

      • Float: 32ビット浮動小数点数。精度がDoubleより低いですが、メモリ効率が良いです。リテラルに f または F を付けてFloat型であることを明示します。
      • Double: 64ビット浮動小数点数。最も一般的に使用される浮動小数点型で、小数点を含む数値リテラルはデフォルトでDouble型と推論されます。

      kotlin
      val floatValue: Float = 3.14f // f を付けてFloat型であることを明示
      val doubleValue: Double = 2.718 // Double型と推論される
      val inferredDouble = 1.0 // Double型と推論される

  • ブール型: 真偽値を表す型です。

    • Boolean: true または false のいずれかの値を持ちます。

    kotlin
    val isKotlinFun: Boolean = true
    val isJavaBetter: Boolean = false

  • 文字型: 単一の文字を表す型です。

    • Char: シングルクォーテーション (') で囲んで表現します。

    kotlin
    val initial: Char = 'K'
    val newLine: Char = '\n' // エスケープシーケンスも使用可能

  • 文字列型: 文字の並びを表す型です。

    • String: ダブルクォーテーション (") で囲んで表現します。文字列はイミュータブル（immutable、一度作成すると変更できない）です。

    kotlin
    val greeting: String = "Hello, Kotlin!"
    val message = "Learning String" // String型と推論される
    Kotlinの文字列には、改行や特殊文字を含むことができるトリプルクォート文字列 """...""" もあります。

    “`kotlin
    val multiLineString = “””
    この文字列は
    複数行にわたります。
    改行もそのまま表現できます。
    “””.trimIndent() // trimIndent() で先頭のインデントを除去

    println(multiLineString)
    “`

  • 型変換: 異なる数値型の間で演算を行う場合、大きい方の型に自動的に変換されることがあります（暗黙の型変換）。しかし、小さい型から大きい型への変換以外では、通常明示的な型変換が必要です。各数値型は、他の数値型に変換するためのメソッド（例: toInt(), toDouble(), toString() など）を持っています。

    “`kotlin
    val intValue = 100
    val longValue: Long = intValue.toLong() // IntからLongへ明示的に変換
    val doubleValue: Double = intValue.toDouble() // IntからDoubleへ変換

    val stringValue: String = intValue.toString() // IntからStringへ変換

    val numberString = “123”
    val intFromString: Int = numberString.toInt() // StringからIntへ変換
    // val invalidNumberString = “abc”
    // val intFromInvalidString: Int = invalidNumberString.toInt() // 実行時にエラー (NumberFormatException)
    “`

4.4. ヌル安全 (Null Safety)

Kotlinの最も強力で評価されている機能の一つが「ヌル安全」です。多くのプログラミング言語では、変数に null (何も参照していない状態) を代入できますが、これは実行時に NullPointerException という例外を引き起こす大きな原因となります。Kotlinは、この問題をコンパイル時に検出し、防ぐための仕組みを持っています。

  • Non-nullable型とNullable型:
    Kotlinでは、変数の型はデフォルトで Non-nullable です。つまり、その型の変数には null を代入できません。

    kotlin
    var name: String = "Alice"
    // name = null // コンパイルエラー！ String型はnullを許容しない
    もし変数に null を代入する可能性がある場合は、型の後ろに ? を付けて Nullable 型として宣言する必要があります。

    “`kotlin
    var nullableName: String? = “Bob”
    nullableName = null // OK. String? 型はnullを許容する

    var age: Int = 30
    // age = null // コンパイルエラー！ Int型はnullを許容しない

    var nullableAge: Int? = 40
    nullableAge = null // OK. Int? 型はnullを許容する
    “`

  • Nullable型を扱う:
    Nullable型の変数にアクセスする際は、その値が null でないことを保証する必要があります。Kotlinは、Nullableな変数に直接アクセスしようとするとコンパイルエラーにします。

    kotlin
    var nullableMessage: String? = "Hello"
    // println(nullableMessage.length) // コンパイルエラー！ nullableMessageがnullかもしれない
    Nullableな値を安全に扱うためのいくつかの方法があります。

    1. セーフコール演算子 ?.:
      Nullableな変数が null でない場合にのみ、その後に続く操作を実行します。もし変数が null なら、操作はスキップされ、式全体の評価結果は null となります。

      “`kotlin
      var nullableMessage: String? = “Hello”
      println(nullableMessage?.length) // 出力: 5 (nullでないのでlengthが評価される)

      nullableMessage = null
      println(nullableMessage?.length) // 出力: null (nullなのでlengthは評価されず、式全体がnullとなる)
      “`
      複数のセーフコールをチェーンさせることも可能です。

      kotlin
      val person: Person? = getPerson() // Personクラスがあると仮定
      val country: String? = person?.address?.country // personまたはaddressがnullなら全体がnull

    2. Elvis演算子 ?::
      Nullableな式の値が null でない場合はその値を使い、null の場合は指定したデフォルト値を返す演算子です。

      “`kotlin
      val name: String? = null
      val displayName = name ?: “ゲスト” // nameがnullなので”ゲスト”が代入される
      println(displayName) // 出力: ゲスト

      val length: Int = nullableMessage?.length ?: 0 // nullableMessageがnullなら0を返す
      “`
      Elvis演算子は、Nullabilityチェックとデフォルト値の設定を簡潔に書くのに非常に便利です。

    3. !! 演算子 (非ヌル表明):
      「この変数は絶対に null ではない」とコンパイラに伝えるための演算子です。ただし、もし実際には null だった場合、実行時に NullPointerException が発生します。これはKotlinのヌル安全性を意図的に迂回する危険な方法であり、本当に null でないという確信がある場合にのみ、自己責任で使用してください。

      “`kotlin
      var nonNullMessage: String? = “これはnullではないはず”
      println(nonNullMessage!!.length) // もしnonNullMessageがnullだったらここでNullPointerExceptionが発生

      // nonNullMessage = null
      // println(nonNullMessage!!.length) // この行を実行するとNullPointerExceptionが発生する
      ``!!` 演算子は、Nullabilityに関する情報を失わせるため、可能な限り避けるべきです。

    4. if による null チェック:
      従来通り、if 文を使って null であるかどうかをチェックすることもできます。Kotlinのスマートキャスト機能により、if (variable != null) のブロック内では、その変数は自動的にNon-nullable型として扱われます。

      “`kotlin
      var greeting: String? = “こんにちは”

      if (greeting != null) {
      // このブロック内では、greeting は String? ではなく String として扱われる
      println(greeting.length) // 安全にlengthにアクセスできる
      } else {
      println(“挨拶がありません”)
      }
      ``
      この      if` を使用したチェックは、最も安全で分かりやすい方法の一つです。

    5. スコープ関数 (?.let, ?.run など):
      Nullableなオブジェクトに対して、そのオブジェクトが null でない場合にのみ特定の処理を実行したい場合によく使われます。特に ?.let が頻繁に利用されます。

      “`kotlin
      var nullableText: String? = “何か文字列”

      nullableText?.let {
      // it は null でない nullableText の値（String 型）
      println(“文字列の長さ: ${it.length}”) // null でないので安全にlengthにアクセス
      // このブロックの最後の式が let 式全体の結果となる
      it.length * 2
      } ?: run {
      // nullableText が null だった場合に実行される
      println(“文字列はnullです”)
      -1 // Elvis演算子の右辺として、let 式全体がnullだった場合のデフォルト値を返す
      }
      ``?.let` は、Nullableなオブジェクトに対して一連の処理を実行したい場合に便利です。

ヌル安全機能は、Kotlinで堅牢なアプリケーションを開発する上で非常に重要な役割を果たします。これらの Nullable 型の扱い方に慣れることは、Kotlinマスターへの第一歩です。

ステップ５：制御フローを学ぶ

プログラムの実行の流れを制御するための構文を制御フローと呼びます。Kotlinには、条件分岐や繰り返しのための標準的な構文が用意されています。

5.1. 条件分岐：if と when

  • if 式:
    条件が真（true）か偽（false）かに基づいて処理を分岐させます。Kotlinの if は式であるため、値を返すことができます。

    “`kotlin
    val score = 85
    var grade = “”

    if (score >= 90) {
    grade = “A”
    } else if (score >= 80) {
    grade = “B”
    } else if (score >= 70) {
    grade = “C”
    } else {
    grade = “D”
    }
    println(“成績: $grade”) // 出力例: 成績: B

    // if を式として使用する例
    val result = if (score > 50) “合格” else “不合格”
    println(“試験結果: $result”) // 出力例: 試験結果: 合格
    ``if式として使用する場合、elseブロックは必須です（ifブロックが値を返す可能性があるため、else` がないと値が未定義になるケースが生じる）。

  • when 式:
    Javaの switch 文に似ていますが、より強力で柔軟な式です。値を返すことができます。

    kotlin
    val statusCode = 200
    val statusMessage = when (statusCode) {
    200 -> "OK"
    400 -> { // 複数行の処理を書きたい場合はブロックを使用
    println("Client Error")
    "Bad Request"
    }
    404 -> "Not Found"
    500, 502 -> "Server Error" // 複数の値をカンマで区切って指定
    in 300..399 -> "Redirection" // 範囲を指定
    is Int -> "Unknown status code" // 引数の型をチェック
    else -> "Really Unknown" // 上記のどれにも一致しない場合 (when を式として使う場合は else が必須)
    }
    println("ステータス: $statusMessage") // 出力例: ステータス: OK
    when は引数なしでも使用でき、より一般的な if-else if の置き換えとしても強力です。

    kotlin
    val x = 10
    val y = 20
    when {
    x > y -> println("xはyより大きい")
    x < y -> println("xはyより小さい")
    else -> println("xとyは等しい")
    }
    when は、Enum定数、Sealed Class、スマートキャストなどとも組み合わせて使うことで、非常に表現力豊かなコードを書くことができます。

5.2. 繰り返し：for, while, do-while

  • for ループ:
    範囲、数列、コレクション、配列など、イテラブル（iterate可能なもの）な要素を順番に処理します。

    “`kotlin
    // 範囲 (Ranges) を使った繰り返し
    for (i in 1..5) { // 1から5まで (5を含む)
    print(“$i “) // 出力: 1 2 3 4 5
    }
    println()

    for (i in 1 until 5) { // 1から5まで (5を含まない)
    print(“$i “) // 出力: 1 2 3 4
    }
    println()

    for (i in 5 downTo 1) { // 5から1までカウントダウン
    print(“$i “) // 出力: 5 4 3 2 1
    }
    println()

    for (i in 1..10 step 2) { // 1から10まで2つ飛ばし
    print(“$i “) // 出力: 1 3 5 7 9
    }
    println()

    // コレクション (List) を使った繰り返し
    val fruits = listOf(“Apple”, “Banana”, “Cherry”)
    for (fruit in fruits) {
    println(fruit)
    }

    // インデックス付きで要素を処理する場合
    for ((index, fruit) in fruits.withIndex()) {
    println(“$index: $fruit”)
    }

    // 配列 (Array) を使った繰り返し
    val numbers = arrayOf(10, 20, 30)
    for (num in numbers) {
    println(num)
    }
    “`

  • while ループ:
    指定した条件が真である限り、ブロック内の処理を繰り返します。

    kotlin
    var count = 0
    while (count < 5) {
    println("Count: $count")
    count++
    }
    // 出力:
    // Count: 0
    // Count: 1
    // Count: 2
    // Count: 3
    // Count: 4

  • do-while ループ:
    まずブロック内の処理を一度実行し、その後指定した条件が真である限り繰り返しを実行します。ブロック内の処理が少なくとも一度は実行される点が while と異なります。

    kotlin
    var i = 0
    do {
    println("i: $i")
    i++
    } while (i < 5)
    // 出力:
    // i: 0
    // i: 1
    // i: 2
    // i: 3
    // i: 4

5.3. ジャンプ式：break と continue、return、ラベル

繰り返し処理の中から抜け出したり、次の繰り返しに進んだり、関数から値を返したりするために、ジャンプ式を使用します。

  • break: 最も内側の繰り返し処理（for, while, do-while）を完全に終了させます。

    kotlin
    for (i in 1..10) {
    if (i == 5) {
    break // iが5になったらループを終了
    }
    print("$i ") // 出力: 1 2 3 4
    }
    println()

  • continue: 最も内側の繰り返し処理の現在のイテレーションをスキップし、次のイテレーションに移ります。

    kotlin
    for (i in 1..10) {
    if (i % 2 == 0) {
    continue // iが偶数ならスキップして次のイテレーションへ
    }
    print("$i ") // 出力: 1 3 5 7 9
    }
    println()

  • return: 関数やラムダ式から値を返したり、処理を終了させたりします。関数の戻り値の型が Unit (Javaの void に相当し、何も返さないことを示す) の場合は、値を伴わない return を使用できます。

    “`kotlin
    fun calculateSum(a: Int, b: Int): Int {
    return a + b // a + b の結果を返す
    }

    fun greet(name: String) {
    if (name.isEmpty()) {
    return // 名前が空なら処理を終了 (Unit を返す関数なので値を返さない)
    }
    println(“Hello, $name!”)
    }
    ``return` はラムダ式や匿名関数の中でも使用され、その振る舞いはコンテキストによって異なります（非ローカルリターン、ローカルリターン）。

  • ラベル:
    複数の入れ子になった繰り返し処理がある場合など、特定の繰り返し処理から break や continue を実行したい場合にラベルを使用します。ラベルは識別子の後ろに @ を付けて定義し、ジャンプ式に続けて記述します。

    kotlin
    outerLoop@ for (i in 1..5) {
    innerLoop@ for (j in 1..5) {
    if (i == 3 && j == 3) {
    break@outerLoop // 外側のループを終了
    // break@innerLoop // 内側のループだけを終了する場合
    }
    println("i=$i, j=$j")
    }
    }
    // i=1, j=1
    // i=1, j=2
    // ...
    // i=3, j=1
    // i=3, j=2
    // と表示された後、break@outerLoop により外側のループごと終了する
    ラベル付き return は、ラムダ式から特定の関数へリターンしたい場合などに使用されます。

ステップ６：関数を学ぶ

関数は、特定の処理をひとまとめにしたコードのブロックです。同じ処理を繰り返し実行したい場合や、プログラムを論理的な単位に分割したい場合に便利です。Kotlinでは fun キーワードを使って関数を定義します。

6.1. 関数の定義

関数の基本的な定義構文は以下の通りです。

kotlin
fun functionName(parameter1: ParameterType1, parameter2: ParameterType2, ...): ReturnType {
// 関数の本体 (処理内容)
// ...
return result // 戻り値がある場合
}

  • fun: 関数を定義することを示すキーワードです。
  • functionName: 関数の名前です。キャメルケース（例: calculateSum）で命名するのが一般的です。
  • (parameter1: ParameterType1, ...): 関数の引数リストです。引数名と : の後にその型を指定します。引数がない場合は省略します。
  • : ReturnType: 関数の戻り値の型です。戻り値がない場合は省略するか、明示的に : Unit と記述します（Unit は省略されるのが一般的です）。
  • { ... }: 関数の本体です。実行したい処理をここに記述します。
  • return result: 戻り値がある関数で、値を返すために使用します。

例: 引数を取らず、何も返さない関数

“`kotlin
fun sayHello() {
println(“Hello!”)
}

fun main() {
sayHello() // 関数を呼び出す
}
“`

例: 引数を取り、値を返す関数

“`kotlin
fun calculateArea(width: Double, height: Double): Double {
val area = width * height
return area // Double 型の値を返す
}

fun main() {
val rectArea = calculateArea(10.0, 5.0)
println(“面積: $rectArea”) // 出力例: 面積: 50.0
}
“`

6.2. 単一式関数

関数の本体が単一の式である場合、波括弧 {} と return キーワードを省略して、= でつなぐ簡潔な書き方ができます。この場合、戻り値の型はコンパイラによって自動的に推定されます（明示的に指定することも可能です）。

“`kotlin
// 通常の書き方
fun add(a: Int, b: Int): Int {
return a + b
}

// 単一式関数として書き換え
fun addConcise(a: Int, b: Int): Int = a + b

// 戻り値の型も省略可能（型推定）
fun addEvenMoreConcise(a: Int, b: Int) = a + b

fun main() {
println(add(2, 3)) // 出力: 5
println(addConcise(4, 5)) // 出力: 9
println(addEvenMoreConcise(6, 7)) // 出力: 13
}
“`
単一式関数は、特に短い関数を定義する際にコードを非常に簡潔にします。

6.3. デフォルト引数と名前付き引数

Kotlinの関数は、デフォルト引数と名前付き引数をサポートしており、関数の呼び出しをより柔軟にします。

  • デフォルト引数:
    関数の引数にデフォルト値を設定できます。関数呼び出し時にその引数を省略した場合、デフォルト値が使用されます。

    “`kotlin
    fun greet(name: String = “ゲスト”, greeting: String = “Hello”) {
    println(“$greeting, $name!”)
    }

    fun main() {
    greet(“Alice”, “Hi”) // 両方の引数を指定 -> Hi, Alice!
    greet(“Bob”) // greeting を省略 (デフォルト値 “Hello” が使われる) -> Hello, Bob!
    greet(greeting = “こんにちは”) // name を省略 (デフォルト値 “ゲスト” が使われる) -> こんにちは, ゲスト!
    greet() // 両方省略 -> Hello, ゲスト!
    }
    “`
    デフォルト引数を使用すると、複数のオーバーロード関数（引数の数や型が異なる同じ名前の関数）を定義する必要がなくなり、コードが簡潔になります。

  • 名前付き引数:
    関数を呼び出す際に、引数の名前を指定して値を渡すことができます。これにより、特に引数の数が多い場合や、引数の意味が分かりにくい場合に、コードの可読性が向上します。引数の順番を自由に変えることも可能です。

    “`kotlin
    fun createEmail(to: String, subject: String, body: String, sender: String = “[email protected]”) {
    println(“””
    Sender: $sender
    To: $to
    Subject: $subject

        $body
""".trimIndent())

    }

    fun main() {
    // 通常の呼び出し (引数の順番に注意が必要)
    createEmail(“[email protected]”, “Meeting”, “Details inside”)

    // 名前付き引数を使った呼び出し (順番を気にせず、どの引数に何を渡すか明確)
createEmail(
    to = "[email protected]",
    body = "Could you please review this document?",
    subject = "Review Request"
    // sender はデフォルト値が使用される
)

    }
    “`
    名前付き引数は、デフォルト引数と組み合わせて使うとさらに便利です。特定の引数だけデフォルト値を上書きしたい場合に、名前付き引数を使えば他の引数を省略して分かりやすく呼び出せます。

ステップ７：クラスとオブジェクトを学ぶ

オブジェクト指向プログラミング（OOP）の基本的な概念であるクラスとオブジェクトは、Kotlinでも非常に重要な要素です。クラスはオブジェクトを作成するための設計図であり、オブジェクトはクラスに基づいて生成された実体です。

7.1. クラスの定義

クラスは class キーワードを使って定義します。

kotlin
class ClassName {
// プロパティ (データ)
// メソッド (振る舞い)
}

例: シンプルな空のクラス

kotlin
class EmptyClass {
// 何もなし
}

7.2. プロパティ

クラスはデータを持つことができます。これをプロパティと呼びます。プロパティはクラスのメンバーとして var または val を使って宣言します。

“`kotlin
class Person {
// プロパティ
var name: String = “名無しの権兵衛” // var なので変更可能
val age: Int = 0 // val なので読み取り専用
}

fun main() {
val person = Person() // Personクラスのオブジェクトを生成
println(“名前: ${person.name}”) // プロパティにアクセス: 名無しの権兵衛
println(“年齢: ${person.age}”) // プロパティにアクセス: 0

person.name = "山田太郎" // var プロパティなので変更可能
println("新しい名前: ${person.name}") // 新しい名前: 山田太郎

// person.age = 30 // エラー！ val プロパティは変更できない

}
“`
プロパティは、デフォルトで public なので、クラスの外部からアクセスできます。可視性を制限するには、後述の可視性修飾子を使用します。

7.3. コンストラクタ

オブジェクトを生成する際に初期化処理を行うための特別なメソッドをコンストラクタと呼びます。Kotlinにはプライマリコンストラクタとセカンダリコンストラクタがあります。

  • プライマリコンストラクタ:
    クラスヘッダーの一部として定義されるコンストラクタです。最も一般的なコンストラクタの定義方法です。

    kotlin
    class Person(val name: String, var age: Int) {
    // クラス本体
    // ...
    }
    プライマリコンストラクタの引数に val または var を付けると、その引数は自動的に同じ名前のプロパティとして定義されます。

    “`kotlin
    fun main() {
    val person = Person(“佐藤花子”, 25) // プライマリコンストラクタを呼び出してオブジェクト生成
    println(“名前: ${person.name}, 年齢: ${person.age}”) // 出力: 名前: 佐藤花子, 年齢: 25

    person.age = 26 // var プロパティなので変更可能
// person.name = "田中一郎" // エラー！ val プロパティは変更できない

    }
    ``
    プロパティ宣言を伴わないプライマリコンストラクタの引数は、クラス本体や初期化ブロック (    init`) 内でのみ使用できます。

    “`kotlin
    class Greeter(greeting: String) { // greeting はプロパティではない
    val message = “$greeting, Kotlin!” // message プロパティを定義

    init {
    // 初期化ブロック: オブジェクト生成時に実行される
    println("Greeterオブジェクトが生成されました。挨拶: $greeting")
}

    }

    fun main() {
    val greeter = Greeter(“こんにちは”) // 初期化ブロックが実行される
    println(greeter.message) // 出力: こんにちは, Kotlin!
    // println(greeter.greeting) // エラー！ greeting はプロパティではないため外部からアクセスできない
    }
    “`

  • セカンダリコンストラクタ:
    クラス本体内に constructor キーワードを使って定義するコンストラクタです。通常はプライマリコンストラクタで対応できない複雑な初期化や、複数の異なる引数パターンでオブジェクトを生成したい場合に使用します。プライマリコンストラクタが存在する場合、セカンダリコンストラクタは this() を使ってプライマリコンストラクタ（または別のセカンダリコンストラクタ）を直接的または間接的に呼び出す必要があります。

    “`kotlin
    class Animal(val name: String) {
    constructor(name: String, type: String) : this(name) { // プライマリコンストラクタ(this(name))を呼び出す
    println(“$type 型の $name が生まれました。”)
    }

    init {
    println("$name が初期化されました。")
}

    }

    fun main() {
    val animal1 = Animal(“ライオン”) // プライマリコンストラクタ呼び出し -> “ライオン が初期化されました。”
    val animal2 = Animal(“ゾウ”, “哺乳類”) // セカンダリコンストラクタ呼び出し -> “ゾウ が初期化されました。”, “哺乳類 型の ゾウ が生まれました。”
    }
    “`

7.4. メソッド

クラスはデータ（プロパティ）だけでなく、振る舞い（メソッド）を持つことができます。メソッドはクラス内で定義される関数です。

“`kotlin
class Dog(val name: String) {
fun bark() { // メソッド定義
println(“$name がワンワン吠えています！”)
}

fun introduce() {
    println("私の名前は $name です。")
}

}

fun main() {
val myDog = Dog(“ポチ”)
myDog.introduce() // メソッド呼び出し: 私の名前は ポチ です。
myDog.bark() // メソッド呼び出し: ポチ がワンワン吠えています！
}
“`

7.5. 可視性修飾子

クラス、プロパティ、メソッドなどのメンバーへのアクセス範囲を制御するために、可視性修飾子を使用します。

  • public (デフォルト): どこからでもアクセス可能です。
  • private: そのメンバーが宣言されたクラス（またはファイル、トップレベルの場合）内からのみアクセス可能です。
  • protected: そのメンバーが宣言されたクラスおよびそのサブクラス内からアクセス可能です。
  • internal: そのメンバーが宣言されたモジュール内からのみアクセス可能です。モジュールとは、IntelliJ IDEAのモジュール、MavenやGradleのプロジェクト、Antタスクのセットなどを指します。

“`kotlin
class Example {
public val publicProperty = 1 // public (デフォルトなので省略可)
private val privateProperty = 2 // private なので Example クラス内からのみアクセス可
protected val protectedProperty = 3 // protected なので Example クラスとそのサブクラスからアクセス可
internal val internalProperty = 4 // internal なので同じモジュール内からアクセス可

private fun privateMethod() {
    println("これは private メソッドです")
}

internal fun internalMethod() {
    println("これは internal メソッドです")
}

fun accessMembers() {
    println(publicProperty)
    println(privateProperty) // OK (同じクラス内)
    println(protectedProperty) // OK (同じクラス内)
    println(internalProperty)
    privateMethod() // OK (同じクラス内)
    internalMethod()
}

}

class SubExample : Example() {
fun accessProtected() {
println(protectedProperty) // OK (サブクラスからアクセス可)
// println(privateProperty) // エラー (サブクラスからは private にアクセス不可)
}
}

// 同じモジュール内の別のファイルからアクセスする場合
fun main() {
val ex = Example()
println(ex.publicProperty) // OK
// println(ex.privateProperty) // エラー
// println(ex.protectedProperty) // エラー (Exampleのサブクラスではない)
println(ex.internalProperty) // OK (同じモジュール内)
ex.accessMembers()
ex.internalMethod() // OK (同じモジュール内)

val subEx = SubExample()
subEx.accessProtected()

}
“`
適切な可視性修飾子を使用することで、コードの隠蔽性を高め、カプセル化を促進できます。

7.6. データクラス (data class)

Kotlinには、データを保持することを主な目的としたクラスを簡潔に定義できる data クラスという便利な機能があります。data クラスとして宣言すると、以下のメソッドが自動的に生成されます。

  • equals() / hashCode(): オブジェクトの内容に基づいて等価性を比較するためのメソッド。
  • toString(): オブジェクトのプロパティとその値を文字列として表現するメソッド。
  • componentN(): プロパティの値を順番に取得するためのメソッド（分解宣言に利用）。
  • copy(): オブジェクトをコピーするためのメソッド。

“`kotlin
data class User(val id: Int, val name: String)

fun main() {
val user1 = User(1, “Alice”)
val user2 = User(1, “Alice”)
val user3 = User(2, “Bob”)

// toString() が自動生成される
println(user1) // 出力例: User(id=1, name=Alice)

// equals() / hashCode() が自動生成される (プロパティの値で比較)
println(user1 == user2) // 出力: true (内容が同じなので等しい)
println(user1 == user3) // 出力: false

// copy() メソッド
val user4 = user1.copy(name = "Alicia") // user1 をコピーし、nameだけ変更
println(user4) // 出力例: User(id=1, name=Alicia)

// componentN() メソッドと分解宣言
val (userId, userName) = user1 // user1.component1(), user1.component2() が呼ばれる
println("ID: $userId, Name: $userName") // 出力: ID: 1, Name: Alice

}
``data` クラスは、DTO (Data Transfer Object) や状態保持クラスなど、値を保持するためのシンプルなクラス定義に最適です。

7.7. シングルトンオブジェクト (object)

アプリケーション全体でそのクラスのインスタンスが一つだけ存在することを保証したい場合があります。これをシングルトンパターンと呼びます。Kotlinでは、class の代わりに object キーワードを使うだけで簡単にシングルトンオブジェクトを定義できます。

“`kotlin
object SingletonExample {
val instanceProperty = “これはシングルトンインスタンスのプロパティです”

fun instanceMethod() {
    println("これはシングルトンインスタンスのメソッドです")
}

}

fun main() {
// object で宣言されたオブジェクトは、名前を使って直接アクセスできる
println(SingletonExample.instanceProperty) // 出力: これはシングルトンインスタンスのプロパティです
SingletonExample.instanceMethod() // 出力: これはシングルトンインスタンスのメソッドです

// シングルトンなので、常に同じインスタンスを参照する
val obj1 = SingletonExample
val obj2 = SingletonExample
println(obj1 === obj2) // 出力: true (参照が同じかどうかの比較)

}
``object` は、静的なユーティリティメソッドやアプリケーション全体の状態を保持するためなどに利用できます。

7.8. コンパニオンオブジェクト (companion object)

クラスに紐づくが、特定のインスタンスには紐づかないメンバー（Javaでいう静的メンバー static に相当）を定義したい場合があります。Kotlinでは、クラス内に companion object を定義することでこれを実現します。

“`kotlin
class MyClass {
companion object {
val CONSTANT = “これはコンパニオンオブジェクトの定数です”

    fun factoryMethod(): MyClass {
        println("ファクトリーメソッドが呼ばれました")
        return MyClass() // MyClass のインスタンスを生成して返す
    }
}

}

fun main() {
// コンパニオンオブジェクトのメンバーは、クラス名を使って直接アクセスできる
println(MyClass.CONSTANT) // 出力: これはコンパニオンオブジェクトの定数です
val instance = MyClass.factoryMethod() // 出力: ファクトリーメソッドが呼ばれました
// val instance = MyClass() // コンストラクタも使える場合
}
``
コンパニオンオブジェクトは、名前を省略してMyClass.CONSTANTやMyClass.factoryMethod()のようにクラス名に続けてアクセスできます。companion object` に名前を付けることもできますが、省略されるのが一般的です。

Javaの static メンバーの多くは、Kotlinではトップレベルの関数やプロパティ、あるいは companion object のメンバーとして定義されます。

7.9. 継承

Kotlinは単一継承をサポートしています。あるクラス（サブクラス、派生クラス）が別のクラス（スーパークラス、基底クラス）のプロパティやメソッドを引き継ぐことができます。

デフォルトでは、Kotlinのクラスは継承を許可しません。継承を許可するためには、スーパークラスを open キーワードで修飾する必要があります。また、オーバーライド可能なプロパティやメソッドも、デフォルトではオーバーライドを許可しません。これらも open で修飾することでオーバーライド可能になります。

“`kotlin
// 継承可能な基底クラス
open class Base(val name: String) {
open fun greet() { // オーバーライド可能なメソッド
println(“私は $name です。”)
}

fun sayHello() { // オーバーライド不可なメソッド
    println("Hello from Base.")
}

}

// Base を継承する派生クラス
class Derived(name: String, val age: Int) : Base(name) { // スーパークラスのコンストラクタを呼び出す

// スーパークラスの open メソッドをオーバーライド
override fun greet() {
    super.greet() // スーパークラスの greet() を呼び出す
    println("私は $name ($age 歳) です。")
}

fun introduce() {
    println("Derivedクラスです。")
}

// fun sayHello() { ... } // エラー！ sayHello() は Base クラスで open ではないためオーバーライドできない

}

fun main() {
val base = Base(“基底クラス”)
base.greet() // 出力: 私は 基底クラス です。

val derived = Derived("派生クラス", 30)
derived.greet() // 出力: 私は 派生クラス です。, 私は 派生クラス (30 歳) です。 (super.greet() が呼ばれている場合)
derived.sayHello() // 出力: Hello from Base.
derived.introduce() // 出力: Derivedクラスです。

// 親クラスの型で子クラスのオブジェクトを参照することも可能 (ポリモーフィズム)
val baseRef: Base = Derived("別の派生クラス", 40)
baseRef.greet() // 出力: 私は 別の派生クラス です。, 私は 別の派生クラス (40 歳) です。 (Derivedのgreet()が呼ばれる)
// baseRef.introduce() // エラー！ Base型には introduce() メソッドがない

}
``
Kotlinの継承では、スーパークラス名の後にプライマリコンストラクタの引数を括弧()で指定して呼び出す必要があります。オーバーライドするメンバーにはoverride` キーワードを付ける必要があります。

7.10. 抽象クラスとインターフェース

  • 抽象クラス (abstract class):
    インスタンス化できないクラスで、抽象メンバー（実装を持たないメンバー）を含むことができます。抽象メンバーはサブクラスで必ずオーバーライドする必要があります。

    “`kotlin
    abstract class Shape {
    abstract val numberOfSides: Int // 抽象プロパティ
    abstract fun calculateArea(): Double // 抽象メソッド

    fun describe() { // 実装を持つメソッド
    println("この図形には $numberOfSides 個の辺があります。")
}

    }

    class Rectangle(val width: Double, val height: Double) : Shape() {
    override val numberOfSides: Int = 4 // 抽象プロパティの実装
    override fun calculateArea(): Double { // 抽象メソッドの実装
    return width * height
    }
    }

    // val shape = Shape() // エラー！ 抽象クラスはインスタンス化できない
    val rectangle = Rectangle(10.0, 5.0)
    rectangle.describe() // 出力: この図形には 4 個の辺があります。
    println(“面積: ${rectangle.calculateArea()}”) // 出力: 面積: 50.0
    “`

  • インターフェース (interface):
    実装を持たない（またはデフォルト実装を持つ）メソッドや抽象プロパティの集まりです。KotlinのインターフェースはJava 8以降のインターフェースに似ており、メソッドにデフォルト実装を持たせることができます。クラスは複数のインターフェースを実装できます。

    “`kotlin
    interface Drawable {
    fun draw() // 抽象メソッド (実装を持たない)

    fun getColor(): String { // デフォルト実装を持つメソッド
    return "Black"
}

    }

    interface Resizable {
    fun resize(factor: Double)
    }

    class Circle(val radius: Double) : Drawable, Resizable { // 複数のインターフェースを実装
    override fun draw() {
    println(“半径 $radius の円を描画します。”)
    }

    override fun resize(factor: Double) {
    println("サイズを $factor 倍に変更します。")
    // radius = radius * factor // val なので変更できない。実際は変数を変更する必要がある
}

// getColor() はデフォルト実装を使用

    }

    val circle = Circle(5.0)
    circle.draw() // 出力: 半径 5.0 の円を描画します。
    println(“色: ${circle.getColor()}”) // 出力: 色: Black (デフォルト実装が呼ばれる)
    circle.resize(1.5) // 出力: サイズを 1.5 倍に変更します。
    “`
    インターフェースは、クラス間の共通の振る舞いを定義するのに役立ちます。

7.11. 列挙クラス (enum class)

限られた定数のセットを表現するために使用されます。Javaの enum と似ていますが、より機能が豊富です。

“`kotlin
enum class Direction {
NORTH, SOUTH, EAST, WEST
}

enum class Color(val rgb: Int) { // プロパティやメソッドを持つこともできる
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF); // 定数リストの終わりにセミコロンが必要な場合がある (本体に何か書く場合)

fun containsRed(): Boolean {
    return (rgb and 0xFF0000) != 0
}

}

fun main() {
val dir = Direction.NORTH
println(dir) // 出力: NORTH

val myColor = Color.RED
println(myColor.rgb.toString(16)) // 出力: ff0000
println(myColor.containsRed()) // 出力: true

// when 式と組み合わせるのが一般的
when (dir) {
    Direction.NORTH -> println("北へ")
    Direction.SOUTH -> println("南へ")
    Direction.EAST -> println("東へ")
    Direction.WEST -> println("西へ")
}

}
“`
列挙クラスは、状態や選択肢など、取りうる値が決まっている場合に便利です。

7.12. シールクラス (sealed class)

継承されるクラスの型を限定したい場合に使用します。sealed クラスのサブクラスは、sealed クラスと同じファイル内、または同じモジュール内に限定されます（Kotlin 1.5以降）。これは、when 式で sealed クラスのサブクラスをすべて網羅した場合に else ブロックを省略できるなど、パターンマッチングとの相性が非常に良いです。

“`kotlin
sealed class Result {
data class Success(val data: String) : Result() // Resultのサブクラス (data classも可)
data class Error(val message: String) : Result() // Resultのサブクラス
object Loading : Result() // Resultのサブクラス (objectも可)
}

fun processResult(result: Result) {
when (result) {
is Result.Success -> println(“成功: ${result.data}”)
is Result.Error -> println(“エラー: ${result.message}”)
Result.Loading -> println(“ローディング中…”)
// sealed クラスなので、すべてのサブクラスをwhenで扱っていれば else は不要
}
}

fun main() {
processResult(Result.Loading) // 出力: ローディング中…
processResult(Result.Success(“データ取得完了”)) // 出力: 成功: データ取得完了
processResult(Result.Error(“ネットワークエラー”)) // 出力: エラー: ネットワークエラー
}
``sealed` クラスは、取りうる状態が限定されているようなシナリオ（例: ネットワーク通信の結果、UIの状態など）を表現するのに非常に役立ちます。

ステップ８：少し進んだトピック (触りだけ)

Kotlinには、これまでに紹介した基本以外にも、開発を効率化し、よりKotlinらしいコードを書くための強力な機能がたくさんあります。ここでは、その中のいくつかについて簡単に触れておきます。

  • コレクション:
    リスト (List, MutableList)、セット (Set, MutableSet)、マップ (Map, MutableMap) など、Javaコレクションフレームワークをベースにした強力で使いやすいコレクションライブラリがあります。これらはKotlinの拡張関数と組み合わせることで、非常に簡潔に操作できます。

    “`kotlin
    val numbers = listOf(1, 2, 3, 4, 5) // 不変リスト
    val names = mutableListOf(“Alice”, “Bob”) // 可変リスト
    names.add(“Charlie”)

    val ages = mapOf(“Alice” to 30, “Bob” to 25) // 不変マップ
    val scores = mutableMapOf(“Math” to 90, “Science” to 85) // 可変マップ
    scores[“English”] = 95

    // 拡張関数を使ったコレクション操作の例
    val evenNumbers = numbers.filter { it % 2 == 0 } // filter はコレクションの拡張関数
    val squaredNumbers = numbers.map { it * it } // map もコレクションの拡張関数
    “`

  • 拡張関数 (Extension Functions):
    既存のクラスに、ソースコードを変更することなく新しい関数を追加できる機能です。非常に強力で、Kotlin標準ライブラリや多くの外部ライブラリで多用されています。例えば、先ほどの filter や map は、コレクション型に対する拡張関数です。

    “`kotlin
    // String 型に “greet” という拡張関数を追加
    fun String.greet() {
    println(“Hello, $this”) // this は拡張関数を呼び出したオブジェクト自身を指す
    }

    fun main() {
    “Kotlin”.greet() // 出力: Hello, Kotlin
    “World”.greet() // 出力: Hello, World
    }
    “`

  • 委譲 (Delegation):
    オブジェクト指向におけるデザインパターンの一つである「委譲」を、Kotlinでは by キーワードを使って簡単に実現できます。特にプロパティ委譲（Delegated Properties）は、遅延初期化 (lazy)、Observableプロパティ (Delegates.observable) など、様々な場面で活用されます。

    “`kotlin
    // プロパティ委譲の例: lazy (遅延初期化)
    val lazyValue: String by lazy {
    println(“lazyValue を計算中…”) // このブロックは lazyValue に初めてアクセスされた時に実行される
    “計算結果”
    }

    fun main() {
    println(“初めて lazyValue にアクセスします”)
    println(lazyValue) // ここで初めて lazyValue の計算が実行される
    println(“再び lazyValue にアクセスします”)
    println(lazyValue) // 計算済みの値が返される (ブロックは実行されない)
    }
    “`

これらの機能は、Kotlinの記述力を高め、より効率的で idiomatic なコードを書くために重要ですが、まずは基本的な文法やクラスの概念をしっかりと理解することから始めましょう。

まとめ：Kotlin学習の次のステップ

この記事では、Kotlinを始めるために必要な開発環境の構築から、変数、データ型、制御フロー、そしてオブジェクト指向の基本的な概念であるクラスとオブジェクトまでを広く深く解説しました。

あなたは今、Kotlinプログラミングの第一歩を踏み出し、その基本的な要素を理解するための確固たる基盤を築きました。これで、より複雑なプログラムを書く準備ができました。

Kotlinの学習は、ここからが本番です。次にどのようなことを学べば良いでしょうか？

  1. Kotlin標準ライブラリの活用: コレクション（List, Set, Map）のより高度な操作、シーケンス、ファイルI/Oなど、Kotlinが提供する豊富な標準ライブラリの使い方を学びましょう。
  2. より進んだ機能: 拡張関数、委譲、データクラス、シールクラス、ラムダ式と高階関数、コルーチンといったKotlinならではの強力な機能を深く理解することで、よりKotlinらしい、簡潔で効率的なコードを書けるようになります。特にコルーチンは非同期処理において非常に強力な機能です。
  3. 練習あるのみ: 学んだことを定着させるためには、実際にコードを書くことが最も重要です。簡単なプログラムから始め、徐々に複雑な問題に挑戦してみましょう。オンラインのプログラミング練習サイト（例: LeetCode, HackerRank など）や、Kotlin公式が提供する Kotlin Koans (https://kotlinlang.org/docs/koans.html) も良いリソースです。
  4. アプリケーション開発: Kotlinを学ぶ多くの人が目指すのは、特定の分野でのアプリケーション開発でしょう。
    • Androidアプリ開発: Android Studio（IntelliJ IDEAベースのAndroid開発用IDE）を使い、KotlinでのAndroid開発に挑戦してみましょう。公式ドキュメントやチュートリアルが豊富に用意されています。
    • サーバーサイド開発: KtorやSpring Bootといったフレームワークを使って、Kotlinでバックエンドシステムを構築してみましょう。
    • マルチプラットフォーム開発: Kotlin Multiplatformを使って、iOSとAndroidでコードを共有するモバイルアプリ開発や、WebAssemblyを使ったWebフロントエンド開発に挑戦することも可能です。
  5. コミュニティに参加する: Kotlinコミュニティは非常に活発です。オンラインフォーラムやSlackグループ、ミートアップなどに参加して、他の開発者と交流したり、質問したり、最新情報を得たりすることは、学習を続ける上で大きな助けになります。
  6. 公式ドキュメントを活用する: Kotlinの公式ドキュメント (https://kotlinlang.org/docs/) は非常に詳細で分かりやすいです。困ったときは、まず公式ドキュメントを参照するのが最も確実です。

Kotlinはモダンでパワフル、そして楽しい言語です。この記事があなたのKotlin学習の素晴らしいスタートとなることを願っています。さあ、IntelliJ IDEAを開いて、さらにコードを書き進めましょう！

頑張ってください！

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール