【Java入門】アクセス修飾子とは？public, protected, privateの違いを徹底解説！

Javaのアクセス修飾子は、クラスやそのメンバ（フィールドやメソッド）へのアクセスを制御するための重要な仕組みです。これを正しく理解すると、コードの安全性が高まり、他の人が見てもわかりやすいプログラムを作成できます。

この記事では、Javaに存在する4種類のアクセス修飾子、`public`、`protected`、`default`、`private`の違いと、それぞれの使い分け方をサンプルコードを交えながら丁寧に説明します。

この記事で学べること

• Javaのアクセス修飾子の基本的な役割
• `public`、`protected`、`default`、`private`の4つの違い
• アクセス修飾子を使い分けるための実践的なルール
• アクセス修飾子とオブジェクト指向「カプセル化」の関係
• よくあるエラーとその解決方法

Javaのアクセス修飾子とは？

アクセス修飾子は、クラス、コンストラクタ、フィールド、メソッドに設定できます。設定することで、他のクラスからのアクセス範囲を限定します。

Javaには主に以下の4つのアクセス修飾子があります。

• `public`：最もオープン
• `protected`：身内と子孫に公開
• `default`（パッケージプライベート）：身内のみに公開
• `private`：自分だけの秘密

これらの使い分けをマスターすることが、質の高いJavaコードを書く第一歩になります。

Javaの4つのアクセス修飾子

ここでは、Javaが持つ4つのアクセス修飾子、`public`、`protected`、`default`、`private`のそれぞれの特徴と使い方を、具体的なサンプルコードと共に確認します。

• どこからでもOK！「public」
• 仲間と子孫にだけ！「protected」
• 同じ仲間内だけ！「default（パッケージプライベート）」
• 自分の中だけ！「private」

どこからでもOK！「public」

`public`は、最もアクセス範囲が広い修飾子です。`public`が付与されたクラスやメンバは、どのパッケージのどのクラスからでもアクセスできます。

汎用的な機能を提供するクラスやメソッドによく利用されます。

// com.example.app パッケージ
package com.example.app;

public class Calculator {
    // どこからでも呼び出せるメソッド
    public int add(int a, int b) {
        return a + b;
    }
}

// com.example.main パッケージ
package com.example.main;

import com.example.app.Calculator;

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        // 別のパッケージからでもaddメソッドを呼び出せる
        int result = calc.add(10, 20); 
        System.out.println("計算結果: " + result); // 実行結果: 計算結果: 30
    }
}

仲間と子孫にだけ！「protected」

`protected`は、同じパッケージ内のクラス、またはパッケージが異なる場合でもそのクラスを継承したサブクラスからアクセスできます。

クラスを継承して機能を拡張させたい場合に、サブクラスにだけ公開したいメンバに使用します。

// com.example.vehicle パッケージ
package com.example.vehicle;

public class Vehicle {
    protected String brand = "Generic"; // サブクラスからアクセス可能

    protected void honk() {
        System.out.println("Tuut, tuut!");
    }
}

// com.example.car パッケージ
package com.example.car;

import com.example.vehicle.Vehicle;

class Car extends Vehicle {
    private String modelName = "Mustang";
    public static void main(String[] args) {
        Car myCar = new Car();
        // 親クラスのprotectedメンバにアクセス
        myCar.honk();
        System.out.println(myCar.brand + " " + myCar.modelName);
    }
}
// 実行結果:
// Tuut, tuut!
// Generic Mustang

同じ仲間内だけ！「default（パッケージプライベート）」

アクセス修飾子を何も記述しない場合、`default`（またはパッケージプライベート）として扱われます。`default`のメンバは、同じパッケージに所属するクラスからのみアクセス可能です。

パッケージ内でのみ連携するクラス群を作りたい場合に便利です。

// com.example.library パッケージ
package com.example.library;

public class Book {
    // default修飾子（何も書かない）
    String title = "Java Programming"; 

    void showTitle() {
        System.out.println(title);
    }
}

// 同じパッケージ内のクラス
package com.example.library;

public class Library {
    public static void main(String[] args) {
        Book book = new Book();
        // 同じパッケージなのでアクセスできる
        book.showTitle(); // 実行結果: Java Programming
    }
}

自分の中だけ！「private」

`private`は、最もアクセス範囲が狭い修飾子です。`private`が付与されたメンバは、そのメンバが定義されているクラスの内部からしかアクセスできません。

クラスの内部データを外部から保護し、意図しない変更を防ぐために使われます。これが「カプセル化」の基本となります。

