本文へスキップ

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

Java入門

Javaの定数の書き方|static finalとenumの使い分け

CATEGORY
DRAWN BY
TOM
DATE
REV.
READ
約18分
SHEETS
8枚
Java定数(static final と enum の使い分け)

トム

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

𝕏

定数の値を10から20に書き換えて、定数を書いたクラスだけをコンパイルし直す。それなのに実行すると、画面には10が出る。Javaの仕様では、想定どおりの動きです。

Javaの定数は static final で宣言し、名前は MAX_RETRY_COUNT のように大文字とアンダースコアで書きます。置き場所は、1つのクラスでしか使わないならそのクラスの中、複数のクラスで使うなら定数クラス、選択肢の集まりなら enum です。

書き方から置き場所の選び方まで、OpenJDK 23.0.1 の javac と java で実行した結果つきでまとめました。冒頭の「10のまま」が起きる理由も、仕様書(JLS)の該当節と手元の再現で確かめています。

この記事でわかること

  • static final の書き方と、MAX_RETRY_COUNT 型の命名ルール
  • final と static final の違い(インスタンスごとか、クラスに1つか)
  • 定数クラス・インターフェース定数・enum の使い分けと、インターフェースに定数を置かない理由
  • 定数だけ書き換えて再コンパイルしても古い値が残る仕組み(JLS 13.1・13.4.9 と手元の再現)
  • 標準ライブラリの定数(StandardCharsets.UTF_8 など)と、Pattern を定数に持つ書き方
  • 定数式の定数は、読んでもクラスの初期化が起きないこと
  • final を付けても中身が変わってしまう List と、List.of による不変化
  • static の付け忘れ・case に書けない定数など、よくある間違い

命名規則の全体(クラス・メソッド・変数・パッケージ)はJava命名規則とコーディング規約に任せ、この記事は「定数をどう宣言し、どこに置くか」に絞ります。enum の宣言・switch・values() などの使い方はJava enum完全ガイドに詳しく書いてあるので、ここでは定数との使い分けの判断に必要な範囲だけを扱います。

PARTS LIST /目次

Javaの定数の書き方|static finalで宣言する

Javaの定数とは、一度値を入れたら変更できない変数のことです。定数専用の構文はなく、final を付けた変数がその役を担います。クラス全体で共有する定数には、さらに static を付けて static final にします。

宣言の形と、使うときの書き方は次のとおりです。

基本の宣言と使い方

定数は、型の前に public static final を並べて宣言し、宣言と同時に値を入れます。使うときは クラス名.定数名 で呼び出し、同じクラスの中なら定数名だけで済みます。

public class Basic {
    // クラスに1つだけ。大文字スネークで書く
    public static final int MAX_RETRY_COUNT = 3;
    public static final String DEFAULT_CHARSET = "UTF-8";
    public static final double TAX_RATE = 0.10;

    public static void main(String[] args) {
        for (int i = 1; i <= MAX_RETRY_COUNT; i++) {
            System.out.println(i + "回目の試行 (" + DEFAULT_CHARSET + ")");
        }
        System.out.println("税込: " + (int) (1000 * (1 + TAX_RATE)));
    }
}

実行結果です。

1回目の試行 (UTF-8)
2回目の試行 (UTF-8)
3回目の試行 (UTF-8)
税込: 1100

試行回数の3や文字コードの "UTF-8" に名前を付けておくと、「3回で足りないから5回にしたい」となっても、書き換えるのは宣言の1行だけです。コードの中に 3 を直接書く方法(マジックナンバー)だと、同じ意味の 3 を探して回ることになります。

定数の名前は大文字スネークケースで書く

