Java：リテラルの基本概念を1から丁寧に解説

「リテラル」という単語は英語の literal（文字どおりの、直接的な）に由来し、「プログラムのソースコード上で直接表現される値」のことを指します。単なる数字や文字だけを指すわけではなく、Java言語の仕様として定められた「その型に適した唯一の書き方」で示された定数値と理解しましょう。

このページではJavaにおけるリテラルとは何か？リテラルの基本概念について1からわかりやすく解説します。

リテラルとは何か？

リテラルの基本概念

• ソースコード上に“直接”書き込まれた値
  例えば、10、'A'、"Hello"、true、null などが代表例です。これらは「変数に格納された値」や「メソッドの戻り値」とは区別されます。変数が「箱」であるならば、リテラルは「箱に入れる前の中身そのもの」と言えます。
• コンパイル時点で確定している値
  リテラルはソースコード上に書かれた時点で、コンパイラにとって「型」と「値」が明確にわかる定数です。このため、コンパイルの段階で型のチェックや範囲チェックが行われ、誤った型への代入などがあればコンパイルエラーになります。
• 言語仕様で定められた書き方を持つ
  例えば「整数ならこう書く」「小数ならこう書く」「文字列ならダブルクォートで囲む」といった具合に、Javaが理解できる書式が決まっています。ここでは、その代表的なものを詳しく見ていきます。

補足：リテラルと変数の違い

• リテラル: ソースコード上で直接書かれた値

int a = 10; // 10 がリテラル

• 変数: 値を格納するために宣言される。値はリテラルかもしれないし、計算結果かもしれない。

int b = a + 5; // bには (a + 5) の計算結果が代入される

上記の例では、10 はリテラルですが、(a + 5) はリテラルではありません。演算結果やメソッドの戻り値はリテラルに該当しないという点に注意してください。

リテラルの種類

Javaでは、大きく次の種類がリテラルとして定義されています。

1. 整数リテラル (int, long)
2. 浮動小数点リテラル (float, double)
3. 文字リテラル (char)
4. 文字列リテラル (String)
5. ブーリアンリテラル (boolean)
6. ヌルリテラル (null)

これらはプリミティブ型（int、long、float、double、char、boolean）と、参照型（String など）で表現される定数値です。（参考 プリミティブ型/参照型）

それぞれに決まった表記方法があり、この表記を間違えると文字列として扱いたいものが数字として認識されてしまったり、2進数として扱いたい数値が10進数として認識されてしまったりします。それぞれ、どのように表記することで「文字として」「文字列として」「数字として」Javaが認識してくれるのか？を1個1個説明していきます。

整数リテラル (Integer Literals)

基本の書き方

Javaの整数リテラルは、何も付けなければ int 型（32ビット）として扱われ、値が int の範囲を超えない限りはエラーなくコンパイルされます。int の範囲（-2,147,483,648～2,147,483,647）を超える大きな値を書くときは、long 型（64ビット）のリテラルにします。long 型を明示したい場合は末尾に L（推奨）または l を付けます。

int x = 10;       // int型
long bigValue = 10L; // long型

進数表現

Javaでは以下の進数表現が可能です。

1. 10進数(Decimal)
   • 例: 123, 0, -50
   • 何も接頭辞がなければ10進数として解釈
2. 2進数(Binary)
   • 接頭辞 0b または 0B
   • 例: 0b1010 (10進数で10)
3. 8進数(Octal)
   • 接頭辞 0（ゼロ）
   • 例: 012 (10進数で10)
4. 16進数(Hexadecimal)
   • 接頭辞 0x または 0X
   • 例: 0x1A (10進数で26)

int dec = 10;        // 10進数で10
int bin = 0b1010;    // 2進数で10
int oct = 012;       // 8進数で10
int hex = 0x1A;      // 16進数で26

Tips：アンダースコアによる桁区切り

Java 7以降、数字の途中にアンダースコア _ を入れて桁数の多い数値を読みやすくできます。

int million = 1_000_000;
long creditCardNumber = 1234_5678_9012_3456L;

ポイント　アンダースコアによる桁区切り

• 1_000_000 は 1000000 と同じ意味。
• _ は 数値の区切り に使われるだけで、実際の値には影響しない。
• コンパイラは _ を無視するので、演算などには影響しない。

ただし、①先頭や末尾などに _ を置くことはできない、というのと②記号の前後には記述できないという点に注意が必要です。

