enum Season {
    SPRING, SUMMER, FALL, WINTER;
}

「曜日」「四季」のように、選択肢が限られているものを表現するために使用されるため、enumは「選択肢の管理者」のような役割を果たします。

+---------------------+
|       enum Day      |  <-- 列挙型 (enum)
+---------------------+
| - MONDAY            |  <-- 定数1
| - TUESDAY           |  <-- 定数2
| - WEDNESDAY         |  <-- 定数3
| - THURSDAY          |  <-- 定数4
| - FRIDAY            |  <-- 定数5
| - SATURDAY          |  <-- 定数6
| - SUNDAY            |  <-- 定数7
+---------------------+

Javaの列挙型（enum）とは？

enumは、決まった範囲の値を１つの型としてまとめる役割を持つデータ型の一種（厳密にはjava.lang.Enumを継承したクラスとして扱われます）。

具体的な例として、曜日（MONDAY、TUESDAY）や四季（SPRING、SUMMER）を扱う際に便利なデータ型です。

例え話：レストランの注文で・・・

• レストランでは「ラーメン」「カレー」「ハンバーグ」など、メニューから選んで注文します。これ以外の注文が来ても対応できません。同様に、enumを使えば、プログラム内で定義した選択肢以外の無効な値を防ぐことができます。

enumを使わない場合の問題

選択肢を文字列（String）で扱う場合、タイプミスや異なる表記によるエラーが発生しやすくなります。以下の例を見てください。

// Stringを使った例（エラーの原因）
String day = "Mondai"; // スペルミスによるバグ

// enumを使った例（安全）
Day day = Day.MONDAY; // 決まった選択肢だけが使用可能

要するにタイプミスやコーディングミスを制限するために役立つのがenumのもう１つの側面でもあります。

enumの基本的な使い方：構文ルール

以下のように、Javaのenumは特定の選択肢を定数として宣言します。

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

ポイント　enumの基本的な性質：不変性

• 要素の追加・削除不可：enumの宣言後に要素を追加したり削除することはできません。
• 要素の再代入不可：プログラムの実行中にenumの要素を新しい値に変更することはできません。
• 定数はすべて暗黙的にfinalかつstatic：そのため、インスタンス化も変更もできません。

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

// 以下のコードはコンパイルエラーになる
Day today = Day.MONDAY;
// today = "Holiday"; // エラー: 型が一致しない

※enumの要素は型名.要素名で呼び出します（例：Day.MONDAY）。

public enum Color { RED, GREEN, BLUE; }

public final class Color extends java.lang.Enum<Color> {
    public static final Color RED = new Color("RED", 0);
    public static final Color GREEN = new Color("GREEN", 1);
    public static final Color BLUE = new Color("BLUE", 2);
    private static final Color[] $VALUES = { RED, GREEN, BLUE };

    private Color(String name, int ordinal) {
        super(name, ordinal);
    }

    public static Color[] values() {
        return $VALUES.clone();
    }

    public static Color valueOf(String name) {
        return Enum.valueOf(Color.class, name);
    }
}

enumの活用例

enumの要素は定数（staticなインスタンス）として定義されているので、クラス名.要素名の形で呼び出せます。

// 列挙型(enum)の定義
enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

public class EnumExample {
    public static void main(String[] args) {
        // 今日の曜日を設定
        Day today = Day.MONDAY;

        // 曜日に応じた条件分岐
        if (today == Day.MONDAY) {
            System.out.println("今日は月曜日です！");
        } else {
            System.out.println("今日は月曜日ではありません。");
        }
    }
}

出力例:

今日は月曜日です！

enumもクラスの一種！そして、enumの各定数は自動的にstatic finalなインスタンスとして生成される！

という点だけ頭に入れておけば基本的には自由に使いこなすことができるはずです。

enumの応用例

ここからは、enumの応用編です。より実践に近づけながら解説します。

enumにメソッドを追加する

enumは定数の集合だけでなく、メソッドを持たせることで、より柔軟な使い方が可能です。

参考　メソッドとは？

enumにメソッドを持たせる理由はなんでしょうか？

例えば「四季」や「状態」を表すenumがあったとしましょう。各季節に「気候の説明」を持たせたい場合、ただの定数ではそれを表現するのは難しいです。ここで、メソッドを使えば、それぞれの要素に必要な情報を持たせ、簡単に取得できるようになります。

// enumの定義：四季に説明を持たせる
enum Season {
    SPRING("暖かい"), 
    SUMMER("暑い"), 
    FALL("涼しい"), 
    WINTER("寒い");

    private final String description; // 各要素の説明を保持するフィールド

    // コンストラクタ：各要素を初期化
    Season(String description) {
        this.description = description;
    }

    // 説明を取得するメソッド
    public String getDescription() {
        return description;
    }
}

public class EnumMethodExample {
    public static void main(String[] args) {
        // SUMMERの説明を取得
        Season currentSeason = Season.SUMMER;
        System.out.println("今の季節は " + currentSeason + " で、" + currentSeason.getDescription() + "です。");
    }
}

出力結果：

今の季節は SUMMER で、暑いです。

enumの内部動作

enumは、内部的にクラス（参考　クラスとは？）として実装され、各要素はシングルトンインスタンスとして生成されます。つまり、同じenum要素を比較する際に==を使うことができ、常に正しい比較が保証されます。

1. enumがクラスとして実装されるとは？

Javaでは、enumはコンパイル時に特別なクラスとして変換されます。これは、各enum要素が通常のクラスインスタンスとして扱われるという意味です。しかし、開発者が自分でインスタンスを生成したり変更することはできません。

enumの内部クラス構造イメージ

以下は、enumが内部的にどのような形でクラスとして扱われるかをイメージ化したものです。

// 実際にはJavaコンパイラによってこのようなクラスに変換される
public final class Day extends Enum<Day> {
    public static final Day MONDAY = new Day("MONDAY", 0);
    public static final Day TUESDAY = new Day("TUESDAY", 1);
    // 他の曜日も同様に定義

    private Day(String name, int ordinal) {
        super(name, ordinal);
    }
}

2. シングルトンパターンの適用

• シングルトンパターンは、あるクラスのインスタンスが1つだけ存在することを保証するデザインパターンです。
• enumでは、このシングルトンの特性が自動的に適用されます。

enum要素はシングルトン

enumの各要素（例：MONDAY、TUESDAY）は、プログラム全体で一度だけ生成されるインスタンスです。これにより、同じ要素同士を比較するときに==演算子を使って正しく比較できるのです。

3. ==演算子による比較の正しさ

通常、Javaでは==演算子はオブジェクトの同一性（同じインスタンスかどうか）をチェックします。例えば、newキーワードで作成したオブジェクト同士を==で比較すると、異なるインスタンスなのでfalseになります。

例：newで作成したオブジェクトの比較

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);  // false

上記の例では、aとbは同じ内容でも、異なるインスタンスなのでfalseになります。

enumでの比較

しかし、enumの場合、各要素はシングルトンとして管理されているため、同じenum要素は常に同じインスタンスです。

Day day1 = Day.MONDAY;
Day day2 = Day.MONDAY;
System.out.println(day1 == day2);  // true

ポイント　enumの内部動作

• 各要素はstatic finalなインスタンスとして扱われます。
• Javaコンパイラはenumをクラスとして変換し、最適化します。
• ordinal()メソッドを使うと、要素のインデックスを取得できますが、順序に依存しない設計が推奨されます。

実務でのenumの活用例

プロジェクトの進捗状況の管理

public enum Status {
    PENDING, IN_PROGRESS, COMPLETED
}

プロジェクトの進捗を管理する際、enumを使って状態を表現することで、管理を簡潔にします。

Status projectStatus = Status.IN_PROGRESS;
if (projectStatus == Status.COMPLETED) {
    System.out.println("プロジェクトが完了しました！");
}

switch文との連携

switch文(参考　switch文の基本)とenumの組み合わせは、条件分岐を簡潔かつ可読性高く実装するのに有効です。

public class EnumSwitchExample {
    public static void main(String[] args) {
        Day day = Day.FRIDAY;

        switch (day) {
            case MONDAY:
                System.out.println("仕事が始まる日");
                break;
            case FRIDAY:
                System.out.println("週末の前日！");
                break;
            default:
                System.out.println("平日");
        }
    }
}

出力例:

週末の前日！

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

Day today = Day.MONDAY;
if (today == Day.MONDAY) {
    System.out.println("今日は月曜日です！");
}

まず最初にお伝えしたいのは、JSPは決して難しいものではありません。むしろ、「ちょっと動きのあるWebページを、できるだけ簡単に作りたい！」という人のために生まれたものなのです。近年では他の技術に取って代わられた印象が否めないJSPですが、昔からある巨大なレガシーシステムなどでは現役で、システムの更改案件などではよく目にすることがあります。

このページでは「JSPってそもそも何？」という一番大事な部分から、初心者向けに順を追って１からわかりやすく専門用語を避けて解説します。

JSPとは何か？

JSP（Java Server Pages）は、Javaを使ってWebページを動的に生成するための技術で、通常のHTMLファイルにJavaのコードを埋め込むことで、アクセスするたびに内容が変化するページを作成することを可能にします。

そのため、JSPはJavaをベースとしていますが、HTMLの知識があれば、基本的な使い方は十分に理解することができます。

【前提１】静的なページと動的なページ

Webページには、大きく分けて2種類あります。
1つは「静的なページ」、もう1つは「動的なページ」です。

静的コンテンツ/動的コンテンツの違いを１分で解説【初心者向け】

【初心者向け】「動的」「静的」という言葉の意味とその違いを端的に解説します。本で学習したがイマイチ理解できない、、、結局一言でいうと違いは何？という疑問をお持ちの方に具体例を用いながら分かりやすく解説します。

it-biz.online

2020.05.15

静的なページとは、内容があらかじめ決まっていて、アクセスするたびに同じ内容が表示されるページです。たとえば、自己紹介だけが書かれた会社のホームページや、お知らせ一覧だけが載っているページなどが該当します。

一方、動的なページは、アクセスした時点の情報や、閲覧しているユーザーの状態に応じて内容が変わります。たとえば、ショッピングサイトで商品が表示されたり、ログイン中のユーザー名が画面に表示されたりするページがそうです。

静的なページはHTMLだけで作成できますが、動的なページを作るには、プログラムによってページの内容を生成する仕組みが必要です。JSPは、そのような仕組みの一つです。

もちろんJSP以外にも同じようなことを実現することが可能で、現代ではほとんどJSP以外が主役です。なのですが、レガシーシステムでは今でも現役で動いていることが多いので「まあ知っておいて損はないかな」というのがJSPの位置づけです。

JSPとはどのような技術か

JSPは、JavaのコードをHTMLに埋め込むことで、Webサーバー上で動的にHTMLを生成する技術です。拡張子が .jsp であるファイルを使ってページを作成します。

JSPファイルは、Webサーバー（通常はTomcat）に配置され、ユーザーがアクセスすると、サーバー側でJavaのコードが実行されます。その結果として生成されたHTMLが、ブラウザに送信され、画面に表示されます。

つまり、JSPは「動的にHTMLを生成する仕組み」であり、「HTMLの中にJavaの処理を一部書き足せる形式のファイル」と言えます。

JSPの動作のしくみ

JSPファイルは、ユーザーがアクセスしたときに、サーバー側で一度「Javaのクラス（Servlet）」に変換されます。変換されたクラスはコンパイルされ、Javaプログラムとして実行されます。このとき、JSPファイルに書かれたHTMLの部分はそのままHTMLとして出力され、Javaのコード部分は処理されて結果が埋め込まれます。最終的に生成されたHTMLがブラウザに送信され、ユーザーに表示されます。