定数の名前は、すべて大文字にして単語をアンダースコアで区切ります。MAX_RETRY_COUNT・DEFAULT_TIMEOUT_MILLIS・DATE_FORMAT の形です。全部大文字の名前を見れば、読み手は「変わらない値だ」と一目で分かります。

  • 単語の区切りは _(maxRetryCount のようなキャメルケースにしない)
  • 値の意味に加えて、単位があるなら名前に入れる(TIMEOUT_MILLIS・WIDTH_PX)
  • 数字から始めない(3_TIMES は名前として書けない)
  • TRUE・ZERO のように、値をそのまま言い換えただけの名前は付けない

クラス名や変数名の命名ルールと並べて見たいときは、命名規則の一覧に早見表があります。

定数に代入し直すとコンパイルエラーになる

final を付けた変数は、2回目の代入をコンパイラが止めます。次のコードで確かめました。

public class Reassign {
    static final int MAX = 10;

    public static void main(String[] args) {
        MAX = 20;
    }
}
Reassign.java:6: エラー: static final変数MAXに値を割り当てることはできません
        MAX = 20;
        ^
エラー1個

メッセージは日本語環境の javac が出したものです。実行する前に、書き換えようとした行が分かります。

constキーワードは使えない
C言語の const に当たるものは、Javaでは final です。const は予約語として確保されていますが、今のJavaでは使われておらず、変数名にも使えません(JLS 3.9)。予約語の一覧はJava予約語一覧にあります。

自作する前に標準ライブラリの定数を探す

"UTF-8" のような文字列や、円周率・int の最大値は、標準ライブラリにすでに定数があります。文字コードは文字列で書くより StandardCharsets.UTF_8 のほうが、綴りの間違いがコンパイル時に分かります。

初期化に処理が要る値も、static final に置けます。たとえば正規表現の Pattern は、compile で作る処理を呼ぶたびに繰り返すのは無駄なので、メソッドの中で毎回作らず、定数として1回だけ作って使い回します。

import java.nio.charset.StandardCharsets;
import java.util.regex.Pattern;

public class StdConst {
    // 毎回 compile しないよう、Pattern は定数に持つ(定数式ではないが static final でよい)
    private static final Pattern DIGITS = Pattern.compile("\\d+");

    public static void main(String[] args) throws Exception {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Math.PI);
        byte[] bytes = "定数".getBytes(StandardCharsets.UTF_8);   // "UTF-8" と文字列で書かない
        System.out.println(bytes.length);
        System.out.println(DIGITS.matcher("abc123").find());
        System.out.println(System.lineSeparator().length());
    }
}
2147483647
3.141592653589793
6
true
1

Pattern.compile(...) はメソッド呼び出しなので定数式にはなりませんが、static final として宣言できます。この「定数式ではない static final」が、あとの節で出てくる「古い値が残らない定数」です。改行コードのように環境で変わる値は、定数にせず System.lineSeparator() で取ります。「Java 改行コード 定数」で調べている場合の答えは、定数ではなくメソッドです。

finalとstatic finalの違い|変わらないのはどちらか

final は「代入が1回きり」という意味で、static は「クラスに1つだけ」という意味です。2つは別の話なので、組み合わせ方で意味が変わります。フィールドに付けるか、ローカル変数に付けるかでも使いどころが違うので、先に3つを並べて比べます。

書き方値を持つ場所値が決まる時期使いどころ
final int id;(フィールド)インスタンスごとコンストラクタの終わりまで作ったあとに変わらないIDなど
static final int LIMIT = 100;クラスに1つクラスの読み込み時全体で共通の定数
final int x = 5;(ローカル変数・引数)メソッドの中代入した時再代入を防ぎたい変数

finalだけならインスタンスごとに値を持てる

static を付けない final フィールドは、インスタンスを作るたびに別の値を入れられます。値は代入できる回数が1回なだけで、全インスタンスで同じ値になるとは限りません。

public class FinalVsStatic {
    static int created = 0;

    final int id;                    // final だけ: インスタンスごとに別の値を持てる
    static final int LIMIT = 100;    // static final: クラスに1つだけ

    FinalVsStatic() {
        this.id = ++created;
    }

