本文へスキップ

本ページはプロモーションが含まれています

Java入門

Javaカプセル化とは?ゲッター/セッターの落とし穴と練習問題

CATEGORY
DRAWN BY
TOM
DATE
REV.
READ
約27分
SHEETS
10枚
カプセル化(privateとセッターの設計)

トム

SESで約8年、環境を変えられないもどかしさの中にいました。32歳で自社開発企業に転職し、今はClaude Codeと自動化で、仕事も時間も組み直している途中です。
・Javaバックエンドエンジニア(Java歴12年以上)
・資格:基本情報技術者/応用情報技術者/Java Silver/Python3エンジニア認定基礎
詳細なプロフィール

𝕏

価格がマイナス120円のボールペンを3本買うと、合計はマイナス360円。

Javaでフィールドを public のままにしておくと、こんな値がエラーも出ずに通ります。

カプセル化とは、フィールドを private で隠し、値を変える入口をクラスのメソッドに絞って、ルールに合わない値を入れさせない設計です。

ただ、private にしてゲッター/セッターを全部付けただけでは、ほとんど何も守れていません。

セッターを作らない設計、不変オブジェクトとrecord、List を返すときの防御的コピーまで、手元で動かした出力つきで順に確かめます。最後に答えつきの練習問題を4問置きました。

この記事でわかること

  • カプセル化の意味と、オブジェクト指向の三要素(カプセル化・継承・ポリモーフィズム)の中での役割
  • public フィールドの事故を private +検証つきセッターで止める前後のコード
  • ゲッター/セッターを機械的に全部付けるとカプセル化にならない理由と、セッターを作らない書き方
  • List.copyOf と Collections.unmodifiableList の違い(実行結果で比較)
  • 既存のクラスにあとからカプセル化を入れる手順
  • 答えつきの練習問題4問

コードはすべて OpenJDK 23.0.1 の javac でコンパイルし、java で実行した出力をそのまま載せています。List.copyOf は Java 10 以降、record は Java 16 以降で使えます。それ以外のコードは Java 8 でも同じように動きます。

PARTS LIST /目次

Javaのカプセル化とは?データと操作をひとまとめにして隠すこと

Javaのカプセル化とは、フィールドと、フィールドを扱うメソッドを1つのクラスにまとめる設計です。外のクラスには決められたメソッドだけを見せ、中身を直接は触らせません。

言葉だけ聞くと「隠す」ほうに目が行きます。けれど、隠すこと自体は手段です。

カプセル化の目的は、そのクラスの値がいつ見ても正しい状態にあると言い切れるようにすることにあります。価格は0円以上、在庫はマイナスにならない、終了日は開始日より後。こうした約束をクラスの中だけで守り切れれば、使う側はいちいち値を疑わずに済みます。

カプセル化で守るのは「値のルール」

カプセル化で守る対象は、フィールドそのものというより、そのフィールドが満たすべきルールです。

たとえば商品クラスなら、次のようなルールが考えられます。

  • 商品名は空にできない
  • 価格は0円以上
  • 在庫は0個以上で、在庫を超えて出荷できない

フィールドが public だと、ルールを確かめるコードをクラスの外のあちこちに書くしかありません。1か所でも書き忘れたら、そこから不正な値が入ります。

private にしておけば、値を変えられる場所がクラスの中のメソッドだけになります。チェックを書く場所も、バグを探す場所も、そのクラス1つに絞れるわけです。

たとえで言うと、自動販売機の「お金の口」と「ボタン」

カプセル化をわかりやすく言うなら、自動販売機の作りがそのままたとえに使えます。

利用者に見えているのは、お金を入れる口と、商品のボタンと、取り出し口だけです。中の在庫の数や、おつりの硬貨の枚数を、利用者が直接書き換えることはできません。

外に見せるもの(public メソッド)

お金を入れる口・商品のボタン・取り出し口
→ insert(int)・push(String) のような入口

中に隠すもの(private フィールド)

在庫の数・おつり用の硬貨・売上の記録
→ stock・coins・sales のような値

ボタンを押したときに「在庫があるか」「お金が足りているか」を確かめるのは、自動販売機の中の仕組みの仕事です。利用者が在庫の数を見て、自分で判断して、自分で商品を取り出すわけではありません。

もし中の在庫を誰でもいじれたら、売上の記録と在庫の数がすぐに合わなくなります。クラスも同じで、値を守る判断はクラスの中に置き、外には「何をしてほしいか」を伝える入口だけを出します。

自動販売機を3つのクラスに分けて作る練習は、Java自動販売機の作り方で手順つきで扱っています。

アクセス修飾子との住み分け

カプセル化を実現する道具が、private や public といったアクセス修飾子です。

アクセス修飾子は「どこから見えるか」を決める文法で、カプセル化は「何を隠して、どんな入口を用意するか」を決める設計の話です。文法を知っていても設計は決まらないので、別々に押さえておくと迷いません。

  • 4種類(public・protected・修飾子なし・private)の範囲の違い、protected の落とし穴、エラーの読み方 → Javaアクセス修飾子4つの違いと使い分け
  • なぜ隠すのか、セッターをどこまで作るか、リストをどう返すか → この記事

修飾子の範囲がまだあいまいなら、先にそちらを読んでおくと、このあとのコードが読みやすくなります。

オブジェクト指向の三要素での位置づけ

オブジェクト指向の三要素は、カプセル化・継承・ポリモーフィズムの3つです。並べて語られることが多いものの、役割はかなり違います。

要素一言でいうとJavaで使う主な文法
カプセル化クラスの中身を守り、入口を絞るprivate、メソッド、final、record
継承親クラスの性質を子クラスが引き継ぐextends
ポリモーフィズム同じ呼び出しで、実体ごとに違う動きをするオーバーライド、インターフェース

継承とポリモーフィズムは「クラス同士の関係」の話です。カプセル化は、その手前にある「1つのクラスが自分の値を守れているか」の話です。

