Kotlinの可視性修飾子を完全ガイド！public・private・internalの意味と使い分けを初心者向けに解説

1. 可視性修飾子とは？

1. 可視性修飾子とは？

Kotlinでプログラムを書くとき、「どこからそのクラスや関数が見えるのか」を決める仕組みがあります。それが可視性修飾子（Visibility Modifiers）です。

小さなサンプルで考えると分かりやすいです。もし、すべての情報が丸見えになってしまうと、外部から勝手に使われたり、名前がかぶったりして混乱の原因になります。

そこで「公開するもの」と「隠すもの」を選べるようにして、必要な場所だけに見えるようにするのが可視性修飾子の役割です。

class Box {
    val publicData = "だれでも見えるよ"      // public扱い
    private val secret = "ないしょ"          // クラスの外からは見えない
}

このように、同じクラスの中でも「見えるもの」と「見えないもの」を分けられます。特にプログラムが大きくなるほど、この考え方がとても大切になります。

Kotlinでよく使う可視性修飾子は次の3つです：

• public（パブリック）：どこからでも見える
• private（プライベート）：そのクラスやファイルの中だけで見える
• internal（インターナル）：同じモジュールの中なら見える

「公開したい場所だけに見せる」。たったこれだけで、コードはぐっと安全で読みやすくなります。

2. publicの使い方と特徴

2. publicの使い方と特徴

publicは「どこからでも呼び出してよい」という合図です。Kotlinでは何も書かないと自動的にpublicになるため、基本は省略して構いません。外部に提供したいクラスや関数に向いています。

// クラスも関数も、書かなければ public
class Person(val name: String) {
    fun sayHello() {
        println("こんにちは、$name です")
    }
}

// トップレベル関数（ファイル直下）も同様に public
fun greetAll(names: List<String>) {
    names.forEach { println("ようこそ、$it さん") }
}

fun main() {
    val p = Person("さくら")
    p.sayHello()

    greetAll(listOf("たろう", "はなこ"))
}

こんにちは、さくら です
ようこそ、たろう さん
ようこそ、はなこ さん

ポイントは「公開したい最小限だけをpublicにする」こと。内部実装は後で変えても、publicな入口（API）が守られていれば、他のコードに影響を与えにくくなります。ライブラリの入口や、画面から呼ばれるサービスなど、外から使われる前提の要素に使いましょう。

3. privateの使い方と特徴

3. privateの使い方と特徴

privateは「この中だけで使う」ことを約束する可視性です。クラスの外やファイルの外に影響させたくない処理や値を隠すことで、うっかり誤用されるのを防ぎ、コードの読みやすさも保てます。まずはクラス内部での例から確認しましょう。

class Calculator {
    // 外から見せたくない一時データ
    private var lastResult: Int = 0

    // 外部に公開しない小さな部品（ヘルパー関数）
    private fun add(a: Int, b: Int): Int = a + b

    // こちらは公開する入口（API）
    fun showSum(a: Int, b: Int) {
        lastResult = add(a, b)
        println("合計は $lastResult")
    }

    // 直近の計算結果だけは読むことを許す
    fun result(): Int = lastResult
}

fun main() {
    val calc = Calculator()
    calc.showSum(5, 3)   // 合計は 8
    println(calc.result())
    // calc.add(5, 3)         // ← private のため呼べない（エラー）
    // println(calc.lastResult) // ← フィールドも非公開（エラー）
}

合計は 8
8

このように、外に見せるのは「使ってほしい入口」だけにして、内部の手順や一時データはprivateで隠します。設計を変えても外側の呼び出し方を壊しにくくなり、保守が楽になります。

もうひとつ覚えておきたいのが「ファイルレベルのprivate」です。ファイル直下に書いた関数や変数もprivateにでき、そのファイル内だけで使える部品として閉じ込められます。

// ---- Utility.kt ----
private fun normalize(name: String): String = name.trim()

fun greet(name: String) {
    // normalize は同じファイル内からだけ使える
    println("こんにちは、${normalize(name)} さん")
}

コツは「公開したい最小限だけを公開する」こと。迷ったらまずprivateにしておき、本当に必要になったら公開する、という順番で考えると安全です。

4. internalの使い方と特徴

4. internalの使い方と特徴

internalは「同じモジュール内なら見えてOK！」という意味です。

モジュールとは、アプリを構成する部品のようなもので、プロジェクトが分かれている場合に「その中だけで使える」範囲を決めるのがinternalです。

internal class InternalClass {
    fun message() {
        println("このクラスはモジュール内で使えます")
    }
}