    public static void main(String[] args) {
        FinalVsStatic a = new FinalVsStatic();
        FinalVsStatic b = new FinalVsStatic();
        System.out.println("a.id=" + a.id + " b.id=" + b.id);
        System.out.println("LIMIT=" + FinalVsStatic.LIMIT);
    }
}
a.id=1 b.id=2
LIMIT=100

id は a と b で別の値です。この id を「定数」と呼ぶ人もいますが、全体で共通の設定値ではないので、定数として使う場面とは別物です。

static finalはクラスに1つの共通の値になる

LIMIT のように値が最初から決まっていて、どのインスタンスでも同じなら、static final にします。static を付け忘れると、インスタンスを作るたびに同じ値をそれぞれが持つことになります。値が1つあれば足りるのに、無駄が出ます。

static final はクラスが読み込まれるときに1回だけ値が入ります。インスタンスを1つも作らなくても FinalVsStatic.LIMIT のように呼べるのは、このためです。

ローカル変数や引数に付けるfinal

メソッドの中の変数にも final を付けられます。こちらは「この変数は再代入しない」という宣言で、再代入するコードを書くとコンパイルエラーです。変数がどの範囲で見えるか(スコープ)はJava変数のスコープで整理しています。ローカル変数は見える範囲が狭いので、定数として名前を付けるより、再代入の事故を防ぐ目的で使うことが多い書き方です。

定数の置き場所|クラス内・定数クラス・interface・enum

定数をどこに書くかは、使う範囲と、値が「選択肢の集まり」かどうかで決まります。迷ったら次の流れで選べます。

flowchart TD
    A["値に名前を付けたい"] --> B{"選択肢の集まり?<br>例: 注文の状態"}
    B -->|"はい"| E["enum にする"]
    B -->|"いいえ"| C{"使うクラスは<br>1つだけ?"}
    C -->|"はい"| P["そのクラスの中に<br>private static final"]
    C -->|"いいえ"| K["定数クラスにまとめる<br>final + private コンストラクタ"]

インターフェースに定数を置く方法は、この流れに入れていません。理由は、あとの節で扱います。

1つのクラスでしか使わないならprivate static final

使うのが1クラスだけなら、そのクラスの中に private static final で書きます。他のクラスから見えないので、あとで値を変えても影響範囲が読めます。

public class OrderService {
    private static final int MAX_ITEMS = 100;

    void validate(int count) {
        if (count > MAX_ITEMS) {
            throw new IllegalArgumentException("上限は" + MAX_ITEMS + "件です");
        }
    }
}

最初は private で書き、別のクラスからも要るとわかった時点で、公開するか、定数クラスに移します。最初から public にしておくと、あとで「どこから使われているか」を調べる手間が増えます。

複数のクラスで使うなら定数クラスにまとめる

複数のクラスから使う値は、定数だけを持つクラスにまとめます。このとき、クラスを final にして継承を禁じ、コンストラクタを private にして、インスタンス化もできなくします。

// 定数クラス: final にして、インスタンス化できないようにする
public final class AppConstants {
    public static final int MAX_RETRY_COUNT = 3;
    public static final String DATE_FORMAT = "yyyy-MM-dd";

    private AppConstants() {
        // new させない
    }
}

new AppConstants() と書くと、javac が止めます。

UseConstants.java:5: エラー: AppConstants()はAppConstantsでprivateアクセスされます
        AppConstants c = new AppConstants();
                         ^
エラー1個

定数クラスには、1つの落とし穴があります。public static final で書いた定数は、使う側のクラスにコンパイル時に値が埋め込まれます。この仕組みは、後半の「定数だけ直しても古い値が残る?」で再現します。

インターフェースに定数を書かない理由