1つ1つのクラスが自分のルールを守れていないと、継承で子クラスを増やしても、ポリモーフィズムで差し替えても、壊れた値がそのまま広がります。三要素のうち最初に身につけたいのがカプセル化なのは、このためです。

逆向きの関係もあります。外に見せているのがメソッドだけのクラスは、中身の違う別のクラスに差し替えても、呼び出し側から見た使い方が変わりません。ポリモーフィズムで実装を入れ替えられるのは、中身を隠してメソッドだけで付き合う形が先にできているからです。

三要素をまとめて俯瞰したい場合はJavaオブジェクト指向とは?3大要素の仕組み、継承の書き方はJava extendsの使い方で扱っています。この記事ではカプセル化だけを深く掘ります。

publicフィールドで不正な値が入る例と直し方

public フィールドのクラスを1つ書いて、どこで何が壊れるかを実際に見てみます。

用意するのは、商品名・価格・在庫を持つだけの小さなクラスです。直す前と直した後で、同じ操作をしたときの出力を比べます。直した後は、コンパイルが通るかどうかも変わります。

Before:マイナスの価格と在庫がそのまま通る

まずはフィールドをすべて public にした版です。

class Product {
    public String name;
    public int price;      // 誰でも書き換えられる
    public int stock;

    Product(String name, int price, int stock) {
        this.name = name;
        this.price = price;
        this.stock = stock;
    }
}

public class Main {
    public static void main(String[] args) {
        Product pen = new Product("ボールペン", 120, 10);

        // どこか遠くのクラスで、うっかりこう書かれたとする
        pen.price = -120;
        pen.stock = pen.stock - 15;

        int total = pen.price * 3;
        System.out.println(pen.name + " を3本: " + total + "円");
        System.out.println("在庫: " + pen.stock + "本");
    }
}

実行結果です。

ボールペン を3本: -360円
在庫: -5本

コンパイルも実行もエラーなしで終わりました。ここが厄介なところで、壊れた値が入った瞬間には誰も気づきません。

マイナスの合計金額は、画面に表示されたり集計に混ざったりしたときに初めて発覚します。そのとき調べる必要があるのは、pen.price に代入している全部の行です。プロジェクトが大きくなるほど、その行数は増えていきます。

After:privateと検証つきセッターで止める

次に、フィールドを private にして、価格を変える入口を setPrice だけにした版です。

class Product {
    private final String name;
    private int price;
    private int stock;

    Product(String name, int price, int stock) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("商品名が空です");
        }
        this.name = name;
        setPrice(price);
        if (stock < 0) {
            throw new IllegalArgumentException("在庫はマイナスにできません: " + stock);
        }
        this.stock = stock;
    }

    public String getName() {
        return name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        if (price < 0) {
            throw new IllegalArgumentException("価格はマイナスにできません: " + price);
        }
        this.price = price;
    }

    public int getStock() {
        return stock;
    }
}

public class Main {
    public static void main(String[] args) {
        Product pen = new Product("ボールペン", 120, 10);

        try {
            pen.setPrice(-120);
        } catch (IllegalArgumentException e) {
            System.out.println("止まった: " + e.getMessage());
        }

        // pen.price = -120;  ← コンパイルエラー(price has private access in Product)

        System.out.println(pen.getName() + " を3本: " + pen.getPrice() * 3 + "円");
        System.out.println("在庫: " + pen.getStock() + "本");
    }
}
止まった: 価格はマイナスにできません: -120
ボールペン を3本: 360円
在庫: 10本

マイナスの価格は setPrice の中で例外になり、元の120円が残りました。

変わった点は3つあります。

  • 価格のルールが setPrice の1か所に集まった
  • コンストラクタでも同じ検証を通すので、作った瞬間から正しい値しか持たない
  • 在庫にはセッターを付けていない(理由は次の章で扱います)

コンストラクタの中で setPrice(price) を呼んでいるのは、検証を2回書かないためです。ルールが変わったときに直す場所が1つで済みます。

クラスの外から直接書き換えるとコンパイルエラーになる

private の効き目は、実行するより前、コンパイルの時点で出ます。private なフィールドに外から代入するコードを書くと、javac が止めてくれます。

class Product {
    private int price;

    public int getPrice() {
        return price;
    }
}

public class Main {
    public static void main(String[] args) {
        Product pen = new Product();
        pen.price = -120;
    }
}
Main.java:12: エラー: priceはProductでprivateアクセスされます
        pen.price = -120;
           ^
エラー1個

英語環境では error: price has private access in Product と表示されます。

Beforeのコードでは、実行して画面を見るまで壊れたことが分かりませんでした。Afterでは、書いた時点でエラーとして教えてもらえます。

見つかるタイミングが実行後からコンパイル時に前倒しになる。カプセル化の一番わかりやすい効果は、ここにあります。

ゲッター/セッターを全部付けるとカプセル化にならない理由

IDEには、フィールドからゲッター/セッターを一括で作る機能があります。便利なので、フィールドを書いたらとりあえず全部生成する、という癖が付きがちです。

ところが、何もチェックしないセッターを全部 public で付けると、外から何でも代入できる状態に戻ります。public フィールドとの違いは、書き方が pen.price = -120 から pen.setPrice(-120) に変わっただけ、ということになりかねません。

検証なしのセッターはpublicフィールドとほぼ同じ

次の2つを見比べると、守れている範囲はほぼ同じです。

publicフィールド

pen.stock = -5;
どこからでも代入できる。チェックはどこにもない。

private+検証なしセッター

pen.setStock(-5);
どこからでも呼べる。書き方が変わっただけで、チェックはどこにもない。

セッターに意味があるのは、中に検証を書いたときだけです。

判断が呼び出し側に散らばると、書き忘れが出る

もう1つの問題は、セッターがあると「値を決めるロジック」がクラスの外に出ていくことです。在庫を減らしたい側が getStock() で値を取り出し、引き算して setStock() で戻す。在庫が足りるかの判断は、呼び出し側のコードに散らばります。