public class Person {
    private String name; // privateフィールド

    // コンストラクタ
    public Person(String name) {
        this.name = name;
    }

    // publicメソッド経由でprivateフィールドにアクセスする
    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Taro");
        // System.out.println(person.name); // コンパイルエラー！直接アクセスはできない
        System.out.println(person.getName()); // メソッド経由ならOK
        // 実行結果: Taro
    }
}

【一覧表】Javaアクセス修飾子の範囲を徹底比較

この章では、これまで紹介した4つのアクセス修飾子のアクセス範囲の違いを、ひとつの表にまとめて比較します。この表を見ることで、それぞれの修飾子の特性を視覚的に整理できるでしょう。

• アクセス範囲の比較テーブル
• この表で覚えるべきポイント

アクセス範囲の比較テーブル

以下の表は、各アクセス修飾子がどの範囲からのアクセスを許可するかを示したものです。

修飾子	同じクラス	同じパッケージ	サブクラス (別パッケージ)	どこからでも
public	◯	◯	◯	◯
protected	◯	◯	◯	×
default	◯	◯	×	×
private	◯	×	×	×

この表で覚えるべきポイント

この表から分かるように、アクセス範囲は public > protected > default > private の順に狭くなります。

プログラミングの基本原則として、「公開範囲は可能な限り狭くする」という考え方があります。これにより、クラスの独立性が高まり、コードの変更が他の部分に影響を与えにくくなるのです。

Javaアクセス修飾子を使いこなすための7つの鉄則

知識として理解するだけでなく、実際にコードを書く際にどう使い分けるかが重要です。ここでは、現場でも通用するアクセス修-飾子の実践的なルールを7つ紹介します。

1. フィールドは原則privateにする
2. メソッドはできるだけ公開範囲を狭くする
3. 定数は`public static final`で公開する
4. むやみに`public`を使わない
5. 継承を意識するなら`protected`を検討する
6. getter/setterをうまく活用する
7. トップレベルクラスに付けられる修飾子を理解する

鉄則1：フィールドは原則privateにする

クラスが持つデータ（フィールド）は、オブジェクト指向の「カプセル化」という考え方に基づき、原則としてすべて`private`にします。フィールドを`public`にすると、クラスの外部から直接、想定外の値（例えば年齢にマイナスの値）を書き込めてしまい、オブジェクトの状態が不正になる危険性があります。

フィールドを`private`で保護し、後述する`public`なメソッド（setter）経由で値を設定するようにすれば、メソッド内で値の妥当性チェックを行えるため、クラスの安全性が格段に向上します。

// Bad: フィールドがpublicだと誰でも値を書き換えられる
public class User {
    public String name;
    public int age; // 負の値も設定できてしまう
}

// Good: フィールドをprivateで保護する
public class User {
    private String name;
    private int age;

    // メソッド経由で安全に操作する
    public void setAge(int age) {
        if (age >= 0 && age < 150) { // 不正な値が入らないようにチェックできる
            this.age = age;
        } else {
            System.out.println("不正な年齢です。");
        }
    }
    
    public int getAge(){
        return this.age;
    }
}

鉄則2：メソッドはできるだけ公開範囲を狭くする

クラスには、外部から利用されるメインの機能（`public`メソッド）と、そのメイン機能を実現するために内部でのみ使われる補助的な処理（ヘルパーメソッド）が存在します。このヘルパーメソッドは`private`に設定すべきです。

例えば、「消費税込みの価格を計算する」という`public`メソッドがあったとします。その内部で「消費税額を計算する」という処理が必要な場合、その部分は`private`メソッドとして切り出します。

クラスを利用する側はメインの機能だけを意識すればよくなり、クラスの使い方がシンプルで分かりやすくなります。

public class ShoppingCart {

    // 外部に公開するメイン機能
    public int getPriceWithTax(int price) {
        // 内部処理はprivateメソッドを呼び出す
        int tax = calculateTax(price);
        return price + tax;
    }

    // 内部でのみ使用するヘルパーメソッド
    private int calculateTax(int price) {
        // (price * 0.1) のような計算処理
        return (int) (price * 0.1);
    }
}

鉄則3：定数は`public static final`で公開する

プログラム全体で共有し、決して変わることのない値（定数）は、`public static final`で定義するのがJavaの標準的な作法です。それぞれのキーワードには明確な意味があります。