インターフェースのフィールドは、何も書かなくても public static final になります(JLS 9.3)。そのため、インターフェースに int MAX = 10; と書けば定数になり、実装したクラスからは MAX と書くだけで見えます。手軽ですが、勧められません。理由は3つあります。

  • 実装しただけのクラスの公開APIに、定数が混ざる
  • 同じ名前の定数を持つインターフェースを2つ実装すると、あいまいでコンパイルエラーになる
  • インターフェースの役割(「このメソッドを持つ」という契約)から外れる

1つめは、次のコードで確かめられます。

interface Limits {
    int MAX = 10;   // interface のフィールドは public static final になる
}

class Worker implements Limits {
    int doubled() {
        return MAX * 2;   // Limits.MAX と書かなくても見える
    }
}

public class IfaceMain {
    public static void main(String[] args) {
        System.out.println(new Worker().doubled());
        System.out.println(Worker.MAX);   // Worker の公開 API のように見えてしまう
    }
}
20
10

Worker.MAX が通ります。Worker は定数を使いたかっただけなのに、外から見ると「Worker は MAX を持っている」クラスになっています。

2つめは、同じ名前の定数を持つ2つのインターフェースを実装した場合です。

interface A { int SIZE = 1; }
interface B { int SIZE = 2; }

class Impl implements A, B {
    int size() {
        return SIZE;
    }
}
Clash.java:6: エラー: SIZEの参照はあいまいです
        return SIZE;
               ^
  Aの変数 SIZEとBの変数 SIZEの両方が一致します
エラー1個

定数を使うためにインターフェースを実装したクラスが増えるほど、こうした衝突が起きやすくなります。定数は、定数クラスか enum に置いてください。

選択肢の集まりはenumにする

「未払い」「支払い済み」のように、取りうる値が決まっている集まりは、int の定数で並べずに enum にします。int の定数だと、コンパイラは種類の取り違えも範囲外の値も止められません。

public class IntStatus {
    static final int STATUS_UNPAID = 0;
    static final int STATUS_PAID = 1;
    static final int ROLE_ADMIN = 1;   // 値がたまたま同じ

    static String label(int status) {
        switch (status) {
            case STATUS_UNPAID: return "未払い";
            case STATUS_PAID:   return "支払い済み";
            default:            return "不明";
        }
    }

    public static void main(String[] args) {
        System.out.println(label(STATUS_PAID));
        System.out.println(label(ROLE_ADMIN));  // 別の種類の定数を渡しても通る
        System.out.println(label(99));          // 範囲外でも通る
    }
}
支払い済み
支払い済み
不明

2行目が問題です。注文の状態を渡すべき場所に、権限の定数 ROLE_ADMIN を渡しても、値が同じ1なので「支払い済み」と判定されます。同じものを enum で書き直すと、2つとも javac が止めます。

public class EnumStatus {
    enum Status { UNPAID, PAID }
    enum Role { ADMIN, USER }

    static String label(Status status) {
        return switch (status) {
            case UNPAID -> "未払い";
            case PAID   -> "支払い済み";
        };
    }

    public static void main(String[] args) {
        System.out.println(label(Status.PAID));
        System.out.println(label(Role.ADMIN));
        System.out.println(label(99));
    }
}
EnumStatus.java:14: エラー: 不適合な型: RoleをStatusに変換できません:
        System.out.println(label(Role.ADMIN));
                                     ^
EnumStatus.java:15: エラー: 不適合な型: intをStatusに変換できません:
        System.out.println(label(99));
                                 ^
エラー2個

enum には、値に加えてフィールドを持たせることもできます。HTTPのステータスコードのように、名前と数値をセットで持ちたい場合の形です。

public class EnumValue {
    enum HttpStatus {
        OK(200), NOT_FOUND(404);

        private final int code;
        HttpStatus(int code) { this.code = code; }
        int code() { return code; }
    }

    public static void main(String[] args) {
        for (HttpStatus s : HttpStatus.values()) {
            System.out.println(s + " = " + s.code());
        }
    }
}
OK = 200
NOT_FOUND = 404

enum の宣言・比較(== と equals)・switch との組み合わせは、Java enum完全ガイドで扱っています。