散らばった判断は、呼び出し側が増えるたびに書き直されます。在庫を減らすクラスが2つある例で確かめます。

class Inventory {
    private int stock;

    Inventory(int stock) { this.stock = stock; }

    public int getStock() { return stock; }
    public void setStock(int stock) { this.stock = stock; }
}

class OrderService {
    // 通常の注文: 在庫を確かめてから減らす
    void order(Inventory inv, int amount) {
        if (inv.getStock() >= amount) {
            inv.setStock(inv.getStock() - amount);
        } else {
            System.out.println("注文: 在庫不足");
        }
    }
}

class SampleService {
    // あとから別の人が書いたサンプル配布: 確認を書き忘れた
    void giveSample(Inventory inv, int amount) {
        inv.setStock(inv.getStock() - amount);
    }
}

public class Main {
    public static void main(String[] args) {
        Inventory pen = new Inventory(3);
        new OrderService().order(pen, 5);
        new SampleService().giveSample(pen, 5);
        System.out.println("在庫: " + pen.getStock());
    }
}
注文: 在庫不足
在庫: -2

OrderService はきちんと在庫不足を止めました。それなのに、SampleService 経由で在庫はマイナス2個になっています。

Inventory のフィールドは private です。文法の上では隠せているのに、守りたかった「在庫はマイナスにならない」は守れていません。

ルールを知っているのが OrderService だけで、Inventory 自身は何も知らないからです。呼び出し側が3つ、4つと増えるたびに、同じ if を書き写す必要が出てきます。

直すなら、値を取り出して外で判断するのをやめ、クラスに「出荷して」と頼む形に変えます。

セッターを作らず「何をしたいか」をメソッドにする

在庫が変わる理由は、入荷と出荷の2つしかありません。それなら setStock(int) の代わりに、理由ごとのメソッドを用意します。

class Inventory {
    private final String item;
    private int stock;

    Inventory(String item, int stock) {
        if (stock < 0) {
            throw new IllegalArgumentException("在庫はマイナスにできません: " + stock);
        }
        this.item = item;
        this.stock = stock;
    }

    // setStock(int) は作らない。在庫が変わる理由ごとにメソッドを分ける
    public void receive(int amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("入荷数は1以上: " + amount);
        }
        stock += amount;
    }

    public void ship(int amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("出荷数は1以上: " + amount);
        }
        if (amount > stock) {
            throw new IllegalStateException(item + " の在庫が足りません(在庫 " + stock + "、出荷 " + amount + ")");
        }
        stock -= amount;
    }

    public int getStock() {
        return stock;
    }
}

public class Main {
    public static void main(String[] args) {
        Inventory pen = new Inventory("ボールペン", 10);
        pen.receive(5);
        pen.ship(12);
        System.out.println("在庫: " + pen.getStock());

        try {
            pen.ship(4);
        } catch (IllegalStateException e) {
            System.out.println("止まった: " + e.getMessage());
        }
        System.out.println("在庫: " + pen.getStock());
    }
}
在庫: 3
止まった: ボールペン の在庫が足りません(在庫 3、出荷 4)
在庫: 3

10個に5個入荷して12個出荷し、残りは3個。続けて4個出荷しようとしたところで止まり、在庫は3個のままです。

「在庫を超えて出荷できない」というルールは、setStock では書けません。セッターは新しい値しか受け取らないので、それが出荷の結果なのか、棚卸しで数え直した結果なのか区別がつかないからです。

ship という名前のメソッドなら、出荷だと分かったうえで判断できます。メソッド名がそのまま業務の言葉になるので、呼び出し側のコードも読みやすくなります。

セッターを作るか迷ったときの判断の流れ

フィールドごとに、次の順で考えると決めやすくなります。

flowchart TD
    A["フィールドを追加した"] --> B{"作った後に<br/>値が変わる?"}
    B -->|"変わらない"| C["final にして<br/>セッターを作らない"]
    B -->|"変わる"| D{"変わる理由が<br/>決まっている?"}
    D -->|"決まっている"| E["理由ごとのメソッド<br/>(ship・receive など)"]
    D -->|"自由に変えてよい"| F["検証つきの<br/>セッターを作る"]

迷ったら「作らない」側に倒しておくのが安全です。あとからセッターを足すのは簡単ですが、一度公開したセッターを消すと、それを呼んでいる全部のコードが動かなくなります。

ゲッターも同じで、外から読む必要がない値には付けなくて構いません。

Lombokの@Dataでセッターが増える問題

Lombok の @Data を付けると、全フィールドのゲッターに加えて、final でないフィールドすべてにセッターが生成されます。手で書かないぶん、セッターが増えていることに気づきにくくなります。

カプセル化を気にするクラスでは、@Data を避けて @Getter だけを付ける、セッターが要るフィールドだけ個別に @Setter を付ける、という使い方が向いています。

ハマりポイント
生成されたセッターは、コードに書かれていないぶん見落とす

IDEの一括生成もLombokの@Dataも、セッターを「作ったつもりがないのに存在する」状態にしがちです。クラスを書き終えたら、外から値を変えられる入口が何個あるかを一度数えてみてください。入口の数が、そのクラスで守るべき場所の数になります。

Lombokの各アノテーションの生成内容と注意点はLombokとは?使い方入門にまとめています。

不変オブジェクトとrecordでセッターをなくす

作った後に値が変わらないクラスは、不変(イミュータブル)オブジェクトと呼ばれます。値が変わらないので、正しい値で作れた時点で、その後ずっと正しいままです。

セッターを作らない設計を最後まで進めると、ここに行き着きます。Javaでは final を使った手書きのクラスと、record の2通りで書けます。

finalクラスとfinalフィールドで不変にする

金額を表す Money クラスを、不変オブジェクトとして書いてみます。

final class Money {
    private final int amount;