// int invalid = _1000;  // ❌ NG: 先頭
// int invalid2 = 1000_;  // ❌ NG: 末尾
// double invalid3 = 3_.14159;  // ❌ NG: 小数点の直前
// int invalid4 = 0x_1A;  // ❌ NG: 接頭辞（記号）の直後

public class UnderscoreExample {
    public static void main(String[] args) {
        // int validNumber = 1_000_000; // ✅ 正しい記述

        // 先頭にアンダースコア（エラー）
        // int invalidNumber1 = _1000; // ❌ コンパイルエラー

        // 末尾にアンダースコア（エラー）
        // int invalidNumber2 = 1000_; // ❌ コンパイルエラー

        System.out.println("アンダースコアを正しく使いましょう！");
    }
}

public class UnderscoreExample2 {
    public static void main(String[] args) {
        // int validSum = 1_000 + 2_000; // ✅ 正しい記述

        // 演算子の前後にアンダースコア（エラー）
        // int invalidSum = 1_000_ + 2_000; // ❌ コンパイルエラー
        // int invalidSum2 = 1_000 +_ 2_000; // ❌ コンパイルエラー

        System.out.println("数値の区切りのみにアンダースコアを使いましょう！");
    }
}

浮動小数点リテラル (Floating-Point Literals)

基本の書き方

浮動小数点数には float（32ビット）と double（64ビット）があります。何も付けない場合は double 型として扱われます。float 型として扱いたい場合は、末尾に F または f を付けます。double と明示する場合は末尾に D または d を付けることもできますが、通常省略されます。

float fVal = 3.14F;  // float型
double dVal1 = 3.14; // double型 (省略形)
double dVal2 = 3.14D; // double型 (明示形)

指数表記 (Scientific Notation)

E または e を用いて10のべき乗を表現する指数表記も可能です。

double dVal3 = 1.2e3;  // 1.2 × 10^3 = 1200.0
double dVal4 = 1.2E-3; // 1.2 × 10^-3 = 0.0012

浮動小数点は厳密な値を表現できないことがある（2進数ベースで格納されるため誤差が生じる）ので、大きな計算やお金の計算などでは BigDecimal を使うことも考慮しましょう。

文字リテラル (Character Literals)

単一の文字を表す

単一の文字を ' ' （シングルコーテーション）で囲んだものが文字リテラルです。Javaでは char 型はUnicode（16ビット）で表現されるため、 'A' や 'あ' のように日本語文字も1文字として扱えます。

char c1 = 'A';
char c2 = 'あ';

エスケープシーケンス

制御文字や特殊な文字を表現する場合、バックスラッシュ \ を使うエスケープシーケンスを用います。

• '\n' : 改行
• '\t' : タブ
• '\'' : シングルクォート自身
• '\"' : ダブルクォート
• '\\' : バックスラッシュ

char c3 = '\n';
char c4 = '\\'; // バックスラッシュを文字として表す

Unicodeエスケープ

\uXXXX と書くと、16進数で指定したUnicode文字を表せます（XXXX は4桁の16進数）。

char c5 = '\u3042'; // 'あ' に相当するUnicode(3042は16進)

文字列リテラル (String Literals)

ダブルコーテーションで囲む

ダブルコーテーションで囲まれた任意の文字列がリテラルになります。String 型で扱われ、参照型です。

String greeting = "Hello, Java!";

Stringについては別途詳細解説記事を設けています。あわせてご覧ください。

Java：String(文字列)の基本を１からわかりやすく

JavaのStringはデータ型ではなくオブジェクトである—この違いを理解すれば、文字列の扱い方が劇的に変わります。本記事では、イミュータブルな設計の理由、String Poolの仕組み、==とequals()の違い、StringBuilderの活用方法などを徹底解説。Java Silver対策にも役立つ必読の内容です。

it-biz.online

2025.02.18

文字列の連結

+ 演算子を使うことで複数の文字列リテラルや文字列変数を連結できます。

String combined = "Hello, " + "World!";

エスケープシーケンス

文字リテラルと同様、文字列中でも \" や \\ などのエスケープシーケンスが利用できます。

String s1 = "He said, \"Hello!\"";
String s2 = "改行は\nこのように書きます。";

ブーリアンリテラル (Boolean Literals)