• public
• どこからでもアクセスできるようにする。
• static
• インスタンスを生成しなくても、クラス名で直接アクセスできるようにする。（例：`AppConfig.TAX_RATE`）
• final
• 一度初期化したら、値を再代入できないようにする（定数であることを保証）。

この3つを組み合わせることで、安全で便利な定数を定義できます。

public class AppConfig {
    // 消費税率（プログラム全体で共通の値）
    public static final double TAX_RATE = 0.1;
    // アプリケーション名
    public static final String APP_NAME = "My Awesome App";
}

鉄則4：むやみに`public`を使わない

何でも`public`にしてしまうと、そのクラスの多くの部分が外部のクラスと密接に結びついてしまいます。これを「クラス間の依存度が高い」状態といいます。

この状態では、あるクラスの内部実装を少し変更しただけで、それを利用している全く別のクラスがエラーを起こす、という事態につながりかねません。

外部に公開する窓口（`public`なメンバ）を最小限に絞ることで、クラスの独立性が高まり、変更に強く、メンテナンスしやすいプログラムになります。

鉄則5：継承を意識するなら`protected`を検討する

`protected`は、「同じパッケージの仲間か、血縁関係（継承したサブクラス）にだけ見せる」という、少し特殊な修飾子です。これは、クラスの設計者が「このクラスを継承して、機能を拡張して使ってほしい」と意図している場合によく使われます。

フレームワークやライブラリの基底クラス（スーパークラス）で、サブクラスにオーバーライド（機能の上書き）を許可したいメソッドや、サブクラスで利用してほしいフィールドがある場合に、`protected`が役立ちます。

// スーパークラス
public abstract class Animal {
    private String name;

    // サブクラスで使ってほしい処理をprotectedにする
    protected void eat() {
        System.out.println("もぐもぐ...");
    }
}

// サブクラス
public class Dog extends Animal {
    public void bark() {
        System.out.println("わんわん！");
        // 親のprotectedメソッドを呼び出せる
        eat();
    }
}

鉄則6：getter/setterをうまく活用する

`private`なフィールドへのアクセス手段として、`public`なgetter（取得用）とsetter（設定用）のメソッドを用意することは、単に値の読み書きを許可するだけではありません。フィールドへのアクセスを完全にコントロールできるというメリットがあります。

例えば、setterを提供しないことで、そのフィールドを「読み取り専用」にできます。また、getterメソッドの内部で、フィールドの値をそのまま返すのではなく、特定のフォーマットに加工してから返すといった処理も可能です。

フィールドへのアクセスをメソッドという一枚の壁を挟んで行うことで、柔軟な制御が実現できます。

public class Employee {
    private String id;
    private String name;

    // idは一度設定したら変更できない（setterがない）
    public Employee(String id, String name) {
        this.id = id;
        this.name = name;
    }
    
    // idのgetter
    public String getId() {
        return this.id;
    }
    