迷ったときの選び方

置き場所の判断を、表にまとめます。

値の性質置き場所理由
1クラスだけで使う設定値private static final(そのクラス内)影響範囲がそのクラスで閉じる
複数クラスで使う設定値(上限・書式・URLなど)定数クラス(final + private コンストラクタ)1か所で管理できる
取りうる値が決まった集まり(状態・種別・権限)enum取り違えと範囲外の値をコンパイラが止める
名前と数値などをセットで持つ集まりフィールド付きの enum値の組み合わせを1か所にまとめられる
実装クラスに持たせる定数置かない(定数クラスか enum へ)公開APIに混ざり、名前が衝突する

定数だけ直しても古い値が残る?コンパイル時定数の罠

static final の定数は、書き換えてその定数のクラスだけ再コンパイルしても、使っているクラスには古い値が残ることがあります。原因は、使う側のクラスに値そのものが埋め込まれるためです。冒頭の「10のまま」は、この仕組みで起きています。

コンパイル時定数は使う側にコピーされる

JLS 4.12.4 は、定数変数(constant variable)を「プリミティブ型か String 型の final 変数で、定数式で初期化されたもの」と定義しています。定数式は、リテラル・算術や比較の演算・文字列連結・他の定数変数への参照などで作った式です(JLS 15.29)。new やメソッド呼び出しは含まれません。

そして JLS 13.1 は、定数変数への参照を「コンパイル時に初期化子の値に解決しなければならない」と定めています。Config.MAX と書いた箇所は、実行時に Config クラスを見に行くコードではなく、10 という値そのものに置き換わるということです。

JLS 13.4.9 は、この結果を直接書いています。static な定数変数の値を変えても、すでにコンパイルされたバイナリは、再コンパイルしない限り新しい値を見ません。条件付きコンパイル(if (DEBUG) を丸ごと消す仕組み)を支えるための副作用だと説明されています。

手元で再現する

仕様の文章だけでなく、手元で実際に動かしました。まず定数を書いたクラスと、使うクラスを用意します。

// Config.java
public class Config {
    public static final int MAX = 10;
}
// Main.java
public class Main {
    public static void main(String[] args) {
        System.out.println("MAX = " + Config.MAX);
    }
}
LOGこの記事の執筆中(OpenJDK 23.0.1)定数だけ書き換えて、定数のクラスだけコンパイルし直した

Config.java の MAX を10から20に書き換え、Config.java だけを javac にかけました。Main は触っていません。この状態で Main を実行すると、画面には MAX = 10 が出ます。Main.class を javap で開くと、Config.MAX を読む命令がなく、MAX = 10 という1つの文字列が埋め込まれていました。

手順と結果は次のとおりです。

# 1回目: 両方をコンパイルして実行
javac -d out Config.java Main.java
java -cp out Main
# Config.java の MAX を 20 に書き換えて、Config.java だけをコンパイル
javac -d out Config.java
java -cp out Main
# 両方をコンパイルし直して実行
javac -d out Config.java Main.java
java -cp out Main
MAX = 10
MAX = 10
MAX = 20

2行目が、書き換えたのに残った古い値です。javap -c で Main.class を開くと、理由が見えます。

public static void main(java.lang.String[]);
  Code:
     0: getstatic     #7    // Field java/lang/System.out:Ljava/io/PrintStream;
     3: ldc           #15   // String MAX = 10
     5: invokevirtual #17   // Method java/io/PrintStream.println:(Ljava/lang/String;)V
     8: return

Config.MAX を読む getstatic がありません。"MAX = " + Config.MAX という文字列連結まで、コンパイル時に "MAX = 10" という1つの文字列に畳み込まれています。Main.class は、実行時に Config を見に行く必要がないからです。

インライン化される定数・されない定数

どんな書き方の定数がコピーされるのかを、次の7つで確かめました。Config.java の値だけを書き換えて、Config.java だけを再コンパイルし、Main を実行した結果です。