このしくみによって、JSPは1枚のファイルで「HTMLの見た目」と「動的な処理」を両立させることができます。

JSPの動き方の流れ

1. ユーザーが .jsp ファイルをリクエストする（例：hello.jsp）
2. Tomcat がその .jsp を読んで、中の Java を実行
3. 結果として HTML を作り出し、ブラウザに返す
4. ブラウザには、あたかも普通のHTMLのように見える

この一連の流れによって、「動きのあるページ」がリクエスト元に返却されることになります。

JSPを動かすための準備

JSPファイルは、通常のHTMLファイルと違い、単独では動作しません。JSPはサーバー側でJavaのコードを実行する仕組みのため、その処理を受け持つ「Webサーバー」や「Javaの開発環境」が必要です。

この章では、JSPを動かすために必要なソフトウェアや環境を、1つずつ順を追って準備していきます。

JSPの動作に必要なもの

JSPを動作させるには、次の3つが必要です。ここでは、それってそもそも何？みたいな説明＋実際にあなたのPCにインストールする手順をメモ程度に記載しておきますので、この辺の知識がすでにあるよ！という方は読み飛ばしてください。

JDKのインストール

まず、Javaの開発環境であるJDKをインストールします。JDKがインストールされていないと、JSPも動作しません。

Javaの開発環境構築の３ステップ解説（JDK/JRE/JVMの仕組みを１から解説）

【超・初心者向け】Javaの開発環境を初心者向けに簡単に設定する方法をわかりやすく解説します。JDKのインストール、IDEの選択、開発のスタートまで、スムーズにJavaプログラミングを始める方法をご説明します。

it-biz.online

2025.03.05

手順

1. Oracleの公式サイトまたはOpenJDKのサイトから、JDKをダウンロード。
2. お使いのOSに合ったインストーラを選び、画面の指示に従ってインストール。
3. インストール後、コマンドプロンプト（またはターミナル）を開き、↓のコマンドを入力。

java -version

バージョンが表示されれば、正常にインストールされています。

Tomcatのインストール

JSPファイルを処理するために、Tomcatをインストールします。TomcatはJavaで動作するWebサーバーで、JSPの実行に適した軽量なサーバーです。

手順

1. Apache Tomcat の公式サイトにアクセス。
2. zip ファイル（Windows の場合）または tar.gz ファイル（Mac/Linux の場合）をダウンロード。
3. ダウンロードしたファイルを任意の場所に展開（解凍）。
   →C:\tomcat や ~/tomcat などが一般的ですが、どこでもOK。
4. binフォルダにある startup.bat（Windows）または startup.sh（Mac/Linux）を実行。
5. ブラウザを開き、次のURLにアクセスします：

無効なURLです

localhost

Tomcatのトップページが表示されれば、インストールは成功です。

JSP用のフォルダを作る

Tomcatでは、webapps フォルダの中にあるプロジェクトが自動的に読み込まれます。自分でJSPファイルを作って表示するには、ここに新しいフォルダを作成します。

手順

1. Tomcatフォルダ内の webapps に移動。
2. 新しくフォルダを作成し、たとえば jsp-demo という名前をつける。
3. jsp-demo フォルダの中に、最初のJSPファイルを作成します。ファイル名は hello.jsp など。

エディタの準備

JSPファイルは、普通のテキストファイルとして作成できますが、プログラミングに適したエディタを使うと効率が上がります。以下のいずれかのエディタを使用するのが一般的です。

• Visual Studio Code（無料で軽量、拡張機能が豊富）
• IntelliJ IDEA（Javaに特化した統合開発環境）
• Eclipse（Java開発で定番のIDE）

初心者の方には、Visual Studio Codeが扱いやすくおすすめです。必要に応じて「Java Extension Pack」などを追加すると、補完機能や構文チェックも利用できます。

最初のJSPファイルを作ってみよう

前の章で、JSPを動かすための準備が整いました。この章では、実際にJSPファイルを1つ作成し、それをブラウザで表示するところまで進めます。

ここでは、「JSPとはどういうものか」を実際に体験しながら、基本的な書き方や仕組みを理解していきます。

JSPファイルとはどんなファイルか

JSPファイルは、基本的にはHTMLっぽく見えるコードで、この中の必要な部分にJavaのコードを差し込むことで、表示内容を動的に変えることができるようにしています。たとえば、「現在の日時を表示する」などの処理が可能になります。

JSPファイルの拡張子は .jsp です。ファイルの中には、通常のHTMLタグと、Javaのコードが組み合わさって記述されます。

<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Hello JSP</title>
</head>
<body>
  <h1>こんにちは、JSPの世界へようこそ！</h1>
  <p>現在の時刻は：<%= java.time.LocalDateTime.now() %></p>
</body>
</html>

上記のJSPファイルの中では、JavaのコードとHTMLが組み合わさっています。それぞれの部分について説明します。

• <%@ page contentType="text/html; charset=UTF-8" %>
  → この行は「ページ全体の設定」です。文字コードをUTF-8にすることで、文字化けを防ぎます。
• <%= java.time.LocalDateTime.now() %>
  → この部分がJSPの特徴です。「現在の時刻を表示する」Javaのコードが入っています。
  <%= と %> で囲まれた中はJavaの「式」として実行され、結果がそのままHTMLに差し込まれます。

上記のファイルをブラウザで表示するためにエディタで編集して保存しましょう。

1. Tomcatの webapps フォルダの中にある、前章で作成した jsp-demo フォルダに移動。
2. hello.jsp という名前の新しいファイルを作成。
3. ファイルをエディタで開き、↑の内容を記述し保存！

ブラウザで表示してみる

ファイルを保存したら、Tomcatが起動していることを確認し、ブラウザで次のURLにアクセスしてみましょう。

無効なURLです

localhost

画面に「こんにちは、JSPの世界へようこそ！」という見出しと、現在の時刻が表示されていれば成功です。

ブラウザでページを更新するたびに、時刻が変化するはずです。これは、JSPがアクセスされるたびにJavaのコードを実行して、ページの中身を動的に作っているということを意味します。

JSPの基本構文

前の章では、JSPファイルを作成し、Javaのコードを埋め込むことで「現在の時刻を表示する」ページを作成しました。ここからは、JSPファイルで使われる代表的な構文について解説します。どのようにJavaのコードをHTMLに差し込むのか、そしてJSP特有の書き方にはどんな種類があるのかを、順を追って学習していきましょう。

JSPの構成要素

JSPでは、以下の4種類の記述形式が用意されています。これらを使い分けることで、Javaの処理とHTMLの表示を同時に扱うことができます。

ディレクティブ

ディレクティブは、JSPファイル全体に関する設定を行うものです。最もよく使われるのは page ディレクティブです。

<%@ page contentType="text/html; charset=UTF-8" %>

この記述によって、出力するHTMLの文字コードがUTF-8になります。日本語を正しく表示するために必須です。

スクリプトレット

スクリプトレットは、JSPファイル内にJavaの処理を書くための領域です。

<%
  int year = java.time.LocalDate.now().getYear();
  String message = "今年は " + year + " 年です。";
%>
<p><%= message %></p>

この例では、Javaで現在の年を取得し、それを文字列として作成しています。そして <%= ... %> を使って、結果をHTMLに出力しています。

スクリプトレットの中ではJavaの文法がそのまま使えます。ただし、後述するようにスクリプトレットは新しい開発ではなるべく使わない方向にあります。

式（Expression）

式は、値をそのままHTMLとして出力したいときに使います。

<p>こんにちは、<%= "JSPユーザー" %>さん！</p>

上の例では、"JSPユーザー" という文字列がHTMLに挿入され、ブラウザには次のように表示されます。

こんにちは、JSPユーザーさん！

この書き方は非常にシンプルで、値を表示するだけであれば便利ですが、複雑な処理は向きません。

宣言

宣言は、JSPファイルの中でメソッドや変数を定義したい場合に使います。

<%! 
  private String getGreeting(String name) {
    return "こんにちは、" + name + "さん！";
  }
%>
<p><%= getGreeting("太郎") %></p>

このように、JSPファイルの中で小さな関数を定義して、それを式の中で呼び出すこともできます。ただし、JSPファイルに処理を詰め込みすぎると保守が難しくなるため、このような記述はできるだけ避け、外部のJavaクラスに処理を分けることが望まれます。

コメントの書き方

JSPには、HTMLのコメントと、JSP用のコメントの2種類があります。

<!-- これはHTMLのコメントです（ブラウザの「ページのソース」に表示されます） -->

<%-- これはJSPのコメントです（ブラウザには一切表示されません） --%>

HTMLのコメントはWebページに送信されるため、内容を見られる可能性があります。
一方、JSPのコメントはサーバー側で処理が止まるため、セキュリティ的に重要なコメントや開発者向けのメモはJSPのコメントで書くのが安全です。

スクリプトレットはなるべく使わない

JSPの構文として紹介しましたが、スクリプトレット（<% ... %>）の使用は、今では非推奨とされています。理由は以下の通り。

• HTMLとJavaのロジックが混ざることで、読みづらくなる
• 保守性が下がり、エラーが起きやすくなる
• JSTL（JSP標準タグライブラリ）やEL（式言語）の方がシンプルで安全に書ける

そのため、今後はJSTLやELを使って、できるだけ「Javaコードを書かずに表示を制御する方法」を覚えていくことが大切です。

次の章では、JSTLとEL（式言語）を使った“スクリプトレットを使わない”JSPの書き方を学びます。より読みやすく、安全なJSPの記述方法を習得していきましょう。

ELとJSTLでスクリプトレットのないJSPへ

ここまでの解説では、JSPの基本構文としてスクリプトレット（<% ... %>）などを紹介しました。
しかし近年のJSP開発では、スクリプトレットを使わない記述スタイルが主流となっています。

この章では、EL（Expression Language）とJSTL（JSP Standard Tag Library）という2つの仕組みを使って、JSPファイルの中にJavaコードを書かずに動的な表示を行う方法を学んでいきます。

EL（式言語）とは

EL（Expression Language）は、JSPの中でJavaの値を簡潔に記述するための言語です。
スクリプトレットのように <%= で囲む必要がなく、シンプルに ${変数名} と書くだけで値を出力できます。

<p>こんにちは、${userName} さん。</p>

このコードでは、Javaのサーバー側で userName という名前のデータ（属性）が用意されていれば、自動的にその値が表示されます。

JSTL（JSP標準タグライブラリ）とは

JSTLとは、JSP上で使える共通の処理をあらかじめタグ化したライブラリです。
たとえば、以下のような処理が可能です。

• 条件分岐（if）
• 繰り返し処理（forEach）
• 値のフォーマット（日付や数値）
• URLの生成

JSTLを使うことで、複雑なJavaの処理をわかりやすいタグで書くことができるようになります。

JSTLを使う準備

JSTLを使うには、JSTLライブラリの .jar ファイルを JSPプロジェクトの中に追加する必要があります。

手順

1. JSTLの最新版（Jakarta標準）をダウンロード
   → https://jakarta.ee/specifications/tags/
2. ダウンロードした jakarta.servlet.jsp.jstl-api-x.x.x.jar などの .jar ファイルを、Tomcatの lib フォルダ、またはプロジェクトの WEB-INF/lib フォルダにコピーします。
3. JSPファイルの先頭に、以下のようにタグライブラリを読み込む宣言を記述します。

<%@ taglib prefix="c" uri="https://jakarta.ee/taglibs/core" %>

この設定により、<c:if> や <c:forEach> などのJSTLタグが使えるようになります。

JSTLで条件分岐をする