    Money(int amount) {
        if (amount < 0) {
            throw new IllegalArgumentException("金額はマイナスにできません: " + amount);
        }
        this.amount = amount;
    }

    // 自分を書き換えず、新しい Money を返す
    Money add(Money other) {
        return new Money(this.amount + other.amount);
    }

    int amount() {
        return amount;
    }
}

public class Main {
    public static void main(String[] args) {
        Money price = new Money(120);
        Money total = price.add(new Money(80));

        System.out.println("price = " + price.amount());
        System.out.println("total = " + total.amount());
    }
}
price = 120
total = 200

add を呼んでも price は120円のままで、合計は新しい Money として返ってきます。

不変にするための決まりは次の3つです。

  • クラスに final を付けて、サブクラスで書き換えられないようにする
  • フィールドを private final にして、コンストラクタで一度だけ値を入れる
  • 値を変えたいときは、自分を書き換えず新しいインスタンスを返す

add の中で other.amount と、別のインスタンスの private フィールドを読んでいる点にも注目です。Javaの private は「同じクラスの中なら読める」という範囲なので、インスタンスが違っても同じ Money クラスのコードからは触れます。

recordなら検証つきの不変クラスが数行で書ける

同じ Money を record で書くと、こうなります。

record Money(int amount) {
    // コンパクトコンストラクタ: 引数の検証だけを書く
    Money {
        if (amount < 0) {
            throw new IllegalArgumentException("金額はマイナスにできません: " + amount);
        }
    }

    Money add(Money other) {
        return new Money(amount + other.amount);
    }
}

public class Main {
    public static void main(String[] args) {
        Money total = new Money(120).add(new Money(80));
        System.out.println(total);
        System.out.println(total.amount());

        try {
            new Money(-1);
        } catch (IllegalArgumentException e) {
            System.out.println("止まった: " + e.getMessage());
        }
    }
}
Money[amount=200]
200
止まった: 金額はマイナスにできません: -1

record は、private final のフィールド、値を読むメソッド(amount())、equals・hashCode・toString を自動で用意します。セッターは作られません。

検証は、引数リストを省いた「コンパクトコンストラクタ」に書きます。手書きの final クラスとやっていることは同じで、記述量がぐっと減ります。

recordにしないほうがいいクラス

record は便利ですが、何でも record にすればよいわけでもありません。

前の章の Inventory のように、作った後に状態が変わっていくこと自体が役割のクラスは、record に向きません。record のフィールドは final なので、在庫を減らすたびに新しいインスタンスを作って差し替えることになります。どの変数が「いまの在庫」を持っているのか、かえって分かりにくくなります。

クラスの性格向いている書き方この記事の例
ルールつきの値(金額・期間・メールアドレスなど)record か final クラスMoney、Period
状態が変わることが役割(在庫・注文・カート)普通のクラス+目的別のメソッドInventory、PointCard
受け渡しだけの入れ物(DTO)recordなし

値として扱うものは不変に、変わっていくものは入口を絞ったクラスに。この2つを使い分けるだけで、セッターの数はかなり減ります。

record の構文、classとの違い、Spring Bootでの使いどころはJavaのrecordとは?で詳しく扱っています。

LOGDDDの本を読んだあと「int で持っていた金額」をクラスにするようになった

仕事でドメイン駆動設計を使うことになり、『ドメイン駆動設計入門』を読みました。読んでから変えたことの1つが、値オブジェクトを使うようになったことです。上の Money や、このあと練習問題で作る Period がまさにそれで、ルールつきの値を不変のクラスにして持ち歩く書き方です。

金額を int のまま持っていると、「マイナスにならない」というルールは使う側が毎回思い出すしかありません。Money にしておけば、ルールは型そのものが運んでくれます。

本の中身と、読んで変えたことはドメイン駆動設計入門の書評に書いています。

Listや配列を返すゲッターは防御的コピーが要る

フィールドを private final にしても、中身が List のような変更できるオブジェクトだと、守りに穴が開きます。final で固定されるのは「どのリストを指しているか」だけで、リストの中身は外から追加も削除もできるからです。

中身まで守る手段が防御的コピーで、受け取るときと返すときにリストを写しておく書き方を指します。よく使われる Collections.unmodifiableList と List.copyOf は似て見えて動きが違うので、3つの書き方を同じ操作で比べます。

3つの書き方を同じ操作で比べるコード

チームのメンバー一覧を持つクラスを、3通りに書きました。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

// 1. 受け取ったリストをそのまま持ち、そのまま返す
class TeamRaw {
    private final List<String> members;
    TeamRaw(List<String> members) { this.members = members; }
    List<String> getMembers() { return members; }
}

// 2. 返すときだけ Collections.unmodifiableList で包む
class TeamView {
    private final List<String> members;
    TeamView(List<String> members) { this.members = members; }
    List<String> getMembers() { return Collections.unmodifiableList(members); }
}

// 3. 受け取るときに List.copyOf でコピーし、そのコピーを返す
class TeamCopy {
    private final List<String> members;
    TeamCopy(List<String> members) { this.members = List.copyOf(members); }
    List<String> getMembers() { return members; }
}