宣言定数だけ再コンパイルしたあとの Main の表示新しい値が見えるか
static final int MAX = 10; → 2010見えない
static final String NAME = "old"; → "new"old見えない
static final int DAY_SECONDS = 24 * 60 * 60; → 186400見えない
static final String KEY = NAME + "-key";old-key見えない
static final Integer MAX = 10; → 2020見える
static final int MAX = Integer.parseInt("10"); → "20"20見える
static final int FROM_CALL = Math.abs(-1); → -55見える

境目は、初期化子が定数式かどうかです。int・String のリテラルや、その計算・連結は定数式なので、値がコピーされます。ラッパー型の Integer や、メソッド呼び出し(parseInt・abs)が入った式は定数式ではないので、使う側は実行時に Config から値を読みます。

定数を読むだけではクラスの初期化も起きない

定数式の static final には、もう1つ違いがあります。使う側が値を埋め込んでいるので、読んでも持ち主のクラスは初期化されません。JLS 12.4.1 は、クラスが初期化される条件の1つを「static フィールドが使われ、そのフィールドが定数変数ではないとき」と書いています。

class Holder {
    static {
        System.out.println("Holder が初期化された");
    }
    static final int CONST = 5;                        // 定数式
    static final int RUNTIME = Integer.parseInt("5");  // 定数式ではない
}

public class InitDemo {
    public static void main(String[] args) {
        System.out.println("CONST を読む");
        System.out.println(Holder.CONST);
        System.out.println("RUNTIME を読む");
        System.out.println(Holder.RUNTIME);
    }
}
CONST を読む
5
RUNTIME を読む
Holder が初期化された
5

CONST を読んだ時点では、Holder の static ブロックは動きません。RUNTIME を読んで初めて、Holder が初期化された が出ます。定数クラスの static ブロックに処理を書いても、定数式の定数を読むだけでは動かない、ということです。

古い値が残る事故を避ける方法

自分のプロジェクトの中だけなら、ビルドツールでクリーンビルド(古い .class を消してから全体をコンパイル)すれば、全部のクラスが新しい値を見ます。事故が起きやすいのは、定数を持つクラスだけを差し替えて配る場合です。

  • 全体を再コンパイルする:定数を持つクラスを変えたら、使うクラスも含めてビルドし直す
  • 変わりうる値は定数式にしない:設定値のように変わる可能性があるものは、メソッド経由(getMaxRetry())か、Integer などの非定数式にする
  • 配布するライブラリの公開定数は書き換えない:使う側が再コンパイルしないと、新しい値は届かない

3つめは、JLS 13.4.9 の勧めにも沿っています。同じ節は、真の数学定数でもない限り、static な定数変数の利用は控えめにするよう勧めています。読み取り専用にしたいだけなら、public static final ではなく、private static 変数とアクセサメソッドを使うほうがよい、という書き方です。

ハマりポイント
定数クラスだけ差し替えても、使う側のクラスは古い値のまま

値を変えたつもりでも、使う側のクラスに値が埋め込まれていると、実行時の表示は変わりません。クラスファイルを個別に差し替えて配る場合は、使う側も一緒にコンパイルし直してください。

finalでも中身は変わる|List.of で不変にする

final が止めるのは「変数への再代入」です。変数が指しているオブジェクトの中身は止めません。定数として List や配列を持つときに、いちばん誤解しやすい点です。

final の List には要素を追加できる

static final List<String> として宣言しても、add で要素を足せます。配列も、要素の書き換えを止められません。

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

public class FinalList {
    static final List<String> NAMES = new ArrayList<>(List.of("A", "B"));
    static final int[] SIZES = {1, 2, 3};

    public static void main(String[] args) {
        NAMES.add("C");       // final でも中身は変えられる
        SIZES[0] = 99;
        System.out.println(NAMES);
        System.out.println(java.util.Arrays.toString(SIZES));
        // NAMES = new ArrayList<>();   // こちらはコンパイルエラー(参照の付け替えは不可)
    }
}
[A, B, C]
[99, 2, 3]