スクリプトレットで if 文を書かなくても、JSTLの <c:if> タグを使うことで簡単に条件分岐ができます。

<%@ taglib prefix="c" uri="https://jakarta.ee/taglibs/core" %>
<c:if test="${loginUser != null}">
  <p>ようこそ、${loginUser.name} さん</p>
</c:if>

このように、loginUser という属性が null でなければ、挨拶文が表示されます。

JSTLで繰り返し表示をする

リストや配列の内容を繰り返し表示するには、<c:forEach> を使います。

サーバー側で、次のようにリストをセットしておきます（Servletなどで）：

List<String> names = List.of("太郎", "花子", "次郎");
request.setAttribute("nameList", names);

JSPファイルでは、次のように記述します：

<%@ taglib prefix="c" uri="https://jakarta.ee/taglibs/core" %>
<ul>
  <c:forEach var="name" items="${nameList}">
    <li>${name}</li>
  </c:forEach>
</ul>

このコードにより、以下のようなHTMLが生成されます：

<ul>
  <li>太郎</li>
  <li>花子</li>
  <li>次郎</li>
</ul>

JSPをすっきり保つために

ELとJSTLを使うことで、JSPファイル内にJavaのコードを書く必要がなくなり、HTMLに近い構造を保ちながら動的な処理を行うことができます。
これは、JSPを読みやすく・保守しやすくする上でも非常に重要です。

また、デザイナーと共同で作業するようなプロジェクトでも、HTMLに近い見た目を保つことで、分業がしやすくなります。

フォームからデータを受け取る

JSPを使ってWebアプリケーションを作成する際、ユーザーの入力に応じて処理を行うことは非常に重要です。この章では、HTMLのフォームを使って入力されたデータを、JSPで受け取って表示する方法を学びます。

フォーム送信の流れ

フォームを使った処理は、次のような流れで行われます。

1. 入力フォームのあるページ（JSP）を表示する
2. ユーザーが名前などの情報を入力し、送信ボタンを押す
3. 入力内容がサーバーに送られる
4. 受け取ったJSPファイルがその情報を読み取り、画面に表示する

JSPではこの一連の流れを、HTMLとJavaの仕組みで簡単に実現できます。

フォームを作るJSP（entry.jsp）

まずは、名前を入力するための簡単なフォームを作成します。

entry.jsp

<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>名前の入力</title>
</head>
<body>
  <h2>お名前を入力してください</h2>
  <form action="result.jsp" method="post">
    <label>名前：<input type="text" name="username" /></label>
    <input type="submit" value="送信" />
  </form>
</body>
</html>

このページでは、名前を入力して「送信」ボタンを押すと、result.jsp にPOSTリクエストでデータが送信されます。

データを受け取るJSP（result.jsp）

次に、送信されたデータを受け取って表示するためのJSPファイルを作成します。

result.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>入力結果</title>
</head>
<body>
  <h2>ようこそ！</h2>
  <p>あなたの名前は <strong><%= request.getParameter("username") %></strong> さんですね。</p>
</body>
</html>

ここでは、request.getParameter("username") というコードで、フォームから送られたデータを取得しています。

• request はJSPに自動で用意されているオブジェクト。
• getParameter("username") は、フォームのname="username" に対応した値を取得するメソッド。

ELを使って書き換える

JSTLやELを使えば、result.jsp をもっとすっきり書くこともできます。以下のようにリクエスト属性に値をセットしてから表示することで、式言語を活用できます。

Servlet側（例）

String name = request.getParameter("username");
request.setAttribute("username", name);
request.getRequestDispatcher("/result.jsp").forward(request, response);

result.jsp：

<%@ taglib prefix="c" uri="https://jakarta.ee/taglibs/core" %>
<p>こんにちは、${username} さん！</p>

ただし、Servletを使う方法はこのガイドの後半で詳しく扱いますので、今はまず request.getParameter() による受け取りに慣れることをおすすめします。

セッションとCookieでデータを保持する

JSPでは、ユーザーが入力した情報を「別のページでも使いたい」という場面がよくあります。
たとえば、ログイン状態を維持したり、前の画面で入力された名前を次の画面でも表示したりする場合です。

そのようなときに役立つのが セッション（Session） と クッキー（Cookie） です。
この章では、それぞれの役割と使い方を学びます。

セッションの基本操作

データの保存：

<%
  String name = request.getParameter("username");
  session.setAttribute("userName", name);
%>

このコードは、userName という名前でセッションに値を保存します。

データの取得：

<%
  String name = (String) session.getAttribute("userName");
%>
<p>ようこそ、<%= name %> さん</p>

このようにすれば、前のページで保存した値を、別のページで取り出して使うことができます。

セッションの有効期間と注意点

セッションは、ユーザーがブラウザを閉じるか、一定時間操作をしないと自動的に無効になります。Tomcatの初期設定では、30分間操作がないとセッションが切れます。

また、多くの情報をセッションに保存しすぎると、サーバーのメモリを圧迫する可能性があるため、用途を絞って使うことが大切です。

Cookieとは

Cookie（クッキー）は、情報をユーザーのブラウザに保存する仕組みです。
サーバー側から「この情報を保存しておいてください」と指示すると、ブラウザがその内容を保持し、次回以降のアクセス時にその情報を自動的に送信してきます。

Cookieの基本操作

Cookieの作成と送信：

<%
  String name = request.getParameter("username");
  Cookie cookie = new Cookie("userName", name);
  cookie.setMaxAge(60 * 60); // 1時間（秒単位）
  response.addCookie(cookie);
%>

Cookieの取得：

<%
  String name = "";
  Cookie[] cookies = request.getCookies();
  if (cookies != null) {
    for (Cookie c : cookies) {
      if ("userName".equals(c.getName())) {
        name = c.getValue();
      }
    }
  }
%>
<p>こんにちは、<%= name %> さん</p>

このように、Cookieを使えば、ブラウザに保存された情報を次回のアクセス時にも利用できます。

セッションとCookieの使い分け

一時的な状態保持（ログイン情報など）にはセッション、
ユーザーに関連する設定（言語選択やテーマなど）にはCookieがよく使われます。

JSPで簡単なアンケートアプリを作ろう

JSPを使ってWebアプリケーションを作るには、「複数ページにまたがる処理」を整理することが大切です。
この章では、3画面構成のアンケートアプリを作り、情報の受け渡し、表示の切り替え、セッションの活用を総合的に体験します。

アプリの構成と目的

このアプリでは、以下のような流れでユーザーにアンケートに答えてもらい、最終画面でまとめて表示します。

1. 入力画面：名前と好きな色を入力（form）
2. 確認画面：入力された内容を表示（セッションで一時保持）
3. 完了画面：ありがとうメッセージと入力内容の最終確認

プロジェクト構造

jsp-demo/
├─ input.jsp     （入力画面）
├─ confirm.jsp   （確認画面）
└─ thanks.jsp    （完了画面）

入力画面：input.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head><meta charset="UTF-8"><title>アンケート入力</title></head>
<body>
  <h2>アンケートにご協力ください</h2>
  <form action="confirm.jsp" method="post">
    <p>お名前：<input type="text" name="userName" /></p>
    <p>好きな色：
      <select name="favoriteColor">
        <option value="赤">赤</option>
        <option value="青">青</option>
        <option value="緑">緑</option>
      </select>
    </p>
    <input type="submit" value="確認画面へ" />
  </form>
</body>
</html>

確認画面：confirm.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<%
  String userName = request.getParameter("userName");
  String favoriteColor = request.getParameter("favoriteColor");

  session.setAttribute("userName", userName);
  session.setAttribute("favoriteColor", favoriteColor);
%>
<!DOCTYPE html>
<html>
<head><meta charset="UTF-8"><title>確認画面</title></head>
<body>
  <h2>以下の内容でよろしいですか？</h2>
  <p>お名前：<%= userName %></p>
  <p>好きな色：<%= favoriteColor %></p>
  <form action="thanks.jsp" method="post">
    <input type="submit" value="送信する" />
  </form>
</body>
</html>

完了画面：thanks.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<%
  String name = (String) session.getAttribute("userName");
  String color = (String) session.getAttribute("favoriteColor");

  // 必要があればセッションのデータを破棄
  session.invalidate();
%>
<!DOCTYPE html>
<html>
<head><meta charset="UTF-8"><title>送信完了</title></head>
<body>
  <h2>ご協力ありがとうございました！</h2>
  <p><strong><%= name %></strong> さんの好きな色は <strong><%= color %></strong> ですね。</p>
</body>
</html>

ArrayList<String> list = new ArrayList<>();

この「<String>」の部分がジェネリクスです。

ジェネリクスとは？

ジェネリクス（Generics）とは、Javaで使われる「型を指定できる仕組み」のことです。

…でも、これだけだとまだイメージが湧きませんよね。

もう少しわかりやすく言うと、

• 「この箱には、文字列だけを入れたい」
• 「あの箱には、数字だけを入れたい」

のように、「扱えるデータの種類をあらかじめ指定することができる」のがジェネリクスの基本的な考え方です。

ジェネリクスが登場した理由とメリット

昔のJavaにはジェネリクスがありませんでした。そのため…

• 箱に色々な種類のデータが混ざってしまう
• 取り出すときに「これって何型だったかな？」とキャスト（型変換）が必要で面倒だった

そこで登場したのがジェネリクス。メリットは3つあります。

まずはイメージをつかむ

ジェネリクス無しの世界😢

[りんご, 100, バナナ, 200, メロン…]

• 何が入っているか不明
• 取り出してから「これは何？」と確認が必要

ジェネリクス有りの世界✨

箱A<String>：[りんご, バナナ, メロン]
箱B<Integer>：[100, 200, 300]

• 最初から型が決まっていて、混ざることがない
• 安全で取り出しやすい！

そのため、ジェネリクスは、ArrayList や HashMap などのコレクション系クラスで最もよく使われます。
コレクションは「複数の値をまとめて持つ」ので、何の型を入れるか決めることにおおきなメリットがあるためです。もちろんコレクション以外でも利用できるシーンはありますが、基本はコレクション系のクラスでよく使える！っていう風に理解しておくとよいでしょう。

ジェネリクスの基本構文

ジェネリクスは次のように書きます。

クラス名<型名> 変数名 = new クラス名<型名>();

• クラス名：ArrayListやHashMapなど
• 型名：StringやIntegerなど扱う型

例えば、「文字列だけを入れる箱」を作るには…

ArrayList<String> fruits = new ArrayList<String>();

これが基本形です。（最近のJavaなら右辺の型は省略可能！）

ArrayList<String> fruits = new ArrayList<>();

ジェネリクスのよくある使い方

ジェネリクスを利用すると、リストから要素を取り出す際に明示的なキャストが不要です。

List<Integer> intList = new ArrayList<>();
intList.add(1);
intList.add(2);

for (Integer num : intList) {
    System.out.println(num);
}

この例では、intList に格納される値は常に Integer 型であることが保証されているため、ループ内でキャストする必要がありません。また、誤った型の要素がリストに含まれることを防ぐことができます。

もし、ジェネリクスを使わずに List を定義すると、以下のように明示的なキャストが必要になります。

List list = new ArrayList();
list.add("Hello");
String str = (String) list.get(0); // キャストが必要

このようなコードでは、リストに異なる型の値が混在する可能性があり、実行時に ClassCastException が発生するリスクがあります。ジェネリクスを使用することで、上記の問題を解決できます。以下のように書き換えることで、型安全性が向上します。

List<String> list = new ArrayList<>();
list.add("Hello");
String str = list.get(0); // キャスト不要