public class Main {
    public static void main(String[] args) {
        List<String> source = new ArrayList<>(List.of("佐藤", "鈴木"));
        TeamRaw raw = new TeamRaw(source);
        TeamView view = new TeamView(source);
        TeamCopy copy = new TeamCopy(source);

        // (a) 呼び出し側が元のリストを書き換える
        source.add("高橋");
        System.out.println("(a) raw  = " + raw.getMembers());
        System.out.println("(a) view = " + view.getMembers());
        System.out.println("(a) copy = " + copy.getMembers());

        // (b) ゲッターで受け取ったリストに足そうとする
        raw.getMembers().add("田中");
        System.out.println("(b) raw  = " + raw.getMembers());
        try {
            view.getMembers().add("田中");
        } catch (UnsupportedOperationException e) {
            System.out.println("(b) view = UnsupportedOperationException");
        }
        try {
            copy.getMembers().add("田中");
        } catch (UnsupportedOperationException e) {
            System.out.println("(b) copy = UnsupportedOperationException");
        }

        // (c) null が混ざったリストを渡す
        List<String> withNull = new ArrayList<>();
        withNull.add(null);
        System.out.println("(c) view = " + new TeamView(withNull).getMembers());
        try {
            new TeamCopy(withNull);
        } catch (NullPointerException e) {
            System.out.println("(c) copy = NullPointerException");
        }
    }
}
(a) raw  = [佐藤, 鈴木, 高橋]
(a) view = [佐藤, 鈴木, 高橋]
(a) copy = [佐藤, 鈴木]
(b) raw  = [佐藤, 鈴木, 高橋, 田中]
(b) view = UnsupportedOperationException
(b) copy = UnsupportedOperationException
(c) view = [null]
(c) copy = NullPointerException

そのまま返すと、外から中身が変わる

TeamRaw は (a) と (b) の両方で中身が変わりました。

(a) は、コンストラクタに渡した source を呼び出し側が書き換えた結果です。TeamRaw は渡されたリストそのものを指しているので、外の変更がそのまま映ります。

(b) は、ゲッターで受け取ったリストに add しただけで、チームに「田中」が入ってしまいました。フィールドは private final なのに、です。

参照の共有がどう起きるかはJavaのインスタンスとは?の「代入するとインスタンスは共有される」で図にしています。

Collections.unmodifiableListは「読み取り専用の窓」

TeamView は、(b) の追加を UnsupportedOperationException で止めました。一方で、(a) では元のリストに足した「高橋」が見えています。

Collections.unmodifiableList が返すのは、元のリストをのぞく読み取り専用の「ビュー(窓)」です。窓越しには書き込めませんが、窓の向こうの元のリストが変われば、見える中身も変わります。

内部のリストを自分で育てていくクラスで、「外からは触らせないが、最新の状態は見せたい」ときに向いています。null の要素もそのまま通します。

List.copyOfは「その時点の写し」

TeamCopy は、(a) でも (b) でも中身が変わりませんでした。

List.copyOf は、渡されたコレクションの要素を写した、変更できない新しいリストを返します。写した後に元のリストが変わっても、写しには映りません。追加や削除をしようとすると UnsupportedOperationException になります。

注意点は、null を1つでも含むと NullPointerException になることです。(c) の結果がそれにあたります。外部から受け取るデータに null が混ざりうるなら、先に取り除くか、new ArrayList<>(members) で写してから Collections.unmodifiableList で包む書き方を選びます。

3つの違いを表にまとめます。

書き方元のリストを変えたとき受け取ったリストに addnull の要素
そのまま返す× 変更が映る× 追加できてしまう通る
Collections.unmodifiableList△ 変更が映る(ビュー)○ 例外で止まる通る
List.copyOf○ 映らない(写し)○ 例外で止まるNullPointerException
ハマりポイント
「変更できないリスト」でも、中の要素までは守られない

List.copyOf も Collections.unmodifiableList も、守るのはリストの「並び」(追加・削除・差し替え)だけです。要素が変更できるオブジェクトなら、getMembers().get(0) で取り出した要素のセッターを呼ぶと中身が変わります。要素まで守りたいときは、要素のクラス自体を不変にします。String や record を要素にすると、この心配が無くなります。

recordでもListのフィールドは写しておく

record は不変と言われますが、守ってくれるのは「どのオブジェクトを指しているか」までです。部品に List を持つ record は、コンパクトコンストラクタで写しに差し替えておきます。

import java.util.ArrayList;
import java.util.List;

record LooseTeam(List<String> members) { }

record Team(List<String> members) {
    Team {
        members = List.copyOf(members);  // 受け取った時点の写しに差し替える
    }
}

public class Main {
    public static void main(String[] args) {
        List<String> source = new ArrayList<>(List.of("佐藤", "鈴木"));
        LooseTeam loose = new LooseTeam(source);
        Team team = new Team(source);

        source.add("高橋");
        System.out.println("loose = " + loose.members());
        System.out.println("team  = " + team.members());
    }
}
loose = [佐藤, 鈴木, 高橋]
team  = [佐藤, 鈴木]

コンパクトコンストラクタの中で引数 members に代入すると、その値がフィールドに入ります。List.copyOf で作ったリストは変更できないので、members() で返す値をさらに写す必要はありません。

List そのものの使い方はJava Listの使い方、List・Set・Map の使い分けはJavaコレクション入門で扱っています。

配列を返すゲッターも同じ穴がある

List と同じ穴は、配列にもあります。配列には「変更できない配列」がないので、受け取るときと返すときに clone() で写します。

import java.util.Arrays;

class Scores {
    private final int[] values;

    Scores(int[] values) {
        this.values = values.clone();   // 受け取るときに写す
    }

    int[] getValuesRaw() {
        return values;                  // 中身をそのまま渡す
    }

    int[] getValues() {
        return values.clone();          // 写しを渡す
    }
}

public class Main {
    public static void main(String[] args) {
        Scores s = new Scores(new int[] {80, 65, 90});

        s.getValues()[0] = 0;
        System.out.println("写しを書き換えた後: " + Arrays.toString(s.getValues()));

        s.getValuesRaw()[0] = 0;
        System.out.println("中身を書き換えた後: " + Arrays.toString(s.getValues()));
    }
}
写しを書き換えた後: [80, 65, 90]
中身を書き換えた後: [0, 65, 90]

写しを返す getValues() 経由の書き換えは、元の点数に影響しませんでした。中身をそのまま返す getValuesRaw() 経由だと、1つめの点数が0点に書き換わっています。

配列は呼び出し側で並べ替えたり書き換えたりしやすいので、外に返す必要があるなら、最初から List.copyOf で包んだ List を返す設計にしておくと迷いが減ります。