true と false だけがブーリアンリテラルとして認識されます。条件分岐やループなど、あらゆる場面で使われる基本要素です。大文字にしてしまうと、文字列リテラルとして認識されてしまうので注意が必要。

boolean isJavaFun = true;
boolean isRaining = false;

ヌルリテラル (null Literal)

参照型変数が「何も参照していない状態」を表す特別なリテラルです。クラス型や配列、String などにしか使えません。プリミティブ型 (int、double など) には代入できません。

String str = null; // strはオブジェクトを参照していない

• null 参照の変数に対してメソッドを呼び出すと NullPointerException が発生します。
• null はあくまで「参照先がない」ことを示す記号のようなもので、数値や文字としての意味はありません。

リテラルの活用と注意点

1. コンパイル時定数
   リテラルを使って初期化された final 変数（例: final int X = 10;）は、コンパイル時定数として扱われることがあります。Javaコンパイラはリテラルとみなして最適化を行うケースがあるため、定数を表す際は final を付けることが多いです。
2. 範囲外エラー
   整数リテラルが int の範囲を超えるのに L を付け忘れた場合、コンパイルエラーになります。浮動小数点リテラルも同様に、極端に大きい/小さい値を書くとエラーやオーバーフローが発生する場合があります。
3. 文字列リテラルの同一性
   文字列リテラルは JVM の内部で「文字列プール」という仕組みによって管理され、同じ内容の文字列リテラルは同じインスタンスを共有します（== 演算子で比較すると true になる場合がある）。一方、new String("Hello") のように生成した場合は別のインスタンスになるため注意が必要です。
4. 演算結果はリテラルではない
   リテラルはソースコード上に書かれた「定数部分」だけを指します。例えば int c = a + b; のように変数どうしを演算した結果はリテラルではありません。

Javaのリテラル総まとめサンプルコード

各種リテラルをまとめて使ったサンプルコードを示します。

public class LiteralExample {
    public static void main(String[] args) {
        // 1. 整数リテラル
        int dec = 10;
        int bin = 0b1010;   // 2進数
        int oct = 012;      // 8進数
        int hex = 0x1A;     // 16進数
        long bigNumber = 12345678900L;

        // 2. 浮動小数点リテラル
        float fVal = 3.14F;
        double dVal1 = 3.14;
        double dVal2 = 1.2e3; // 1200.0

        // 3. ブーリアンリテラル
        boolean isJavaFun = true;
        boolean isRainy = false;

        // 4. 文字リテラル
        char ch1 = 'A';
        char ch2 = '\n';    // 改行
        char ch3 = '\u3042'; // 'あ' (Unicode)

        // 5. 文字列リテラル
        String message = "Hello, Java!";

        // 6. ヌルリテラル
        String nullStr = null;

        // 出力
        System.out.println("=== 整数リテラル ===");
        System.out.println("dec: " + dec);
        System.out.println("bin: " + bin);
        System.out.println("oct: " + oct);
        System.out.println("hex: " + hex);
        System.out.println("bigNumber: " + bigNumber);

        System.out.println("\n=== 浮動小数点リテラル ===");
        System.out.println("float: " + fVal);
        System.out.println("double 1: " + dVal1);
        System.out.println("double 2: " + dVal2);

        System.out.println("\n=== ブーリアンリテラル ===");
        System.out.println("isJavaFun: " + isJavaFun);
        System.out.println("isRainy: " + isRainy);

        System.out.println("\n=== 文字リテラル ===");
        System.out.println("ch1: " + ch1);
        System.out.println("ch2 (改行後に出力されます)");
        System.out.println(ch2);
        System.out.println("ch3: " + ch3);

        System.out.println("\n=== 文字列リテラル ===");
        System.out.println("message: " + message);

        System.out.println("\n=== ヌルリテラル ===");
        System.out.println("nullStr: " + nullStr);
    }
}

/*
=== 整数リテラル ===
dec: 10
bin: 10
oct: 10
hex: 26
bigNumber: 12345678900

=== 浮動小数点リテラル ===
float: 3.14
double 1: 3.14
double 2: 1200.0

=== ブーリアンリテラル ===
isJavaFun: true
isRainy: false

=== 文字リテラル ===
ch1: A
ch2 (改行後に出力されます)

ch3: あ

=== 文字列リテラル ===
message: Hello, Java!

=== ヌルリテラル ===
nullStr: null
*/