この場合、リストには String 型の値のみを格納できるため、キャストが不要になります。また、型が保証されるため、誤った型を扱うことによるエラーを未然に防ぐことができます。

【応用編】自分でジェネリクスクラスを作る方法

ジェネリクスはコレクションだけでなく、独自クラスにも適用できます。例えば、以下のような汎用的なクラスを定義する例を見てみましょう。

class Box<T> {
    private T data;

    void set(T data) { this.data = data; }
    T get() { return data; }
}

Box<String> box = new Box<>();
box.set("Hello");
System.out.println(box.get()); //"Hello"

このコードは「Boxというクラスの中で、あとから使う型（T）を自由に指定できるようにしている」という仕組みです。※　T というのは、仮の型名（型のプレースホルダー）です。

• Box<T>：これは「このBoxはT型のデータを扱います」という意味。
• private T data;：データを入れる変数 data は、T型ですよ〜 という意味。
• set(T data)：引数として T型のデータ を受け取って、保存。
• get()：保存された T型のデータ を返す。

つまり「このクラスはTという型を扱う、型付きの箱（Box）」ということ。Box<String> と書いた時点で「T = String」と明確に決まるので、String型のメソッドが自由に使えるようにもなります。

Box<String> box = new Box<>();
box.set("こんにちは");

String value = box.get();
System.out.println(value.length());      // 出力: 5
System.out.println(value.toUpperCase()); // 出力: コンニチハ
System.out.println(value.contains("にち")); // 出力: true

ジェネリクスを使用することで、型の安全性を向上させ、明示的なキャストを減らすことができます。これにより、コードが簡潔になり、バグの発生を防ぐことができます。特にコレクションを扱う際は、ジェネリクスを積極的に活用しましょう。

List<String> names = new ArrayList<>();

class A<T> {
    T value;
}

参考　インターフェースとは？わかりやすく３分で解説

Comparableとは？

プログラムでは「数値」や「文字列」の並び替えがよく行われます。数字なら「小さい順」「大きい順」、文字なら「あいうえお順」など、誰でも簡単にできますよね。

しかし、自分で作ったクラス（例えば人間、車、本）を並び替えるには、何を基準にするかを明確に決める必要があります。このときに役立つのが、Java標準のインターフェース「Comparable」です。

Comparableの基本的な使い方を理解するために、独自のクラスを定義して、そのクラスで並び順を変えるところまでを順を追って説明していきます。

Step①: クラスを作る

例えば「人間」というクラスを作ります。

class Person {
    String name; // 名前
    int age;     // 年齢

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

Step②: Comparableを実装する

「年齢で並べたい」とき、次のようにComparableを実装します。

class Person implements Comparable<Person> {
    String name;
    int age;

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

    // これが比較を行うためのルールを決めるメソッド
    // 「Personクラスのインスタンス同士を、年齢（age）を使って比較する」
    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }
}

Comparableインターフェースは「並べ替えのルールを定めるために、compareTo()の実装を必須とする契約」です。この実装（ルール）に従って、Collections.sort()などがオブジェクトを並び替える、というイメージです。

1個1個整理しますね。

• Comparableインターフェースの目的
  • 「このクラスのインスタンスを、自然な順序（natural order）で比較・並び替えできるようにする」ためのインターフェース。
• compareToメソッドの役割
  • シグネチャは int compareTo(T other)
  • 戻り値の意味：
    • 負の値：this が other より小さい
    • 0：同じ
    • 正の値：this が other より大きい
  • ここに「並べ替えのルール」を書きます（例：年齢順、辞書順など）。
• ルールを実装する流れ
  • クラス宣言で implements Comparable<YourClass> を付与
  • compareTo() をオーバーライドし、比較ロジックを記述
  • これでそのクラスは「Comparableなオブジェクト」となる
• ルールに従った並び替え
  • Collections.sort(listOfYourClass);
  • Arrays.sort(arrayOfYourClass);
  • 上記を呼ぶと、自動的に compareTo() を使って順序付けされる

Java標準ライブラリ（OpenJDK）のソースから抜粋すると、java.lang.Comparable は非常にシンプルに定義されていることが分かります。

package java.lang;

/**
 * This interface imposes a total ordering on the objects of each
 * class that implements it.
 */
public interface Comparable<T> {
    /**
     * Compares this object with the specified object for order.
     * @param  o the object to be compared.
     * @return a negative integer, zero, or a positive integer
     *         as this object is less than, equal to, or greater than the specified object.
     */
    int compareTo(T o);
}

実際に並び替えをしてみよう（サンプルコード付き）

先ほど定義したPersonクラスを用いて実際に並び替えを行うコードを見てみましょう。以下は複数の人を年齢順に並べ替える例です。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("佐藤", 25));
        people.add(new Person("鈴木", 20));
        people.add(new Person("高橋", 30));

        // 年齢順で並び替え
        Collections.sort(people);

        // 並び替えた結果を表示
        for (Person person : people) {
            System.out.println(person.name + " (" + person.age + ")");
        }
    }
}

/* 出力
鈴木 (20)
佐藤 (25)
高橋 (30) */

年齢の若い順に表示されます。

けど、なんで？っていうのをちょっとだけ深堀しておきます。

この1行：

Collections.sort(people);

がなぜ並び替えをしてくれるのかの裏側の流れを見てみます。

🔁 流れを順を追って説明

ステップ① Collections.sort() を呼ぶ

Collections.sort(people);

これは、リストの中身を昇順（小さい順）に並び替えるメソッドです。
ただし、「どう並び替えるか（ルール）」は Comparable インターフェースの compareTo() に頼っています。

ステップ② 内部で List.sort(null) が呼ばれる

List.sort(null)の中身を見ると、実はこうなっています：

public static <T extends Comparable<? super T>> void sort(List<T> list) {
    list.sort(null); // Comparator が null だと \"自然順序\" でソート
}

これをやさしく言い換えると「Tは、自分自身か親クラスと比較できる能力（Comparable）を持った型でなければいけませんよ。そのリストを自然な順序で並べ替えます」ということ。<T extends Comparable<? super T>>の部分が肝でこれはジェネリクスの型制約と呼ばれます。

そして、リストの要素（この場合は Person）が Comparable を実装していれば、その compareTo() メソッドが呼び出されます。このとき内部ではこんな処理が行われています：

for (int i = 0; i < list.size(); i++) {
    for (int j = i + 1; j < list.size(); j++) {
        if (list.get(i).compareTo(list.get(j)) > 0) {
            // 要素を交換する（大きければ後ろに）
        }
    }
}

要するに compareTo() を使って2つのオブジェクトを比較し、順番を入れ替えているわけです。Collections.sort(people); だけで並び替えができる理由は：

1. Personが Comparable を実装していて
2. compareTo() で「年齢順に並べる」と明確に書かれており
3. Javaが内部で compareTo() を何度も呼びながら順番を整えてくれる

という仕組みがあるからです。つまり、「compareToが並び替えのルールブックになっていて、Javaがそれを読んで並び替えている」と考えてOKです！

Comparatorとの違いを知ろう

Javaにはもう1つ「Comparator」という似た仕組みがあります。

• Comparable
  自然な順序（通常の並べ方）をクラス自体が決定する場合に使います。
• Comparator
  並び順を外側で自由に決めたい場合に使います（例えば名前順、年齢順などその都度変更する場合）。

Comparatorの使い方も知っておこう（応用編）

先ほどの「人」の例で、今度は名前順に並べたい場合、Comparatorを使います。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("佐藤", 25));
        people.add(new Person("鈴木", 20));
        people.add(new Person("高橋", 30));

        // 名前順に並べ替え
        people.sort(new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.name.compareTo(p2.name);
            }
        });

        for (Person person : people) {
            System.out.println(person.name + " (" + person.age + ")");
        }
    }
}

/* 出力
佐藤 (25)
鈴木 (20)
高橋 (30) */

今度は名前の50音順に並びました。

Comparableを使うメリット

• わかりやすい：クラス自身がどのように並ぶかを決めているため、コードが読みやすいです。
• 使いやすい：Javaの配列やリストのソート機能がそのまま使えます。

注意点（初心者がよく間違うポイント）

• compareToメソッドを使うとき、数字を単純に引き算すると、整数オーバーフローを起こすことがあります。安全な方法は常に Integer.compare(a, b) を使うことです。

例：

良くない例：

return this.age - other.age; // オーバーフローの可能性あり

安全な例：

return Integer.compare(this.age, other.age); // 安全

まとめ

• Comparableはオブジェクトの自然な順序を決定するための仕組み
• compareTo()で比較方法を定義
• Comparatorと使い分けることで、様々な並び替えが可能
• 基本を押さえて、安全な書き方を心掛けることが大事

1. インナークラス (Inner Class):
   クラスのメンバ（フィールドやメソッド）と同じように定義されるクラス。インスタンスメンバとして扱われるため、外側のクラスのインスタンスを通してのみインスタンス化できます。外側のクラスのprivateメンバにもアクセスできるのが特徴。
2. staticネストクラス (Static Nested Class):
   クラス内に、static修飾子をつけて定義されたクラス。外側のクラスのインスタンスがなくてもインスタンス化でき、静的メンバのように振る舞います。外側のクラスの静的メンバにはアクセスできますが、インスタンスメンバには直接アクセスできません。
3. ローカルクラス (Local Class):
   メソッドやコンストラクタ、イニシャライザなどのブロック内で定義されるクラス。そのブロック内でのみ有効で、外側のクラスのメンバや、そのブロックのfinalまたはeffectively finalなローカル変数にアクセスできます。名前を持たない匿名クラスとは異なり、名前を持つことができます。
4. 匿名クラス (Anonymous Class):
   名前を持たないクラスで、クラスの宣言と同時にインスタンス化されるクラス。主に、インターフェースや抽象クラスを実装したり、クラスを継承したりする際に、その場で簡単な処理を記述するために使われます。ローカルクラスと同様に、外側のクラスのメンバや、そのブロックのfinalまたはeffectively finalなローカル変数にアクセスできます。

このページでは、上記4種類のJavaの内部クラスについて、初心者の方にも分かりやすいように解説していきます。

【前提】クラスとスコープをおさらい

「クラス」はデータ（フィールド）と振る舞い（メソッド）を束ねる設計図で、「インスタンス」はその具体物です。

参考　クラスとインスタンスの基本概念を１から

Javaではクラス宣言の内側にさらに別のクラスを記述することが許されており、これをネストクラス（入れ子クラス）と呼びます。トップレベルクラスと異なり、スコープ（見える範囲）が外側クラスの内部に限定される点が最大の特徴です。

なぜ“クラスの中にクラス”が必要か

理由１　「外側のクラスと強く関係する処理」をまとめたいから

たとえばButtonクラスがあって、そのボタンの「クリックイベント処理」を表すClickListenerクラスがあるとします。このClickListenerは他の用途には使いませんし、Buttonとセットで使うのが当然です。
だったら、わざわざ別ファイルに分けるより、中に書いた方が読みやすくて自然ですよね？

「このクラスはこの中でしか使わない」
→ なら中に書けばいいじゃないか！

理由２　「外側の状態（フィールド）を安全に共有」できるから

インナークラスは、外側クラスのprivateフィールドにアクセス可能です。通常、privateな情報は外から見えませんが、内部にいるクラスだからこそ見られる、という特徴を持ちます。
外側に余計なgetterを生やさなくていいという意味でも、安全な設計にすることが可能になります。

理由３　「外に見せたくない構造を隠せる」から

クラスを外部ファイルに出すと、他の人や他のクラスからもアクセスされる可能性があります。でも内部クラスなら、完全に外側クラスの一部として、スコープを制限できます。
「このロジックはこのクラス専用だよ」と明確な意図をコード上に示せるのが大きなメリットです。