日付も同じで、古い java.util.Date は setTime で中身を変えられるオブジェクトです。フィールドに持つなら、作った後に変わらない java.time.LocalDate や LocalDateTime を選ぶと、写す手間そのものが要らなくなります。

既存のクラスにあとからカプセル化を入れる4ステップ

新しく書くクラスなら、最初から private で始めればすみます。困るのは、すでに public フィールドのまま使われているクラスです。

どこから直接書き換えられているか分からないクラスに、いきなりセッターを足しても、直接代入している行は残ったままです。順番を決めて進めると、取りこぼしなく直せます。コンパイラに呼び出し元を探してもらうのがコツです。

フィールドをprivateにして、コンパイラに場所を探させる

step
1
フィールドをすべて private にしてコンパイルする

最初の Before のコードで、3つのフィールドを private に変えただけでコンパイルすると、直接触っている行がすべてエラーとして並びます。

Main.java:18: エラー: priceはProductでprivateアクセスされます
        pen.price = -120;
           ^
Main.java:19: エラー: stockはProductでprivateアクセスされます
        pen.stock = pen.stock - 15;
           ^
Main.java:19: エラー: stockはProductでprivateアクセスされます
        pen.stock = pen.stock - 15;
                       ^
Main.java:21: エラー: priceはProductでprivateアクセスされます
        int total = pen.price * 3;
                       ^
Main.java:22: エラー: nameはProductでprivateアクセスされます
        System.out.println(pen.name + " を3本: " + total + "円");
                              ^
Main.java:23: エラー: stockはProductでprivateアクセスされます
        System.out.println("在庫: " + pen.stock + "本");
                                       ^
エラー6個

この6個が、クラスの外からフィールドに触っている場所の一覧です。検索で探すと、変数名が違う呼び出しや、似た名前の別フィールドで漏れや誤りが出ます。コンパイラなら型を見て判定するので、見落としません。

javac が1回に表示するエラーは100個までです。手元で150か所の代入を書いて試すと、only showing the first 100 errors, of 150 total; use -Xmaxerrs if you would like to see more と出ました。全部を見たいときは -Xmaxerrs で上限を上げるか、表示された分を直してからもう一度コンパイルします。

エラーの行を「読むだけ」と「変える目的」で分ける

step
2
エラーの行を、何をしているかで分ける

並んだエラーを、次の3つに分けます。

種類上の例での該当行置き換え先
値を読んでいるだけ21行目・22行目・23行目ゲッター(getPrice() など)
決まった目的で値を変えている19行目(出荷で在庫を減らす)目的別のメソッド(ship(int))
何でも入れられる形で代入している18行目(価格を直接代入)検証つきのセッターか、その代入自体が要るかを見直す

18行目の「マイナスの価格を代入する」ような行は、分けている途中で「そもそもこの代入は正しいのか」という疑問が出てきます。カプセル化を入れる作業は、既存のバグを見つける作業にもなります。

目的別のメソッドを作り、検証をクラスへ移す

step
3
目的ごとにメソッドを作り、検証をそこへ集める

手順2で「決まった目的」に分けた行ごとに、ship や receive のようなメソッドを作ります。呼び出し側に書かれていた if の確認は、メソッドの中へ移します。

呼び出し側に同じ確認が何か所もあったなら、ここで1つにまとまります。前の章の OrderService と SampleService のように、確認を書き忘れていた呼び出し側も、メソッドを呼ぶだけで守られるようになります。

step
4
読むだけの行にゲッターを付け、残りは作らない

最後に、読むだけの行のためにゲッターを付けます。手順2で使い道が見つからなかったフィールドには、ゲッターもセッターも付けません。

直したあとは、Before の操作をもう一度流して、不正な値が例外で止まるかを確かめます。単体テストがあるなら、「マイナスを渡すと例外になる」ケースを1つ足しておくと、あとで誰かがセッターを足したときにも気づけます。

カプセル化のメリットと、やりすぎの線引き

ここまでのコードで見てきた効果を、メリットとして整理しておきます。あわせて、どこまでやるかの線引きも考えます。

全部のクラスを不変にして、全部のリストを写して…と進めると、今度はコードが重くなります。守る価値があるのはどこか、の見当をつけておくと手が止まりません。

カプセル化のメリット3つ

  • 不正な値を1か所で止められる:検証がクラスの1か所に集まり、書き忘れが起きにくい
  • バグの調べる範囲が狭くなる:値を変えられるのがクラスのメソッドだけなので、そこだけ読めばよい
  • 中身を変えても使う側が壊れない:外に見せているのがメソッドだけなら、フィールドの型や持ち方を変えても呼び出し側はそのまま動く

3つめは、あとから効いてきます。たとえば在庫を int から倉庫ごとの Map に持ち替えても、ship と getStock の使い方が同じなら、呼び出し側は1行も直さずに済みます。

やりすぎになりやすい場面

逆に、カプセル化をそこまで厳しくしなくてよい場面もあります。

  • 画面やAPIとの受け渡しだけに使う、ルールを持たない入れ物(DTO)。record にしておけば十分なことが多い
  • メソッドの中だけで使う一時的なリスト。外に返さないなら写す必要はない
  • テストのためだけにゲッターを足したくなったとき。テストは公開メソッドの結果で確かめ、内部のフィールドを覗かない書き方を先に考える

DTOとEntityの役割の違いはJavaのDTOとは?を参照してください。

LOG設計の入門書を読んだとき一番効いたのは「低凝集」の章だった

設計の基本を学び直したくて『良いコード/悪いコードで学ぶ設計入門』を読んだとき、役に立ったのは第5章の低凝集と、第8章の密結合でした。データを持つクラスと、そのデータを使う処理が別々の場所に散らばっている状態が低凝集です。

ゲッターで値を取り出して、外で計算して、セッターで戻す。さっきの setStock の書き方は、まさにその形です。読んでから、メソッドの名前を「何のためか」で付けるようにしました。setStock の代わりに ship と書くのも、その延長にあります。