コメントアウトした NAMES = new ArrayList<>(); は、javac が止めます。

Reassign.java:8: エラー: static final変数NAMESに値を割り当てることはできません
        NAMES = new ArrayList<>();
        ^
エラー1個

つまり、final は「どのリストを指すか」を固定し、「リストに何が入っているか」は固定しません。

ハマりポイント
final を付けたリストを、どこかのコードが書き換える

public な static final List は、使う側のどのコードからでも add できます。定数のつもりのリストが、実行中に増えたり減ったりします。中身まで固定するなら、次の節の List.of を使います。

List.of・copyOf・unmodifiableList の違い

中身を変えられない定数にするには、List.of で作ります。List.of で作ったリストに add すると、UnsupportedOperationException が出ます。

List<String> fixed = List.of("A", "B");
try {
    fixed.add("C");
} catch (UnsupportedOperationException e) {
    System.out.println("List.of は追加できない: " + e.getClass().getSimpleName());
}

// unmodifiableList は「読み取り専用の窓」。元のリストを変えると見える中身も変わる
List<String> base = new ArrayList<>(List.of("X"));
List<String> view = Collections.unmodifiableList(base);
base.add("Y");
System.out.println("view = " + view);

// copyOf は独立したコピー
List<String> copy = List.copyOf(base);
base.add("Z");
System.out.println("copy = " + copy + ", base = " + base);
List.of は追加できない: UnsupportedOperationException
view = [X, Y]
copy = [X, Y], base = [X, Y, Z]

3つの違いを表にします。

作り方変更できるか元のリストを変えたとき向いている場面
List.of("A", "B")できない元がない(直接書く)最初から決まった値の定数
List.copyOf(base)できないコピー後の変更は反映されない既存のリストを不変にして渡す
Collections.unmodifiableList(base)この窓からはできない反映される(view が [X, Y] になった)元のリストを内部で管理し、読み取りだけ見せる

定数として持つなら、public static final List<String> NAMES = List.of("A", "B"); の形です。配列は不変にできないので、定数にしたいときは List.of に置き換えるか、返すたびに clone() でコピーを渡します。

定数まわりのよくある間違いと直し方

定数まわりのつまずきは、ほとんどが「付け忘れ」「入れ忘れ」「型の取り違え」のどれかです。コンパイラが止めてくれるものと、止めてくれずに動いてしまうものがあるので、実際に出るエラーや実行結果と一緒に5つ見ていきます。

static を付け忘れる

final int LIMIT = 100; と書くと、定数ではなく「インスタンスごとの値」です。インスタンスを作らないと使えず、LIMIT を クラス名.LIMIT では呼べません。全体で共通の値なら static final です。

final の変数を初期化し忘れる

static final の変数は、宣言か static ブロックのどちらかで必ず値を入れます。入れ忘れると、コンパイルが通りません。

public class NoInit {
    static final int LIMIT;

    public static void main(String[] args) {
        System.out.println("start");
    }
}
NoInit.java:2: エラー: 変数LIMITは初期化されていない可能性があります
    static final int LIMIT;
                     ^
エラー1個

int の定数で種類を表して取り違える

STATUS_PAID = 1 と ROLE_ADMIN = 1 のように、別の種類の int 定数が同じ値になっていても、コンパイラは気づけません。前の節で見たとおり、label(ROLE_ADMIN) が通ってしまいます。種類を表す定数は、enum に置き換えます。

case に定数でない値を書く

switch の case に書けるのは、定数式だけです(JLS 15.29)。static final でも、初期化子にメソッド呼び出しが入っていると、case には使えません。

public class NotConst {
    static final int A = 1;
    static final int B = Integer.parseInt("2");