つまり内部クラスは「関係が強く、独立性が低い」クラスのための居場所っていうイメージです。以下のような設計上の目的を果たすために、Javaは内部クラスという仕組みを提供しているとまずは理解しておきましょう。

• ロジックのまとまり（凝集度）を保つ
• 外部への漏洩を防ぐ（情報隠蔽）
• コードの可読性・保守性を上げる

ここからは１個１個の内部クラスの特徴や注意点について解説します。

インナークラス (Inner Class)

インナークラスは、外側のクラスの「メンバー」として定義される内部クラスです。これは、クラスの中にあるフィールド（変数）やメソッド（関数）と同じような立ち位置だと考えると分かりやすいです。

class Outer {
    private int outerField = 10;

    class Inner {
        public void innerMethod() {
            // 外側のprivateメンバにアクセス
            System.out.println("Outerのフィールドの値: " + outerField);
        }
    }

    public void createInnerAndCall() {
        // 外側のクラスから内部クラスのインスタンスを作成
        Inner inner = new Inner();
        inner.innerMethod();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        // 出力: Outerのフィールドの値: 10
        outer.createInnerAndCall();

        // 外側のクラスのインスタンスを通して、内部クラスのインスタンスを作成
        Outer.Inner innerInstance = outer.new Inner();
        // 出力: Outerのフィールドの値: 10
        innerInstance.innerMethod();
    }
}

この例では、Outerクラスの中にInnerクラスが定義されています。InnerクラスのinnerMethodメソッドは、外側のOuterクラスのprivateなフィールドであるouterFieldにアクセスすることが可能。また、Innerクラスのインスタンスを作成する際には、まずOuterクラスのインスタンス (outer) を作り、それを通して outer.new Inner() のようにして作成します。

特徴

• インスタンスに紐づく:
  インナークラスのインスタンスを作るには、前提として外側クラスのインスタンスが必要です。
• 外側のクラスのメンバにアクセス可能:
  インナークラスからは、外側のクラスのprivateなメンバを含むすべてのメンバ）に自由にアクセスすることが可能です。

staticネストクラス (Static Nested Class)

staticネストクラスは、staticキーワードをつけて定義された内部クラスです。これは外側のクラスのインスタンスに直接紐付かず、独立して存在できる点がインナークラスとは異なります。

【Java】static の意味と使い方を３分でわかりやすく解説

Javaのstaticキーワードの使い方を徹底解説！メモリ効率の向上や便利なユーティリティメソッドの提供、共通データの管理を簡単にするためのポイントを、サンプルコード付きで初心者向けにわかりやすく説明します。

it-biz.online

2025.04.13

class OuterStatic {
    private static int staticOuterField = 20;
    private int instanceOuterField = 30;

    static class InnerStatic {
        public void innerStaticMethod() {
            // 静的メンバにアクセス
            System.out.println("OuterStaticの静的フィールドの値: " + staticOuterField);
            // エラー！インスタンスメンバにはアクセスできない
            // System.out.println("OuterStaticのインスタンスフィールドの値: " + instanceOuterField); 
        }
    }

    public static void main(String[] args) {
        // 外側のクラスのインスタンスなしで、staticネストクラスのインスタンスを作成
        OuterStatic.InnerStatic innerStatic = new OuterStatic.InnerStatic();
        // 出力: OuterStaticの静的フィールドの値: 20
        innerStatic.innerStaticMethod();
    }
}

この例では、OuterStaticクラスの中にstatic修飾子が付いたInnerStaticクラスが定義されています。InnerStaticクラスのinnerStaticMethodメソッドは、外側のOuterStaticクラスのstaticなフィールドであるstaticOuterFieldにアクセスできていますが、インスタンスフィールドであるinstanceOuterFieldにはアクセスしようとするとエラーになります。

staticなメソッドはstaticではないメンバへのアクセスができない、という意味でJavaの原理原則と一致しており、不自然なルールではありません。

尚、staticネストクラスのインスタンスは、OuterStatic.InnerStatic innerStatic = new OuterStatic.InnerStatic(); のように、外側のクラス名を指定して直接作成できます。

イメージ

大きな家の敷地内にある、独立した小さな小屋（staticネストクラス）を想像してください。小屋は家の一部ではありますが、家の主人（外側のクラスのインスタンス）がいなくても存在できます。ただし、小屋からは家の中の共有スペース（外側のクラスのstaticなメンバ）は見えますが、個人の部屋（外側のクラスのインスタンスメンバ）には直接入ることはできません。

特徴

• 外側のクラスのインスタンスが不要:
  staticネストクラスのインスタンスは、外側のクラスのインスタンスがなくても直接作成できます。
• 外側のクラスの静的メンバにのみアクセス可能:
  staticネストクラスからは、外側のクラスのstaticなフィールドやメソッドに直接アクセスできますが、staticでないインスタンスメンバにはアクセスできません。

ローカルクラス (Local Class)

ローカルクラスは、メソッドやコンストラクタなどの特定のブロックの中で定義されるクラスです。その定義されたブロック内でのみ有効で、外からはアクセスできません。

ブロック内のみで有効→つまり、ローカルクラスにはアクセス修飾子を付ける必要がない→アクセス修飾子を付けるとコンパイルエラーになります。

class OuterLocal {
    private int outerField = 40;

    public void outerMethod() {
        // finalまたはeffectively finalである必要がある
        int localVariable = 50; 

        class LocalInner {
            public void localInnerMethod() {
                // 外側のメンバにアクセス
                System.out.println("Outerのフィールドの値: " + outerField);
                // finalまたはeffectively finalなローカル変数にアクセス
                System.out.println("ローカル変数の値: " + localVariable);
            }
        }

        LocalInner localInner = new LocalInner();
        // 出力: Outerのフィールドの値: 40, ローカル変数の値: 50
        localInner.localInnerMethod();
    }

    public static void main(String[] args) {
        OuterLocal outer = new OuterLocal();
        outer.outerMethod();
    }
}

イメージ

あなたが一時的に借りた部屋（メソッドなどのブロック）の中で、その部屋の中だけで使うための小さな道具（ローカルインナークラス）を作るようなイメージです。その道具は部屋の外には持ち出せませんし、他の部屋の人が使うこともありません。

特徴

• 定義されたブロック内でのみ有効:
  ローカルクラスは、それが定義されたメソッドなどのブロックが終わると、その存在は消えます。
• 外側のクラスのメンバにアクセス可能:
  ローカルクラスからは、外側のクラスのすべてのメンバ（privateを含む）にアクセスできます。
• ブロック内のfinalまたはeffectively finalなローカル変数にアクセス可能:
  ローカルクラスが定義されているメソッドなどのブロック内のローカル変数にアクセスする場合、その変数はfinalであるか、実質的にfinal（一度代入された後、値が変更されない）である必要があります。

class OuterLocalExtended {
    private int outerField = 40;

    public LocalInner getLocalInnerInstance() {
        // finalまたはeffectively finalである必要がある
        int localVariable = 50;

        class LocalInner {
            public void localInnerMethod() {
                System.out.println("Outerのフィールドの値: " + outerField);
                System.out.println("ローカル変数の値: " + localVariable);
            }
        }
        // LocalInnerのインスタンスをメソッドの外に返す
        return new LocalInner();
    }

    public static void main(String[] args) {
        OuterLocalExtended outer = new OuterLocalExtended();
        // メソッド終了後にインスタンスを受け取る
        LocalInner instance = outer.getLocalInnerInstance();
        // ... 何らかの処理 ...
        // メソッド終了後にローカル変数にアクセスしようとする（実際にはコピーを参照）
        instance.localInnerMethod(); 
    }
}

この例では、getLocalInnerInstance メソッド内で LocalInner のインスタンスが作成され、メソッドの戻り値として外に渡されます。main メソッドでは、getLocalInnerInstance の実行が終了した後も、LocalInner のインスタンス (instance) が存在し続ける可能性があります。

もし localVariable が final でなかった場合、getLocalInnerInstance メソッドが終了し、スタック上の localVariable が解放された後も、instance がその解放されたメモリ領域を参照しようとする危険性があります。これは、プログラムのクラッシュや予期しない動作を引き起こす可能性があります。

final または実質的に final であることで、ローカルクラスのインスタンスが生成された時点で、参照するローカル変数の値がコピーされ、そのコピーがインスタンス内に保持されます。そのため、元のローカル変数がメソッド終了時に消滅しても、コピーされた値は安全にアクセスできるということになります。

匿名クラス (Anonymous Class)

匿名クラスは、名前を持たないクラスで、クラスの宣言と同時にそのインスタンスが作成されます。主に、インターフェースを実装したり、クラスを継承したりする際に、その場で簡単な処理を記述するために使われます。

interface Greeting {
    void greet(String name);
}

class OuterAnonymous {
    private String message = "Hello, ";

    public void performGreeting(String personName) {
        // 匿名クラスを使ってGreetingインターフェースを実装
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void greet(String name) {
                // 外側のメンバにアクセス
                System.out.println(message + name);
            }
        };
        // 出力: Hello, Taro
        anonymousGreeting.greet(personName);
    }

    public static void main(String[] args) {
        OuterAnonymous outer = new OuterAnonymous();
        outer.performGreeting("Taro");
    }
}

この例では、Greetingというインターフェースを、performGreetingメソッドの中で匿名クラスを使って実装しています。new Greeting() { ... } の部分が匿名クラスの定義とインスタンス化を同時に行っている箇所です。匿名クラスの中のgreetメソッドでは、外側のOuterAnonymousクラスのmessageフィールドにアクセスしています。

匿名クラスも、メソッド内で定義しているクラスなので、ローカルクラスと同様でアクセス修飾子を付けるとコンパイルエラーが発生します。

イメージ

例えるなら、注文したケーキ屋さんで、その場で簡単なデコレーション（匿名クラスによる処理の実装）を加えてもらうようなイメージです。デコレーションの名前はないけれど、その場でケーキに特別な機能を追加できます。

特徴

• 名前がない:
  クラス定義に名前がありません。
• 宣言と同時にインスタンス化:
  new インターフェース名() または new スーパークラス名() のようにして、その場でクラスの定義とインスタンスの作成を同時に行います。
• 外側のクラスのメンバやfinal/effectively finalなローカル変数にアクセス可能:
  ローカルインナークラスと同様のアクセスルールを持ちます。

匿名クラスについては少し理解しづらい部分があると思います。以下のページでより詳しく解説しておりますので、合わせてご覧ください。

【Java】匿名クラスとは？１分でわかりやすく使いどころを解説

Javaの匿名クラスについて、基本的な書き方から使いどころ、ラムダ式との違いまでを初心者にもわかりやすく解説します。一度きりの実装に便利な匿名クラスのメリット・注意点も紹介。

it-biz.online

2025.04.07

このページでは、Javaの基本コマンドであるjavac・java・jarの使い方を１からわかりやすく解説しつつ、Java 9で導入されたモジュールシステムやJava 11のソースファイルモードにも触れていきます。

さらに、クラスローダ・JITコンパイラ・GCなど、JVMの裏側にある奥深い仕組みにも言及しながら、読んでいて「Javaって実は面白い！」と思える記事にしていますので、是非最後までご覧ください。

コンパイルと実行（javacとjava）

まずは基本となるコンパイルと、コンパイルしたバイトコード（classファイル）の実行コマンドから解説します。

ソースコードの準備とコンパイル（javac）

Javaのプログラムはソースコード（.javaファイル）をコンパイルしてバイトコード（.classファイル）に変換する作業が必要です。たとえば、HelloWorld.javaに下記のようなクラスを定義したとします。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