本の感想は良いコード/悪いコードで学ぶ設計入門の書評にまとめています。

クラスを書き終えたときの5つの確認

ここまでの話を、クラスを1つ書き終えたときに見直す項目にすると、次の5つになります。

カプセル化の確認リスト

  1. public のフィールドが残っていないか
  2. コンストラクタで、ルールに合わない値を弾いているか
  3. 作った後に変わらない値は final になっているか
  4. セッターの代わりに、目的の分かる名前のメソッドにできないか
  5. List・配列・Date のような変更できるオブジェクトを、そのまま受け取ったり返したりしていないか

全部に「はい」と答えられなくても構いません。1番と2番だけでも、冒頭のマイナス価格のような事故はほとんど止まります。

3番から5番は、クラスが長く使われるほど効いてきます。使う人が増えたクラスほど、あとから入口を狭めるのが難しくなるからです。

Javaカプセル化の練習問題4問

読んで分かった気になったところで、手を動かして確かめます。問題1・3・4はクラスを書く問題、問題2は出力を予想する問題です。

答えと解説は、各問題の下の「答えと解説を見る」を開くと出てきます。先に自分で書いて実行してから開くと、ズレに気づけます。

問題1:会員の年齢を守るクラスにする(初級)

次の Member クラスは、年齢に何でも代入できてしまいます。

class Member {
    public String name;
    public int age;
}

次の条件を満たすように書き直してください。

  • 名前は作った後に変えられない
  • 年齢は0〜150の範囲だけ受け付け、範囲外なら IllegalArgumentException を投げる
  • 年齢を変える入口は、メソッド changeAge(int) の1つだけにする
答えと解説を見る
class Member {
  private final String name;
  private int age;

  Member(String name, int age) {
      this.name = name;
      changeAge(age);
  }

  public void changeAge(int age) {
      if (age < 0 || age > 150) {
          throw new IllegalArgumentException("年齢は0〜150: " + age);
      }
      this.age = age;
  }

  public String getName() { return name; }
  public int getAge() { return age; }
}

new Member("トム", 30) を作り、changeAge(31) → changeAge(-5) の順に呼んだときの実行結果です。

トム 31歳
止まった: 年齢は0〜150: -5
トム 31歳

名前は private final にしてセッターを作らず、年齢の検証は changeAge に1つだけ書きます。コンストラクタからも changeAge を呼ぶので、new Member("トム", -5) も同じ例外で止まります。メソッド名は setAge でも動きますが、「年齢を変える」という意図が名前から読めるほうを選びました。

問題2:unmodifiableListとcopyOfの出力を予想する(中級)

次のコードを実行すると、2行に何が表示されるでしょうか。実行する前に予想してください。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Cart {
    private final List<String> items = new ArrayList<>();

    void add(String item) { items.add(item); }

    List<String> viewItems() { return Collections.unmodifiableList(items); }
    List<String> copyItems() { return List.copyOf(items); }
}

public class Main {
    public static void main(String[] args) {
        Cart cart = new Cart();
        cart.add("りんご");

        List<String> v = cart.viewItems();
        List<String> c = cart.copyItems();

        cart.add("みかん");

        System.out.println(v.size());
        System.out.println(c.size());
    }
}
答えと解説を見る

答えは 2 と 1 です。

2
1

v は Collections.unmodifiableList が返したビューなので、あとから cart.add("みかん") で内部のリストが増えると、v からも2件に見えます。

c は List.copyOf が「りんご」1件の時点で作った写しなので、1件のままです。どちらも add しようとすると UnsupportedOperationException になる点は同じで、違いは「元の変化が見えるかどうか」だけです。

問題3:開始日と終了日をrecordで守る(応用)

セール期間を表す Period を record で作ってください。条件は次のとおりです。

  • 部品は開始日 start と終了日 end(どちらも java.time.LocalDate)
  • どちらかが null、または終了日が開始日より前なら IllegalArgumentException
  • 指定した日が期間内(開始日・終了日を含む)かを返す contains(LocalDate) を持つ
答えと解説を見る
import java.time.LocalDate;

record Period(LocalDate start, LocalDate end) {
  Period {
      if (start == null || end == null) {
          throw new IllegalArgumentException("日付が空です");
      }
      if (end.isBefore(start)) {
          throw new IllegalArgumentException("終了日が開始日より前です: " + start + " > " + end);
      }
  }

  boolean contains(LocalDate day) {
      return !day.isBefore(start) && !day.isAfter(end);
  }
}

12月1日〜25日の期間を作り、24日と26日で contains を呼び、最後に開始日と終了日を逆にして作ったときの実行結果です。

Period[start=2026-12-01, end=2026-12-25]
true
false
止まった: 終了日が開始日より前です: 2026-12-25 > 2026-12-01

検証はコンパクトコンストラクタに書くので、ルールに合わない Period はそもそも作れません。record にはセッターがないため、作った後に終了日だけ前にずらされる心配もありません。「開始日と終了日の組」のように、2つの値の関係がルールになっているものほど、1つのクラスにまとめて守る効果が出ます。

問題4:外で計算しているポイントをクラスへ移す(応用)

次のコードでは、ポイントの計算と残高の確認を Main が行っています。

class PointCard {
    private int points;
    public int getPoints() { return points; }
    public void setPoints(int points) { this.points = points; }
}

public class Main {
    public static void main(String[] args) {
        PointCard card = new PointCard();
        card.setPoints(card.getPoints() + 1_250 / 100);   // 100円ごとに1ポイント
        if (card.getPoints() >= 10) {
            card.setPoints(card.getPoints() - 10);        // 10ポイント使う
        }
    }
}

setPoints をなくし、ポイントを貯める earn(int yen) と使う use(int amount) を PointCard に作ってください。足りないポイントを使おうとしたら IllegalStateException を投げるようにします。