    public static void main(String[] args) {
        int x = 2;
        switch (x) {
            case A: System.out.println("A"); break;
            case B: System.out.println("B"); break;
        }
    }
}
NotConst.java:9: エラー: 定数式が必要です
            case B: System.out.println("B"); break;
                 ^
エラー1個

A は通り、B だけが止まります。switch に使うつもりなら、int・String のリテラルか、定数式で書きます。

何でも定数にする、またはマジックナンバーのまま書く

3 や "UTF-8" を、意味の分からないままコードに直接書くと、変更のたびに探して回ることになります。一方、0 や 1 のように意味が自明な値まで定数にすると、ZERO = 0 のような読みにくい名前が増えます。意味のある値には名前を付け、自明な値はそのまま書く、が落ち着く線です。

なお、定数式どうしの計算は、定数のまま保たれます。static final int SECONDS_PER_DAY = 24 * 60 * 60; と書けば、値は 86400 で、読む人には何の計算かが伝わります。

よくある質問

Q1. Javaで定数を宣言するにはどう書きますか?

public static final 型 名前 = 値; と書きます。名前は MAX_RETRY_COUNT のように大文字とアンダースコアで書きます。1つのクラスの中だけで使うなら private にします。

Q2. final と static final の違いは何ですか?

final は「代入が1回だけ」で、インスタンスのフィールドなら、インスタンスごとに別の値を入れられます。static final はクラスに1つだけの共通の値で、全体で共有する定数に使います。

Q3. 定数クラスと enum はどちらを使えばいいですか?

取りうる値が決まった集まり(注文の状態・権限など)は enum です。上限や書式のように、1つずつ独立した設定値は定数クラスにまとめます。値の取り違えをコンパイラに止めてほしいかどうかが分かれ目です。

Q4. インターフェースに定数を書いてもいいですか?

文法上は書けます(フィールドは暗黙に public static final です)。ただし、実装したクラスの公開APIに定数が混ざり、同名の定数を持つインターフェースを2つ実装すると「あいまい」のエラーが出ます。定数クラスか enum に置くほうが安全です。

Q5. final を付けたのに List の要素を変えられるのはなぜですか?

final が固定するのは変数への再代入で、オブジェクトの中身ではないからです。中身まで変えられなくするには、List.of か List.copyOf で作った不変のリストを使います。

Q6. 定数を書き換えて再コンパイルしたのに古い値が残るのはなぜですか?

int や String の定数式で初期化した static final は、使う側のクラスのコンパイル時に値が埋め込まれるからです(JLS 13.1・13.4.9)。使う側のクラスもコンパイルし直せば、新しい値が表示されます。

Q7. Javaに const はありますか?

キーワードとしては存在しますが、予約されているだけで、実際には使えません(JLS 3.9)。定数は final で宣言します。

Q8. 定数の名前はなぜ全部大文字なのですか?

変数と区別して、「変わらない値」だと一目で分かるようにするための慣習です。単語はアンダースコアで区切ります。詳しい理由はJava命名規則にまとめています。

まとめ|定数は static final、置き場所は用途で決める

Javaの定数は、public static final で宣言し、名前は大文字スネークケースで書きます。1クラスだけで使うなら private static final、複数のクラスで使うなら定数クラス、選択肢の集まりなら enum です。インターフェースには置きません。

2つの落とし穴も、手元で出して確かめました。

  • int・String の定数式は、使う側に値が埋め込まれる:定数のクラスだけ再コンパイルしても、使う側は古い値を表示した
  • final が止めるのは再代入だけ:final List には add できた。中身まで固定するなら List.of
NEXT STEP
自分のコードで int の定数を使って「状態」を表している箇所を1つ探し、enum に置き換えてみる。

置き換えたあとに、別の種類の値を渡している呼び出しがあれば、コンパイルエラーで見つかります。

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

NEXT READ本棚から1本

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

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

→ おすすめ5冊を見る

トム

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

𝕏

Java入門

TOC