これをコンパイルするには、次のコマンドを実行します。

javac HelloWorld.java

同じフォルダ内にHelloWorld.classが生成されます。これがバイトコードです。

実行（java）

生成されたバイトコードを実行する際には、拡張子を付けずにクラス名を指定します。

java HelloWorld

これで「Hello, World!」と表示されれば成功です。

java/javacコマンドのオプション

javac は Java ソースコード（.javaファイル）をバイトコード（.classファイル）にコンパイルするためのコマンドでした。最もシンプルな使い方は、javac ファイル名.java で、同じディレクトリに .class ファイルが生成するだけですが、以下のオプションを使うことで様々な対応が可能になります。

javac [オプション] ソースファイル
java [オプション] クラスファイル

javac の代表的なオプション一覧

1. 出力先を指定してコンパイルする
   javac -d out MyProgram.java
2. 複数のソースファイルを一括コンパイル
   javac -encoding UTF-8 -d out src/*.java
3. 外部ライブラリを使う場合（クラスパス指定）
   javac -cp lib/some-library.jar -d out src/MyApp.java
   • some-library.jar のクラスを参照しながらコンパイル
   • MyApp.class は out/ に出力される
4. Javaのバージョンを指定してコンパイルする
   javac -source 11 -target 8 MyLegacyApp.java
   • ソースは Java 11 の構文チェック
   • バイトコードは Java 8 向けに出力

Javaコマンドの3つの実行形態 + ソースファイルモード

Javaプログラムをjavaコマンドで実行する方法は、大きく3つ存在します。さらに、Java 11からはソースファイルモードというシンプルな実行形態も加わりました。

1. mainメソッドを持つクラスファイル
2. jarファイル内のメインクラス
3. モジュールに含まれるメインクラス
4. （Java 11～）ソースファイルモード

以下では、これらの違いや使い分けを確認していきます。

mainメソッドを持つクラスファイル

もっともシンプルで伝統的な実行形態です。すでに紹介したHelloWorldのように、main(String[] args)を持つクラスをjavacでコンパイル後、java クラス名で起動する方法です。

• メリット: 設定が不要で手軽
• デメリット: 配布やライブラリ管理の段階になると、クラスファイルをまとめる必要が出てくる

jarファイル内のメインクラス

複数のクラスファイルやリソースをまとめたアーカイブファイル（.jar形式）を生成し、Main-Classを指定することで、java -jarコマンドで実行可能にできます。

1 manifest.txtなどでメインクラスを指定
Main-Class: com.example.app.HelloWorld

2 jarコマンドでアーカイブを作成
jar cfm HelloWorld.jar manifest.txt com/example/app/*.class

3 実行
java -jar HelloWorld.jar

これにより、配布やバージョン管理が容易になり、システム全体の保守性が向上します。

モジュールに含まれるメインクラス（Java 9～）

Java 9で導入されたモジュールシステム（Project Jigsaw）は、大規模化したJavaアプリケーションにおけるパッケージ管理をより厳密に行う仕組みです。

• module-info.javaでモジュール名やエクスポートするパッケージ、依存モジュールなどを宣言します。
• 実行時はモジュールパスとメインモジュール・メインクラスを指定します。

java --module-path mods -m com.example.app/com.example.app.HelloWorld

• -module-pathでモジュールを配置したディレクトリを指定
• -mオプションで「モジュール名/メインクラス」を指定

モジュール同士の依存関係やアクセス制御を明確化し、ライブラリの衝突などを防ぎやすくなるのが大きな利点です。

Java 11のソースファイルモード

Java 11からは、単一のソースファイルであればコンパイルを明示せずに直接実行できるようになりました。

java HelloWorld.java

これだけでコンパイルと実行を一括で行います。スクリプト感覚で試験的なコードを書くときや、学習用途にはとても便利です。

注意: 大規模開発や複数クラスが絡む場合は、従来どおりコンパイル→実行またはIDEのプロジェクト構成が一般的です。あくまでも“単体ファイル”に限り便利な機能である、と理解しましょう。

jarコマンドの応用：アプリケーションのパッケージング

jarファイルの基本

jarはZIP形式をベースにしたアーカイブで、クラスファイルやリソースをひとまとめにできます。

• 配布が容易になり、classpathにjarファイルを追加するだけでアプリケーションが動作するようにできます。
• META-INF/MANIFEST.MFにメインクラスやクラスパス情報を記述することで、java -jar形式の実行ファイルを構築可能です。

実行可能jarとマニフェストファイル

たとえば以下のように、メインクラスを指定したmanifest.txtを準備します。

Main-Class: com.example.app.HelloWorld

このファイルを用いてjarを作成すると、

jar cfm HelloWorld.jar manifest.txt com/example/app/*.class

すると、

java -jar HelloWorld.jar

でメインメソッドが呼び出され、アプリが起動します。

応用設定：クラスパスとJVMオプション

クラスパス（classpath）の指定

外部ライブラリを使う場合など、Javaがクラスファイルやライブラリを探しに行くパスを指定する必要があります。

javac -cp ./libs/*:. MyApp.java
java -cp ./libs/*:. MyApp

• .は現在のディレクトリ
• :はパス区切り文字（Windowsでは;）
• ./libs/* でlibsフォルダ内のJARすべてを指定

JVM起動オプション（メモリ・デバッグ）

• -Xms -Xmx: ヒープメモリの初期サイズ・最大サイズを指定（例：-Xms512m -Xmx1024m）
• リモートデバッグ:

java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 MyApp

指定ポートにデバッガを接続すればブレークポイントを張ってステップ実行が可能です。

Javaの裏側の仕組み

クラスローダ

Javaではクラスローダが複数階層になっており、標準ライブラリを読み込むブートストラップクラスローダ、ユーザのクラスパスを参照するシステムクラスローダなどが段階的にクラスを探します。

• パッケージ名に対応するディレクトリ構造を辿って.classファイルをロード
• モジュールシステム利用時はモジュールパスを優先的に参照

JITコンパイラ

JVMは実行時にバイトコードをインタプリタで実行するだけでなく、JITコンパイラによって頻繁に呼ばれるメソッドをネイティブコードに変換します。

• これにより、Javaアプリは起動直後こそ遅めでも、使い込むうちに高速化が期待できます。

ガーベジコレクション（GC）

メモリ管理を自動化するJavaの大きな特徴です。

• ヒープ内の不要オブジェクトをGCが検知し、自動的にメモリを再利用
• GCアルゴリズム（Serial GC, Parallel GC, G1 GC, ZGCなど）をアプリケーション特性に合わせて選択可能
• メモリリークの心配は軽減される一方、開発者がGCタイミングを完全に制御することは難しい

この記事のゴール: 「変数は型で決まり、メソッドは場合によって実体で決まる」——この 1 行を実感として理解する。

Javaにおける「静的バインディング」と「動的バインディング」という言葉は、初心者にとって少しとっつきにくく感じられるかもしれません。これらは継承が関わるときにだけ登場する話です。

たとえば、Animal a = new Dog(); のように、親クラスの変数に子クラスのインスタンスを代入したとき、Javaは「変数を見るべきか？」「実体を見るべきか？」という判断をしなければなりません。このとき、

• 変数（フィールドや static メソッド）は「型（参照型）」で判断される → 静的バインディング
• インスタンスメソッド（オーバーライドされる可能性があるもの）は「中身（実体型）」で判断される → 動的バインディング

というルールが働くのです。

つまり、継承＋多態性（ポリモーフィズム）の文脈で初めて「バインディング」という言葉が意味を持ちます。この記事ではその仕組みを、丁寧に・図解やサンプルコード付きで解説していきます。

動的バインディングと静的バインディングの違いは、「メソッドや変数の呼び先が、いつ決まるか」です。

• 静的バインディング：コンパイル時に決まる（例：変数、static メソッド）
• 動的バインディング：実行時に決まる（例：オーバーライドされたメソッド）

たとえば、Animal a = new Dog(); のとき、a.name は静的に Animal のものが使われ、a.speak() は動的に Dog のものが呼ばれる、というのがこのページで解説したい内容です。

ポイント　覚え方

• Field と Static は Static バインディング。
• 残ったインスタンスメソッドは動的バインディング。

これだけでも問題は解けます。以下で仕組みをゆっくり深掘りしましょう。

静的バインディング ― 型を見て早決め

静的バインディングとは、「コンパイル時に呼び先が決まる処理」のことです。
Javaでは次のようなケースが静的バインディングになります。

• フィールド（変数）
• static メソッド
• private や final なメソッド
• オーバーロード（同名で引数違い）

これらは変数の型（参照型）を見てコンパイル時に呼び先が決まるので、実行時に変わることはありません。

class Animal {
    String kind = "Animal";
    static void hello() { System.out.println("Hello from Animal"); }
}
class Dog extends Animal {
    String kind = "Dog";
    static void hello() { System.out.println("Hello from Dog"); }
}
Animal a = new Dog();
System.out.println(a.kind); // ①
a.hello();                  // ②

• ① kind は変数なので 型 Animal を参照 → "Animal"。
• ② hello() は static メソッドなので型を参照 → "Hello from Animal"。

なぜコンパイル時に決められる？

コンパイラは上のコードを見ると「kind は Animal で offset いくつ」「hello() は Animal のメモリアドレスいくつ」とバイトコードに固定します。プログラムが動くときに変更される可能性がないため最速です。

動的バインディング ― 実体を見て後決め

動的バインディングとは、「実行時に呼び先が決まる処理」のことです。
Java では、オーバーライドされたインスタンスメソッドに対して動的バインディングが行われます。

これは、変数の型（参照型）ではなく、実際の中身（実体型）を見て、実行時にどのメソッドを使うかを判断する仕組みです。

class Animal {
    void speak() { System.out.println("..."); }
}

class Dog extends Animal {
    @Override void speak() { System.out.println("Bowwow"); }
}

Animal a = new Dog();
a.speak(); // → Bowwow（実体が Dog なので）

• speak() はオーバーライド可能なインスタンスメソッド。
• 実行時に JVM が「実体は Dog だ」と判断し、Dog 版の speak() を呼びます。

このように、実行時に実体のクラスを探して処理を決めるため、「多態性（ポリモーフィズム）」が実現できます。
Java の柔軟性の根幹を支える仕組みです。

ざっくり内部図

Animal a → ヒープ内 Dog オブジェクト → Dog のメソッド表 (v‑table) → Dog.speak()

JVM はこのメソッド表を O(1) で検索するので速度ロスは最小。

初期化順序トラップ（null が出る理由）

class Parent {
  Parent() { show(); }
  void show() { System.out.println("Parent"); }
}
class Child extends Parent {
  String name = "Child";
  @Override void show() { System.out.println(name); }
}
new Child(); // → null

1. Parent コンストラクタ内で show() 呼び出し。
2. 動的バインディングで Child の show() が走る。
3. しかし name まだ初期化前 → null。

試験では 「なぜ null になる？」 を説明できれば OK です。

オーバーロードは静的、ボクシングはその次

static void f(int x)     { System.out.println("int"); }
static void f(Integer x) { System.out.println("Integer"); }
static void f(int... xs) { System.out.println("varargs"); }

f(5);                // int  ← 一番ぴったり
f(Integer.valueOf(5)); // Integer

可変長引数は “最後の手段” なので出番は少なめ。

Javaには同じ文字列が何度も使われることを想定して、メモリのムダをなくす工夫があります。それが「文字列プール（String Pool）」です。intern()メソッドは、このプールと関係しています。

Javaの文字列リテラルと文字列プールとは？

Javaでは、文字列を "apple" のようにダブルクオーテーションで書いたものを文字列リテラルと呼びます。

参考　リテラルの基本概念

String s = "apple";

このように書かれた文字列は、文字列プール（String Pool）という特別な場所に自動で保存されます。文字列プールとは、同じ文字列を一度だけ保存しておく場所、そしてそれを使いまわす仕組みです。

つまり、同じ "apple" を何度使っても、同じ1つのインスタンスを共有することで、メモリの節約しよう！という考え方です。

new String()を使うと何が起こる？

次のようなコードを書いたとします。

String s = new String("apple");

このとき、"apple" というリテラルはプールに登録されますが、new String(...) は新しいインスタンスをヒープ領域に作成します。つまり、↑のコードは内部で次の２つの処理が行われています：

1. リテラル部分 "apple"：
   ソースコード中の文字列リテラルは、クラスがロードされる際に自動的に文字列プールに登録されます。つまり、この時点で "apple" は既にプール内に存在することになります。
2. new String("apple")：
   new String(...) は、プールにあるリテラル "apple" を元にしてヒープ上に新しい String オブジェクトを生成します。
   ※ この新たなオブジェクトはプールに登録されず、ヒープ上の独立した存在です。

比較するとこうなります：

String s1 = "apple";                  // プール上の"apple"
String s2 = new String("apple");     // ヒープ上の新しい"apple"

System.out.println(s1 == s2); // false（参照が異なる）

intern()の役割とは？

intern()メソッドを使うと、次のような動作をします：

「この文字列と同じ内容の文字列が文字列プールにあるかを確認し、あればそれを返す。なければプールに登録して返す」

つまり、new String(...) のようにヒープに作られた文字列も、プールにある文字列と結びつけられるのです。

String s1 = "apple";
String s2 = new String("apple");
String s3 = s2.intern();

System.out.println(s1 == s2); // false（ヒープとプールで違う）
System.out.println(s1 == s3); // true（どちらもプール）

1. リテラル "apple":
   クラスロード時に文字列プールに登録される（自動で管理される）。
2. new String("apple"):
   ヒープ上に新しいオブジェクトを生成。内部で使われているリテラルはプールされているが、この新オブジェクト自体はプールには入りません。
3. new String("apple").intern():
   プール内に既に "apple" があるので、その参照が返される（= リテラル "apple" と同じインスタンス）。

1. built は文字列リテラルではなく、new StringBuilder() で動的生成した文字列。
2. built.intern() を呼ぶと、プールに "xyz" が存在しないため、built 自身がプールに登録され、その参照を返します。
3. 以後、同じ内容 "xyz" を持つ文字列を intern() すると、プール内の同じオブジェクトが返されます。

intern()を使うと何がうれしいの？

✅ メモリ効率が良くなる

同じ文字列を何度も使っている場合、それぞれが別のインスタンスだとメモリがムダになります。intern()を使えば1つにまとめられます。

✅ ==で比較できるようになる

Javaでは==は「中身」ではなく「参照（場所）」の比較です。intern()でプールに統一しておけば、中身が同じ文字列は同じ参照になるため、==で比較できるようになります。

Java：レコード（record）の概要

Javaでは長らく「データのやり取りに使うだけのクラス」を定義するのが煩雑でした。たとえば、DTO（Data Transfer Object）やValue Object（値オブジェクト）として、単に名前や年齢などのフィールドだけ持つクラスを定義したい場合にでも、以下のようなメソッドを書き足す必要がありました。

• コンストラクタ
• getter/setter
• equals() / hashCode()
• toString()

「全部自動生成してしまえば一瞬じゃないか」と思うかもしれませんが、ツールやIDEの機能を活用しても、何らかの手間はどうしてもつきまといます。そこで、Java言語においても「冗長なコードを削減し、単純にデータを表現するのに特化したクラスが欲しい」という要望が高まりました。

その結果として、Java 14（プレビュー）で初登場し、Java 16で正式導入されたのがレコード（record）です。

レコードが解決しようとしている問題

レコードの最大の目的は「ボイラープレートコード（決まりきった定型コード）の削減」にあります。特にDTO用途で「単にデータを保持しているだけ」という構造を明示化し、かつメソッドの自動生成をしてくれます。結果として、コード量が減り、ソースが読みやすくなる効果が期待できます。

また、レコードは不変（イミュータブル）な設計を前提とするため、値オブジェクト的な使い方を推奨している点も大きな特徴です。

レコードの基本構文：record

レコードクラスを宣言するには record キーワードを使います。例えば、次のように書くと、名前（String）と年齢（int）を持つレコードを定義できます。

public record Person(String name, int age) {
}

ポイントとなるのは、括弧内の引数が、そのままレコードのフィールドとして扱われることです。上記の宣言だけで、以下のものが自動生成されます。

1. private final String name;
2. private final int age;
3. すべてのフィールドを受け取るコンストラクタ
4. name() / age() というアクセサメソッド（getter相当）
5. equals() / hashCode() / toString()

実際に内部的に自動生成されるのが↓。

public final class Person extends java.lang.Record {
    private final String name;
    private final int age;

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

    // アクセサ（getter）
    public String name() {
        return name;
    }

    public int age() {
        return age;
    }

    // equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person other = (Person) o;
        return age == other.age && java.util.Objects.equals(name, other.name);
    }

    // hashCode
    @Override
    public int hashCode() {
        return java.util.Objects.hash(name, age);
    }

    // toString
    @Override
    public String toString() {
        return "Person[name=" + name + ", age=" + age + "]";
    }
}

ご覧のように、内部的にはjava.lang.Recordを継承したfinalなクラスとして定義され、同時に各種フィールドや必要なコンストラクタ・メソッドが定義される、という仕組みです。ひとまず↑のコードが理解できれば、レコードクラスに関する基本は抑えられたと思ってOK！

フィールドの取り扱い（アクセサメソッド）

内部的にはフィールド名と同じメソッドが使えるようになるので・・・以下のようにフィールドを参照することができます。

Person person = new Person("Alice", 20);

System.out.println(person.name()); // "Alice"
System.out.println(person.age());  // 20

getterの代わりに「フィールド名と同じメソッド」が生成されるのがレコードの特徴です。なお、レコードの場合は「setter」がありません。※レコードは基本的に不変オブジェクト（後述）を想定しているため。

レコードがもたらす利点

ボイラープレートの削減

先ほど述べたように、レコードではgetter, equals, hashCode, toStringなどを自分で書かなくて済むのが最大の利点です。ちょっとしたDTOをたくさん定義したいとき、余計なコードの量が削減され、メンテナンス性も上がります。

もともと↓のように記載していたのが、たった1～2行で定義できちゃいます、というのがレコードクラスの美味しいところです。

public final class Person extends java.lang.Record {
    private final String name;
    private final int age;

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

    // アクセサ（getter）
    public String name() {
        return name;
    }

    public int age() {
        return age;
    }

    // equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person other = (Person) o;
        return age == other.age && java.util.Objects.equals(name, other.name);
    }

    // hashCode
    @Override
    public int hashCode() {
        return java.util.Objects.hash(name, age);
    }

    // toString
    @Override
    public String toString() {
        return "Person[name=" + name + ", age=" + age + "]";
    }
}

不変オブジェクトとしての設計

レコードは通常のクラスとは異なり、フィールドが暗黙的にfinal として扱われます。つまり、オブジェクトを生成した時点でフィールドは確定し、あとから値を変更できません。
これにより、「値が変わらない」という前提で設計することが容易になり、マルチスレッド環境などでの安全性も高まります。

「意図」が明確化される

普通のクラスは、何でもできてしまう柔軟性を持ちます。そのため、「このクラスは本来ただのデータを入れるだけのはずなのに、いつの間にかロジックが増えすぎている…」といった事態が起こりがちです。
一方、レコードは明示的に「データ保持用」であることを表すものなので、実装する人にも使う人にも、その意図がわかりやすく伝わります。

レコードを使う際の注意点

イミュータブルであること

レコードは不変オブジェクトとして扱われることを想定しているため、基本的にはフィールドは再代入できないようになっています。
ただし、フィールドが参照型で、内部に可変状態を持っている場合（例：List や Map など）には注意が必要です。レコード自身が保持する参照先のオブジェクトを通じて、内部データを変更できてしまう可能性があります。
深い意味での完全な不変性を担保したい場合は、フィールドに不変コレクションを設定したり、コンストラクタ内で防御的コピーを行ったりする工夫が必要です。

継承はできない

レコードは暗黙的に final 扱いとなり、サブクラスとして継承することはできません。
Javaのオブジェクト指向の文脈では「継承がクラス設計の基本手段」という面もありますが、レコードは「あくまでデータの容れ物である」という思想により、クラス継承は不要だろうという考えに基づいています。
もし、継承による多態性が必要なら、レコードよりも通常のクラスを使うことが多いでしょう。

参照型フィールドの取り扱い

先ほど少し触れましたが、レコードのイミュータブル性は「フィールドへの再代入ができない」という点を保証するだけで、オブジェクト内部までは制御していません。

• 例えば、public record MyData(List<String> list) と書いた場合、list 自体は後から他のオブジェクトに差し替えられませんが、list の内容を変更する（list.add("someValue")など）は可能です。
• これを防ぎたいなら、Collections.unmodifiableList(...) を用いるなど、工夫が必要です。

コンストラクタ周りの詳細

レコードでは「すべてのフィールドを引数に取るコンストラクタ」（参考 コンストラクタとは？）が自動的に定義されます。先ほどの Person であれば new Person(String name, int age) というコンストラクタがすでに用意されます。

public final class Person extends java.lang.Record {
    private final String name;
    private final int age;

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

ただし、このコンストラクタに関しては、覚えておきたい必須知識がいくつかありますので、ここで解説しておきます。

カノニカルコンストラクタ

括弧内に宣言したフィールドの組み合わせと同じシグニチャのコンストラクタを「カノニカルコンストラクタ」と呼びます。

public record Person(String name, int age) {
    public Person(String name, int age) {
        // ここに処理を書いてもOK（必ず this.name = name; などの代入をしなければならない）
        this.name = name;
        this.age = age;
    }
}

先ほども解説した通り、カノニカルコンストラクタはレコードクラスを定義すると自動的に生成されますが、これをあえて自分で定義することも可能です。自分で定義するときは、レコードが自動生成するコードを「上書き」するイメージで記述していけばOKで、自分でバリデーションや初期化処理を細かく書きたいときに使います。

ただし、注意しなければいけないのが、カノニカルコンストラクタを利用するときは、必ずカノニカルコンストラクタ内ですべてのフィールドを初期化する必要がある！という点です。レコード特有の制限になるので頭に入れておきましょう。

public record Book(String title, int price) {

    // カノニカルコンストラクタを明示的に定義
    public Book(String title, int price) {
        // 追加ロジック（例：タイトルが空文字ならエラー）
        if (title == null || title.isBlank()) {
            throw new IllegalArgumentException("タイトルは必須です");
        }
        if (price < 0) {
            throw new IllegalArgumentException("価格は0以上である必要があります");
        }

        // 必須：レコードのすべてのフィールドを初期化
        this.title = title;
        this.price = price;
    }
}

上記のように全コンポーネントをパラメータとして受け取り、その値で必ずフィールドを初期化する必要があります。

コンパクトコンストラクタ

レコードには、さらに便利な「コンパクトコンストラクタ」という書き方があります。
これはシグニチャがカノニカルコンストラクタと同一（= 全フィールドを引数に取る）である点は変わりませんが、メソッドシグニチャを省略して書ける構文です。

public record Book(String title, int price) {

    // コンパクトコンストラクタ（シグニチャ省略）
    public Book {
        if (title == null || title.isBlank()) {
            throw new IllegalArgumentException("タイトルは必須です");
        }
        if (price < 0) {
            throw new IllegalArgumentException("価格は0以上である必要があります");
        }
        // title, price への代入は暗黙的に行われる
        // → this.title = title; this.price = price; 
    }
}

コンパクトコンストラクタでは、括弧内に引数を再度書かなくていい（すでにレコードで宣言してあるから）という簡略化がなされています。ここで書かれた処理は、最終的にレコードのフィールドを初期化する「カノニカルコンストラクタ」に統合されるイメージです。データに対するバリデーションや前処理を入れる場合、コンパクトコンストラクタが非常に便利です。

レコードの活用例

DTO（データ転送オブジェクト）としての利用

最も典型的な利用方法のひとつが、DTO（Data Transfer Object）としての利用です。
アプリケーション内で複数の値をまとめて別のメソッドやモジュールへ引き渡すとき、単にフィールドを持つためだけのクラスを作ることがあります。そこにレコードが大変便利です。

// 例: 顧客情報DTO
public record CustomerDto(String name, String email, String address) {
}

こうしておけば、わざわざgetterやequals()などを書かずに済みますし、「ああ、これはただのデータ入れ物なんだな」という意図を明示できます。

Web APIレスポンスの格納

サーバーサイドJavaやクライアント側でWeb APIをコールして、その結果返ってきたJSONやXMLなどをオブジェクトとして受け取る機会はよくあります。
このとき、少し前まではPOJO（Plain Old Java Object）やLombokで生成したクラスを使うことが主流でしたが、Java 16以降なら気軽にレコードを使えます。

public record UserResponse(String username, int age, String city) {
}

JacksonやGsonといったライブラリも、（バージョンや設定によりますが）レコードをある程度認識して扱えるようになっています。シリアライゼーションやデシリアライゼーションの際に、コンストラクタ引数を使う形で解釈してくれます。

小規模な値オブジェクトの表現

ドメイン駆動設計(DDD)の文脈などで、値オブジェクトという単位が存在します。これらは通常、同値性を判定するための equals() と hashCode() が欠かせません。さらに、値オブジェクトはイミュータブルであることが推奨されます。
レコードで定義すれば、その2点（同値性メソッドとイミュータブル設計）をあまり意識せずに自動で満たせるため、値オブジェクトを気軽に作成できます。

レコードの制限事項・よくある疑問

サブクラスは作れない？

先ほども触れましたが、レコードは暗黙に final なクラスとして扱われるため、継承によるサブクラス化は不可能です。
もしどうしても似たようなレコード同士を共通インターフェースでまとめたいなら、インターフェース（あるいはsealed interface）を実装する形をとることは可能です。

public sealed interface Animal permits Cat, Dog {
    String name();
}

public record Cat(String name) implements Animal {}
public record Dog(String name) implements Animal {}

Java：インターフェースとは？わかりやすく３分で解説(interface/implements)

【超・初心者向け】Javaのインターフェースとは？その基本概念と利用する理由、そして拡張性の高さについて、具体的なサンプルコードと日常生活の例を交えてわかりやすく解説します。インターフェースを使った柔軟で拡張性の高いプログラム設計を学びましょう。

it-biz.online

2025.04.13

equals(), hashCode(), toString()のカスタマイズはどうなる？

レコードでは、フィールドに基づいた equals() や hashCode()、toString() が自動生成されます。
しかし、どうしてもカスタマイズしたいケースがあるかもしれません。その場合、通常のクラスと同じように自分でメソッドをオーバーライドできます。

public record Person(String name, int age) {
    @Override
    public String toString() {
        return "名前=" + name + ", 年齢=" + age;
    }
}

ただし、「レコードは純粋に値を表現する」ことが目的ですから、むやみにメソッドを上書きするのは設計上あまり好ましくない場合もあります。必要性をよく検討したうえで行うのがよいでしょう。

レコードの可変フィールドは？

レコードのフィールドは暗黙的に private final となるため、可変（var）なフィールドは基本的に定義できません。そのため、「後から値を変えたい」ケースや「大きなオブジェクトを段階的に組み立てたい」ケースにはレコードは不向きです。

どうしても可変が必要なら、通常のクラスを使うか、あるいはビルダーパターンを検討するほうが適切な場合が多いです。

レコードは「単にデータを表すだけの軽量クラス」をとてもシンプルに表現できる仕組みです。Lombokのように外部ライブラリに頼らなくても、Java言語標準だけでボイラープレートを削減できる点は大きなメリットといえます。

また、レコードはイミュータブルな値オブジェクトの表現とも非常に相性が良いため、DDD（ドメイン駆動設計）の文脈や並行処理の多いアプリケーションでも有効です。ただし、継承ができないという仕様や可変データ構造を扱うときの注意など、いくつかの制限はあるので、何でもかんでもレコードにすればいいわけではありません。

ぜひ、Javaのバージョンが16以上を使える環境であれば、従来のJavaクラスで煩雑だった部分をレコードに置き換えてみて、そのシンプルさと読みやすさを実感してみてください。適切に使い分けることで、ソースコードが洗練され、メンテナンスがしやすくなるはずです。

特にJava Silver試験などでよく問われる内容でもあり、今後徐々に利用頻度が増えていくと思われる重要構文の１つです。現場で活躍できるJavaプログラマーを目指す方であれば知っておきたい基本知識の１つです。

このページではパターンマッチング機能について１からわかりやすく解説します。是非最後までご覧ください。

【前提】instanceofでの判定とキャスト

Java 15以前では、あるオブジェクトが特定の型かを判定し、それを利用しようとする場合、次のように「判定 → キャスト」の2段階を踏むのが一般的でした。

Object obj = "Hello World"; // ここでは実際は String 型

if (obj instanceof String) {
    // まず instanceof で判定
    String s = (String) obj; // キャストを明示的に書く
    System.out.println(s.toUpperCase());
}

1. if (obj instanceof String) で型チェック (String型かどうか)
2. String s = (String) obj; でキャスト
3. s.toUpperCase() のようにメソッド呼び出し

このように、判定とキャストがそれぞれ別々の箇所に存在し、キャストが常に明示的に必要という点がやや煩わしいところでした。

参考　キャストとは？

パターンマッチング付きinstanceofの基本構文

Java 16以降では、上記処理をより簡潔に記述できるようになりました。

Object obj = "Hello World";

if (obj instanceof String s) {
    // 'instanceof String s' で判定とキャストを同時に行う
    System.out.println(s.toUpperCase());
}

この書き方では、

• obj instanceof String s が「パターン」にあたります。
  • String s と書くことで、objがString型の場合に、自動的にその型で扱うための変数 s を用意してくれます。
  • 実際には(String)objをする必要がなくなり、冗長なキャストが省略できます。
• objがString型でない場合はif文の条件がfalseとなるので、ブロック内部は実行されません。

パターンマッチング機能のメリット

1. コードがスッキリ
   • 従来のように毎回キャストを書く必要がなくなり、可読性が向上します。
2. スコープの明確化
   • sという変数はifブロック内のみ有効になるため、意図しない範囲で使われる可能性がありません。
3. 安全性の向上
   • instanceofの結果がtrueだった場合だけパターン変数が使えるので、ClassCastExceptionのリスクを意識しなくて済みます。

パターン変数のスコープと使い方

パターンマッチングを行った変数（上の例だと s）の有効範囲（スコープ）は、instanceofのチェックが行われたブロック内に限られます。↓のコードを見てみましょう。

Object obj = "Hello World";

if (obj instanceof String s) {
    // ここでは s は String 型として使える
    System.out.println("Upper case: " + s.toUpperCase());
} else {
    // ここでは s は使えない
    // System.out.println(s.toLowerCase()); // コンパイルエラーになる
}

• ifブロック内では、変数sはString型として使用できます。
• elseブロックやifブロックを抜けた後では、sは「存在しない」扱いなので使用できません。

これは一見不便に思えるかもしれませんが、「その型だと判明している場所だけでしか使わない」という意図が明確になるため、可読性と安全性が高まります。

public class InstanceofScopeExample {
    public static void main(String[] args) {
        Object obj = "Hello World";

        // パターン①: instanceof が true になる場合
        if (obj instanceof String s) {
            System.out.println("[1] 大文字: " + s.toUpperCase()); // → OK: "HELLO WORLD"
        } else {
            // s はこのスコープでは未定義なので使えない
            // System.out.println(s.toString()); // ❌ コンパイルエラー
        }

        // パターン②: 否定して else にスコープが移る場合
        if (!(obj instanceof String s)) {
            System.out.println("[2] Object: " + obj.toString()); // → s は未定義なので使えない
            // System.out.println(s.toString()); // ❌ コンパイルエラー
        } else {
            // s はここで有効（判定が true であることが確定）
            System.out.println("[2] 小文字: " + s.toLowerCase()); // → OK: "hello world"
        }
    }
}

論理演算子（AND/ORなど）と組み合わせる場合

Java 16で導入されたパターンマッチングは「論理演算子」と組み合わせて書く場合が特に強力です。よくある例として、&&（AND）を使って条件がtrueになった場合のみ追加チェックをしたいケースがあります。

Object obj = "Hello World";

if (obj instanceof String s && !s.isEmpty()) {
    // obj が String にマッチし、かつ s が空文字列ではない場合
    System.out.println("Lower case: " + s.toLowerCase());
}

• obj instanceof String s がtrueのときだけ変数 s がString型として扱える
• その結果をさらに使って !s.isEmpty() をチェック

ここでのポイントは、instanceofがtrueでないと&&の右側は評価されない（短絡評価）ため、sを安全に使うことができます。（左側がfalseの場合は右側にたどり着かないので、そもそもStringとしての操作が行われず、ClassCastExceptionなどの心配もありません。）

なぜ「パターンマッチング」と呼ばれるのか

「パターンマッチング」という用語は、たとえばScalaやKotlinなどではmatch式やwhen式として、型や値のパターンをマッチさせて分岐処理を簡潔に記述できる機能を指します。Javaのinstanceofへの拡張は「パターンマッチングを導入する」流れの一部で、将来的にはswitch文などでもパターンマッチングを活用できる機能が拡充されています（Java 17以降でプレビュー機能として提供）。

instanceof String s は、

• 「もし obj が String型というパターンにマッチしたならば」
• 「そのマッチ対象を s という変数として使えるようにする」

という発想で書かれています。これが「パターンマッチング」と呼ばれる理由です

if-else if-else構文との併用

複数の型の可能性をチェックするケースも、よりスマートに書けます。

Object obj = Integer.valueOf(100);

if (obj instanceof String s) {
    System.out.println("It's a String: " + s.toUpperCase());
} else if (obj instanceof Integer i) {
    System.out.println("It's an Integer: " + (i + 10));
} else {
    System.out.println("Unknown type.");
}

// It's an Integer: 110

objがそれぞれどの型にマッチしたかで場合分けできますし、マッチしたブロック内では常に該当の型として安全に操作できます。

ネストした条件分岐

パターン変数が使えるのは、そのif文や、論理演算子でつながった同一の評価式内になります。

Object obj = "Nested Checking";

if (obj instanceof String s) {
    if (s.length() > 5) {
        System.out.println("String is more than 5 characters");
    }
}

// String is more than 5 characters

このようにネストしていくことも可能ですが、論理演算子（&&や||）を使ってまとめて書く方法も便利です。

Java 16以降を使える環境であれば、このパターンマッチングを活用してみることをおすすめします。条件分岐やキャスト周りのコードが大幅にシンプルになり、可読性と保守性が向上するはずです。ぜひ活用してみてください！