    // nameのgetterとsetter
    public String getName() {
        return this.name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

鉄則7：トップレベルクラスに付けられる修飾子を理解する

ソースファイル（`.java`ファイル）に直接記述するクラスをトップレベルクラスと呼びます。このトップレベルクラスに付けられるアクセス修-飾子は`public`か`default`（何も書かない）の2種類だけです。

Javaのルールとして、「1つのソースファイルには、`public`なクラスは最大1つまでしか定義できず、そのクラス名はソースファイル名と一致させる必要がある」と定められています。これは、Javaのコンパイラがクラスを効率的に見つけるための仕組みです。

`default`のクラスは同じファイルに複数定義でき、これらは同じパッケージ内でのみ使用される補助的なクラスという位置づけになります。

なぜJavaにアクセス修飾子が必要なの？

ここでは、アクセス修飾子がなぜJavaという言語に備わっているのか、その背景にあるオブジェクト指向の重要な考え方「カプセル化」と絡めて解説します。

• オブジェクト指向の要「カプセル化」とは
• カプセル化がもたらす3つのメリット

オブジェクト指向の要「カプセル化」とは

カプセル化は、データ（フィールド）と、そのデータを操作する手続き（メソッド）をひとまとめにし、内部の詳細を外部から隠すことを指します。

テレビのリモコンを想像してみてください。私たちはボタンを押すだけでチャンネルを変えられますが、リモコン内部の電子回路がどう動いているかを知る必要はありません。必要な操作（ボタン）だけが公開され、複雑な仕組みは隠されています。Javaにおけるカプセル化も、この考え方と同じです。

アクセス修飾子、特に`private`は、このカプセル化を実現するための中心的な機能です。

+------------------------------------------------+
| class Television {                             |
|                                                |
|   // ▼ 外部から隠す内部データ (private)         |
|   private int currentChannel;                  |
|   private int volume;                          |
|                                                |
|   // ▼ 公開された操作 (public)                  |
|   public void changeChannel(int newChannel) {  |
|     // ...内部処理...                          |
|   }                                            |
|   public void volumeUp() {                       |
|     // ...内部処理...                          |
|   }                                            |
| }                                              |
+------------------------------------------------+

より詳しい情報は、Javaの公式チュートリアルでも確認できます。
引用元：Oracle Java Tutorials - Encapsulation

カプセル化がもたらす3つのメリット

カプセル化を徹底すると、プログラムに多くの恩恵があります。

• 安全性の向上
  不正な値がフィールドに設定されるのを防ぎ、オブジェクトの状態を常に正しく保てます。
• 保守性の向上
  クラスの内部実装を変更しても、公開している`public`メソッドの仕様さえ変わらなければ、そのクラスを利用している他のコードに影響が出ません。
• 再利用性の向上
  クラスの使い方がシンプルになり、他のプログラムでも部品として再利用しやすくなります。

Javaアクセス修飾子のエラーと解決策

Javaの学習中に、アクセス修飾子が原因で発生するコンパイルエラーに遭遇することはよくあります。ここでは、代表的なエラーとその原因、解決策を紹介します。

• ケース1：「... has private access in ...」
• ケース2：「... is not visible」
• Q&A：こんな時どうする？

ケース1：「... has private access in ...」

このエラーは、`private`で宣言されたフィールドやメソッドに、クラスの外部からアクセスしようとした場合に発生します。

// エラーが発生するコード
public class BankAccount {
    private double balance = 1000;
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        // privateなbalanceに直接アクセスしようとしてエラー
        System.out.println(account.balance); 
        // -> Error: balance has private access in BankAccount
    }
}

解決策：対象のフィールドにアクセスするための`public`なgetterメソッドを用意します。

// 修正後のコード
public class BankAccount {
    private double balance = 1000;

    // publicなgetterメソッドを追加
    public double getBalance() {
        return this.balance;
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        // getterメソッド経由でアクセスする
        System.out.println(account.getBalance()); // 実行結果: 1000.0
    }
}

ケース2：「... is not visible」

このエラーは、主に`default`（パッケージプライベート）のクラスやメンバに、別のパッケージからアクセスしようとした時に発生します。

// com.example.model パッケージ
package com.example.model;

class Product { // defaultクラス
    String name = "Laptop";
}

// com.example.main パッケージ
package com.example.main;
// import com.example.model.Product; // importはできるが...

public class App {
    public static void main(String[] args) {
        // Product product = new Product(); // ここでエラー
        // -> Error: Product is not visible
    }
}

解決策：他のパッケージから利用したいクラスやメンバには、`public`修飾子を付けます。

// 修正後のコード
package com.example.model;

public class Product { // publicクラスに変更
    public String name = "Laptop"; // フィールドもpublicに
}

Q&A：こんな時どうする？

• Q. コンストラクタにもアクセス修飾子を付けられますか？
  A. はい、付けられます。コンストラクタを`private`にすると、外部からインスタンスの生成を禁止できます。これは、シングルトンパターンなどで利用されるテクニックです。


• Q. `protected`と`default`の違いがよく分かりません。
  A. 両方とも同じパッケージからはアクセスできますが、`protected`は「別パッケージでもサブクラスならアクセス可能」という点が異なります。継承が関係するかどうかで使い分けます。

まとめ

この記事では、Javaの4つのアクセス修飾子について、その違いと実践的な使い方を解説しました。最後に、重要なポイントを振り返ります。

• Javaのアクセス修飾子は、クラスやメンバへのアクセス範囲を制御する仕組み。
• `public`, `protected`, `default`, `private`の4種類があり、`private`が最も範囲が狭い。
• 基本は「最小権限の法則」に従い、できるだけ公開範囲を狭くするのが良い設計。
• フィールドは原則`private`にし、カプセル化を意識することがコードの安全性を高める。
• アクセス修飾子を正しく使い分けることで、保守性と再利用性の高いプログラムが書けるようになる。

アクセス修飾子は、一見地味なルールに見えるかもしれません。しかし、大規模な開発になるほど、その重要性は増していきます。

今回学んだ知識を活かして、より品質の高いコードを目指してください。