たとえば、Androidアプリで「ひとつの機能を作るモジュール」などがある場合、internalで外部との境界を作ることができます。

5. それぞれの可視性修飾子の比較まとめ

5. それぞれの可視性修飾子の比較まとめ

Kotlinのpublic・private・internalの違いを一覧で見てみましょう。

6. クラスだけでなく関数や変数にも使える！

6. クラスだけでなく関数や変数にも使える！

可視性修飾子は、クラスだけでなく、関数・変数・プロパティなど、さまざまな場所に使えます。

class Sample {
    private val secret = "ひみつ"

    fun showSecret() {
        println(secret)
    }
}

fun main() {
    val s = Sample()
    s.showSecret()
    // s.secret は見えないのでエラーになります
}

ひみつ

外部から見られたくない情報をprivateにして守ることで、安全なコードになります。

7. なぜ可視性修飾子が大切なの？

7. なぜ可視性修飾子が大切なの？

すべてpublicにしてしまうと、誰でも好き勝手にそのコードを呼び出せてしまい、バグやトラブルの元になります。

必要なものだけを公開し、それ以外はprivateやinternalで隠すことで、安全でわかりやすいプログラムが書けるようになります。

「見せるもの」と「隠すもの」を意識することは、プログラミングでとても大事な考え方です。

まとめ

まとめ

Kotlinにおける「可視性修飾子」は、クラスや関数、変数が「どの範囲からアクセスできるか」を明確にするための重要な機能です。この記事では、Kotlinでよく使われる3つの可視性修飾子である public、private、internal を中心に、それぞれの役割や違い、実践的な使い方について詳しく解説しました。

まずpublicは、特に指定がなければ自動的に適用されるデフォルトの修飾子で、他のクラスやモジュールからも自由にアクセスできる公開状態です。共有ライブラリや、どこからでも使いたい関数に適しています。

一方、privateはクラス内やファイル内のみにアクセスを制限するため、外部に触れてほしくないデータやロジックを隠すのに役立ちます。たとえば、計算処理や内部状態を管理する変数などに使うと安全性が高まります。

そしてinternalは、モジュール単位での可視性を制御します。複数の機能に分割されたプロジェクト構成において、特定のモジュール内だけで共有したいコードに対して使うことで、他モジュールからの不要なアクセスを防げます。

可視性修飾子は、ただの構文的なキーワードではなく、「このコードは誰に見せたいのか」「どこまで使わせたいのか」という設計の意図を表す手段です。Kotlinの可視性制御を適切に使いこなすことで、チーム開発でもバグの予防や保守性の向上につながります。

また、Kotlinではクラスだけでなく、関数、プロパティ、ローカル変数にも可視性修飾子をつけることができるため、きめ細やかなアクセス制御が可能です。とくに、変数をprivateにしつつ、外部から読み取り専用でアクセスさせたい場合は、getterのみpublicにするなどの柔軟な設計も可能です。

実際の開発では、まずすべてprivateから始めて、必要に応じてinternalやpublicに切り替えていく「最小公開の原則」を守ると、コードの安全性と拡張性がぐっと高まります。

参考：Kotlinでの可視性修飾子の基本構文

public class MyClass {
    private val hiddenValue = 10
    internal fun internalMethod() { println("内部モジュールだけで使う") }
    public fun show() { println("これはどこからでも使える") }
}

Kotlinの可視性修飾子は、Androidアプリ開発やサーバーサイド開発でも頻繁に使われる基礎文法です。適切に活用することで、より安全で読みやすいコードを書くことができます。とくに初心者のうちは、privateをしっかり使って「隠す設計」に慣れることが、良い習慣になります。

可視性修飾子の設計は、小さなコードでも、大きなプロジェクトでも品質に大きな差を生むポイントです。この機会にしっかり理解しておきましょう。

この記事を読んだ人からの質問

この記事を読んだ人からの質問

プログラミング初心者からのよくある疑問／質問を解決します

Kotlinのpublic修飾子は省略しても問題ないのですか？

はい、Kotlinではpublic修飾子は省略可能です。特に何も書かなければ自動的にpublicとして扱われるため、明示的に書かなくてもプログラムは正常に動作します。

Kotlinのprivate修飾子を使うと何が隠れるのですか？

privateを使うと、その関数や変数、クラスは定義されたクラスやファイルの中だけで使えるようになります。他のクラスや外部からはアクセスできません。

Kotlinのinternal修飾子って具体的にどんなときに使うべきですか？

internal修飾子は、同じモジュール内だけで使わせたいクラスや関数に使います。アプリの機能ごとにモジュールが分かれている場合、そのモジュールの中だけで利用したいコードに指定するのが効果的です。