答えと解説を見る
class PointCard {
  private int points;

  // 100円ごとに1ポイント
  public void earn(int yen) {
      if (yen < 0) {
          throw new IllegalArgumentException("金額はマイナスにできません: " + yen);
      }
      points += yen / 100;
  }

  public void use(int amount) {
      if (amount <= 0) {
          throw new IllegalArgumentException("使うポイントは1以上: " + amount);
      }
      if (amount > points) {
          throw new IllegalStateException("ポイントが足りません(残り " + points + "、使用 " + amount + ")");
      }
      points -= amount;
  }

  public int getPoints() {
      return points;
  }
}

card.earn(1_250) → card.use(10) → card.use(5) の順に呼んだときの実行結果です。

残り: 2
止まった: ポイントが足りません(残り 2、使用 5)

1,250円で12ポイント貯まり、10ポイント使って残りは2ポイントです。続けて5ポイント使おうとしたところで止まりました。

「100円ごとに1ポイント」という計算の決まりと、「残りを超えて使えない」という確認が、どちらも PointCard の中に入りました。Main は「貯めて」「使って」と頼むだけになり、ポイントの付け方が変わっても earn の1か所を直せば済みます。

よくある質問

カプセル化について、検索でよく聞かれる疑問をまとめました。用語の違い(アクセス修飾子・情報隠蔽)と、List.copyOf やrecordの使い方、private がどこまで守ってくれるかの8つです。

Q1. Javaのカプセル化とは何ですか?

データ(フィールド)とそれを扱うメソッドを1つのクラスにまとめ、フィールドを private で隠して、決められたメソッドからしか値を変えさせない設計です。ルールに合わない値がクラスに入るのを防ぎます。

Q2. カプセル化のメリットは何ですか?

主に3つあります。不正な値をクラスの中の1か所で止められること、値を変えられる場所が限られてバグを調べる範囲が狭くなることです。さらに、フィールドの持ち方を変えても呼び出し側を直さずに済みます。

Q3. ゲッターとセッターを付ければカプセル化になりますか?

検証のないセッターを全部 public で付けると、外から何でも代入できるので public フィールドとほとんど変わりません。値が変わらないフィールドにはセッターを作らず、変わる理由が決まっているなら ship のような目的別のメソッドにします。

Q4. カプセル化とアクセス修飾子の違いは何ですか?

アクセス修飾子(public・protected・修飾子なし・private)は「どこから見えるか」を決める文法です。カプセル化は、その文法を使って何を隠し、どんな入口を用意するかを決める設計の考え方です。

Q5. List.copyOfとCollections.unmodifiableListの違いは何ですか?

Collections.unmodifiableList は元のリストの読み取り専用ビューで、元のリストが変わると見える中身も変わります。List.copyOf はその時点の要素を写した変更できないリストで、元が変わっても影響を受けません。List.copyOf は null の要素を含むと NullPointerException になります。

Q6. recordを使えばカプセル化は十分ですか?

record はフィールドを private final にし、セッターを作らないので、不変の値を作るのに向いています。ただし部品に List のような変更できるオブジェクトを持つ場合は、コンパクトコンストラクタで List.copyOf などを使って写しておく必要があります。

Q7. カプセル化と情報隠蔽の違いは何ですか?

情報隠蔽は、使う側が知らなくてよい内部の詳細を見えなくする考え方です。カプセル化は、データと操作を1つのクラスにまとめることを指し、Javaでは private を使った情報隠蔽とセットで実現します。入門の段階では、ほぼ同じ意味で使われていると考えて差し支えありません。

Q8. privateにしたフィールドは絶対に書き換えられませんか?

通常のコードからは書き換えられませんが、リフレクションの setAccessible(true) を使うと、自分で書いたクラスの private フィールドは書き換えられます。JDK の内部クラス(String の中身など)は Java 17 以降、同じことをすると InaccessibleObjectException で止まります。private が防ぐのは、うっかりの書き換えです。悪意のある操作まで止める仕組みとは考えないでください。

まとめ:カプセル化は「値を変える入口を絞る」設計

カプセル化は、private で隠すことそのものより、値を変えられる入口を絞って、クラスが自分のルールを守り切れるようにする設計です。

  • フィールドは private にし、検証はコンストラクタとメソッドの1か所に集める
  • 検証のないセッターを全部付けると、public フィールドとほぼ同じ
  • 値が変わらないなら final かrecordで不変にする。変わる理由が決まっているなら目的別のメソッドにする
  • List は List.copyOf で写すか、Collections.unmodifiableList で窓にする。違いは元の変化が見えるかどうか
  • 「変更できないリスト」でも中の要素までは守られない

冒頭のマイナス360円のボールペンは、setPrice に3行の if を書くだけで止まりました。逆に言えば、その3行を書く場所がクラスの中に用意されていなかったことが、public フィールドの本当の問題でした。

学ぶ順番の全体像はJava入門ロードマップで確認できます。

NEXT STEP
自分のコードからセッターのあるクラスを1つ選び、そのセッターを呼んでいる場所を全部検索してみる。

呼び出し元が「出荷」「取り消し」のように同じ目的で呼んでいるなら、そのセッターは目的別のメソッドに置き換えられます。1つ置き換えるだけで、ルールを書く場所がクラスの中に戻ってきます。

途中経過は、また書きます。

NEXT READ本棚から1本

AIで開発を組み直すなら、まずこの5冊から

入門・実践・設計まで、Claude Codeの本をレベル別に5冊選んで比べました。

→ おすすめ5冊を見る

トム

SESで約8年、環境を変えられないもどかしさの中にいました。32歳で自社開発企業に転職し、今はClaude Codeと自動化で、仕事も時間も組み直している途中です。
・Javaバックエンドエンジニア(Java歴12年以上)
・資格:基本情報技術者/応用情報技術者/Java Silver/Python3エンジニア認定基礎
詳細なプロフィール

𝕏

Java入門

TOC