5. 変数と定数 - Javaプログラミング入門

サンプル：Variables.java

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

上記のプログラム内の「Hello World!」という文字を「Welcome Java!」に変更したいとします。
今は6行しかないので手作業でも問題ないかもしれませんが
これが100行、1000行と増えると修正作業が大変になり、修正漏れのリスクも高まります。
この問題を解決する方法の一つが変数です。
変数を使えば、変更が必要な箇所を一括で管理できるため、修正作業が簡単になり、ミスも防ぎやすくなります。

変数とは

変数は、値を保存しておくための「箱」 のようなものです。
この箱から値を取り出したり、新しい値に入れ替えたりすることができます。

変数には、名前をつける必要があります。
この名前のことを「変数名」といいます。
また、プログラムの中で同じ変数名を複数の変数につけることはできません。
それぞれの変数を区別するために使う文字や数字の並びのことを「識別子」と呼びます。

変数の命名規則

Javaの変数名には、以下のルールがあります。

文字の種類:
使用できる文字は、アルファベットの大文字・小文字（A〜Z、a〜z）、数字（0〜9）、アンダースコア（_）、ドル記号（$）です。
日本語などのUnicode文字も使用できますが、一般的ではありません。

先頭文字:
変数名の先頭文字は、アルファベット（大文字・小文字）またはアンダースコア（_）である必要があります。
数字を先頭にすることはできません。

大文字・小文字の区別:
Javaでは、大文字と小文字は区別されます。
例えば、nameとNameは別の変数として扱われます。

予約語:
Javaで予約されているキーワード（int、for、ifなど）は、変数名として使用できません。
使用できない予約語は以下の通りです。(Java SE 21 Edition)

abstract   continue   for          new         switch
assert     default    if           package     synchronized
boolean    do         goto         private     this
break      double     implements   protected   throw
byte       else       import       public      throws
case       enum       instanceof   return      transient
catch      extends    int          short       try
char       final      interface    static      void
class      finally    long         strictfp    volatile
const      float      native       super       while
_
 
exports      opens      requires     uses   yield
module       permits    sealed       var         
non-sealed   provides   to           when        
open         record     transitive   with
 

https://docs.oracle.com/javase/specs/jls/se21/html/jls-3.html#jls-3.9

これに付け加え、変数名として推奨される命名規則としては
①キャメルケースで記載しましょう
～複数の単語を組み合わせる場合、2番目以降の単語の先頭を大文字にしましょう。
例

firstName、totalAmount

この書き方を、大文字がラクダのこぶに見えることから、キャメルケースと呼びます。

②意味のある名前を付けましょう
～変数名はその変数が何を表しているのかがわかるように、意味のある名前にしましょう。
例

count、userName
aやbなどの無意味な名前は極力避けるべきです

③略語は避けましょう
～略語は意味が伝わりにくくなる可能性があるため、できるだけ避けましょう。

変数の使い方

変数を使うときは、「宣言」→「代入」→「参照」の順番で進める必要があります。

①宣言（変数を作る）
まず、プログラムに「この名前の変数を使いますよ」と教えるために変数を宣言します。
宣言するときは、データ型 変数名;のように記載します。
例

int price; // 整数型のpriceという変数を作る

②代入（値を入れる）
次に、その変数に値を入れる（代入する）必要があります。
値を入れるためには、変数名 = 値;のように記載します。
ここでの【＝】は、変数へ値を入れる、つまり代入する演算子ということで、代入演算子と呼ばれています。
例

price = 1000; // priceに1000を入れる

また、一度代入した変数の値をあとから別の値に変更すること（再代入）ができます。
💡注意！
再代入をすると、もともと入っていた値は消えてしまうので注意が必要です。
例

price = 2000; // もともと入っていた1000は消えて、新しく2000が代入される

③参照（値を使う）
最後に、その変数の中に入っている値を使う（参照する）ことができます。
例

System.out.println(price); // priceの中身を表示する

priceという名前の変数に入っている値を取り出し、System.out.printlnを使って画面に表示させることができます。
このように、変数の中の値を利用することを「参照」と呼びます。

💡注意！
もし宣言や代入をしないまま変数を使おうとすると、エラー（コンパイルエラー）になります。
たとえば、priceを宣言せずにprice = 100;と書くと、プログラムが「priceって何？」と分からずエラーになります。

サンプル：Variables.java

public class Variables {
    public static void main(String[] args) {
        // 変数の宣言
        String message;
        // 変数へ代入
        message = "Hello World!";
        // 変数を参照
        System.out.println(message);
        System.out.println(message);
        System.out.println(message);
        System.out.println(message);
        System.out.println(message);
        System.out.println(message);
    }
}
 

変数を使えば、値を変更するのは代入する部分だけでOK です。
一度変更すれば、その変数を使っているすべての出力に自動的に反映されます。

変数のメリット

変数を使うと、次の3つのメリットがあります。

① 繰り返し使える（再利用性）
同じ値を何度も書くと、間違えて入力してしまうことがあります。
しかし、変数を使えば 一度値を設定すれば何度でも使える ので、ミスを減らすことができます。

② プログラムが読みやすくなる（可読性）
例えば、1000 * 1.10 という計算式 を見たとき、それが何の計算なのかすぐに分かるでしょうか？
しかし、price * taxというように変数を使えば、「金額に税金をかけているんだな」と一目で分かります。
変数を使うことで、プログラムの内容が直感的に理解しやすくなります。

③ 修正がカンタンになる（保守性）
もし金額を変更したい場合、変数に入っている値を1か所変更するだけで済みます。
ベタ書き（直接数値を書き込む）だと、プログラムの中のすべての該当箇所を手作業で修正しなければなりません。
長いプログラムでは、修正漏れを防ぐのが大変ですが、変数を使えば変更作業がぐっと楽になります。

変数の初期化

変数の初期化とは、変数の宣言と代入を1行でまとめたものだと思ってください。
変数を宣言すると同時に、その変数に最初の値を割り当てることができます。
Javaでは、変数は使用する前に必ず初期化する必要があります。
初期化されていない変数を使用しようとすると、コンパイルエラーが発生します。

サンプル:VariableInit.java

public class VariableInit {
    public static void main(String[] args) {
        // 変数の初期化
        int price = 100;
        String message = "Hello";
    }
}
 

変数を使って計算してみよう

変数を参照するもう一つの使い方として、変数に代入した値で計算を行うことができます。
3. 式と演算子で記載した四則演算を行うプログラム(FourArithmetic.java)を変数を使って記載するとこのようになります。
サンプル:VariableArithmetic.java

public class VariableArithmetic {
    public static void main(String[] args) {
        int operand1 = 10;
        int operand2 = 3;
        System.out.println(operand1 + operand2);
        System.out.println(operand1 - operand2);
        System.out.println(operand1 * operand2);
        System.out.println(operand1 / operand2);
        System.out.println(operand1 % operand2);
    }
}
 

実行結果

13
7
30
3
1

3. 式と演算子で記載した四則演算のプログラム(FourArithmetic.java)は
数値を変えるときは5行目から9行目の場所を修正する必要がありましたが
変数を使うことで、3行目と4行目のみを修正すれば良くなりました。

さまざまな代入演算子

代入演算子とは、変数に値を入れるための記号です。
例えば、変数aに10を入れるときは、次のように書きます。

int number = 10;  // numberに10を入れる

この=が代入演算子 です。

ただ値を入れるというだけではなく、自分自身の変数numberに5を足したい場合はこのように記載します。

number = number + 5;  // numberに5を足してnumberに代入

これは 「変数numberに5を足した結果をnumberに入れる」という意味になります。
そのため、number = 5と記載したら、結果はただの5になりますが
自分自身に5を足した結果を代入するので15という結果になります。

しかし、こう書くのは少し長いので、短くできる便利な書き方があります。
これを「複合代入演算子」といいます。

number += 5;  // numberに5を足して代入（短縮形）

他にも、いろいろな計算をしながら代入することができます。

演算子	説明	記載例	変数aに代入された後の値
+=	右の値を足して代入	int a = 10; a += 5;	15
-=	右の値を引いて代入	int a = 10; a -= 3;	7
*=	右の値を掛けて代入	int a = 10; a *= 2;	20
/=	右の値で割って代入	int a = 10; a /= 3;	3
%=	右の値で割った余りを代入	int a = 10; a %= 3;	1
+=	右の文字列を連結して代入	String a = "Hello"; a += " World!";	"Hello World!"

サンプル:AssignmentOperators.java

public class AssignmentOperators {
    public static void main(String[] args) {
        int a = 10;
        a += 5;
        System.out.println(a);
        a = 10;
        a -= 3;
        System.out.println(a);
        a = 10;
        a *= 2;
        System.out.println(a);
        a = 10;
        a /= 3;
        System.out.println(a);
        a = 10;
        a %= 3;
        System.out.println(a);
        String str = "Hello";
        str += " World!";
        System.out.println(str);
    }
}
 

実行結果

15
7
20
3
1
Hello World!

インクリメント演算子・デクリメント演算子

インクリメント演算子とは、数値を1増やすための演算子です。
デクリメント演算子とは、数値を1減らすための演算子です。
インクリメント演算子は++という記号を使用し、デクリメント演算子は--という記号を使用します。
実際に記載をしてみましょう。
サンプル:IncrementDecrement.java

public class IncrementDecrement {
    public static void main(String[] args) {
        int number = 0;
        // インクリメント
        number++;
        System.out.println(number);
        // デクリメント
        number--;
        System.out.println(number);
    }
}
 

実行結果

1
0

実行すると、きちんとインクリメントをした後の出力は変数の値が1増えており
デクリメントをした後の出力は変数の値が1減っているのがわかるかと思います。

今までは右辺と左辺のように、演算子の左右両方にオペランドが存在していました。
このような演算子を二項演算子と呼びます。
一方で、今回のインクリメント演算子、デクリメント演算子には、片方にしかオペランドが存在していません。
このような演算子を単項演算子と呼びます。

前置と後置の違い

前置インクリメントと後置インクリメントを単体で使う場合は特に違いが生じることはありません。

代入演算子を使用しようとした際に差が出ます。

int a = 0;
int b = 0;

と変数を用意した際に

a = b++;

と

a = ++b;

ではaの変数の値の内容が異なります。
前置インクリメントの場合は、bの値を1増やしてから、更新された値をaに代入しますのでaの値は1になります。

後置インクリメントの場合は、bの値をaに代入してから、bの値を1増やしますので、aの値は0になります。

定数

一度値を設定したら変更できない変数のことです。
定数を使うと、プログラム内で値が変わることを防ぎ、コードが分かりやすくなります。

定数の特徴としては、一度値を設定したら、その後その値を変更することはできません。
また、変数とは違い、定数の名前は、一般的に大文字で書きます。
これにより、定数だと一目で分かります。
さらに、単語と単語の間を アンダースコア（_）で区切る書き方です。
例

MAX_VALUE, DEFAULT_USER_NAME

この書き方をスネークケースと呼びます。

定数の宣言方法は、変数宣言の前にfinalキーワードをつけます。
例えば、円周率の定数を作るときはこのように書きます。

final double PI = 3.14159;

finalを使うことで、PIの値は変更できなくなります。
もし、後からPI = 3.14;と変更しようとすると、エラーになります。

サンプル:Constant.java

public class Constant {
    public static void main(String[] args) {
        // 定数の初期化
        final double PI = 3.14159;
        final double TAX_VALUE = 1.10;
        // 定数に再代入することはできません
        PI = 3.5; // コンパイルエラー
    }
}
 

定数の利用用途

定数は様々なところで利用されることがありますが
一つ例を挙げるのであればマジックナンバーになります。

サンプル：MagicNumber.java

public class MagicNumber {
    public static void main(String[] args) {
        // 商品価格
        int price = 100;
        // 消費税額を計算
        double taxAmount = price * 1.10; // 1.10は何を意味する値なの？
        // 税込み価格を計算
        double priceWithTax = price + taxAmount;
        // 計算結果を表示
        System.out.println("税込み価格: " + priceWithTax);
    }
}
 

プログラムを書く際、特定の意味を持つ数値をコードの中に直接記述することがあります。
これらの数値は値が変わらないため、そのまま記載されることが多いですが、このような数値を「マジックナンバー」と呼びます。
例えば、6行目の1.10という数値がコードに直接書かれていた場合、それが消費税率を表していることは、書いた本人でなければ理解しにくいかもしれません。
マジックナンバーはコードの可読性や保守性を低下させる原因となるため、できる限り避けるべきです。
マジックナンバーの問題点として、まず「何を意味するのかが分かりにくい」ため、コードの意図を理解するのに時間がかかります。
また、複数の場所で使用されている場合、値を変更するときにすべての箇所を修正しなければならず、ミスが発生しやすくなります。
さらに、プログラムの仕様が変更された際に、どこを修正すればよいのか分かりにくくなることも問題です。
このようなマジックナンバーの問題を解決するためには、定数を使用するのが効果的です。
定数に分かりやすい名前を付けることで、その値が何を意味するのかが明確になり、コードの可読性や保守性が向上します。

修正サンプル:MagicNumber.java

public class MagicNumber {
    public static void main(String[] args) {
        // 消費税率
        final double TAX_RATE = 1.10;
        // 商品価格
        int price = 100;
        // 消費税額を計算
        double taxAmount = price * TAX_RATE; // 消費税率という意味が明確に伝わる
        // 税込み価格を計算
        double priceWithTax = price + taxAmount;
        // 計算結果を表示
        System.out.println("税込み価格: " + priceWithTax);
    }
}
 

コラム

型推論

Java10からは、varを使うことで、変数を宣言する際にデータ型を省略できるようになりました。

varを使うと、変数を宣言する時にデータ型を指定する代わりに、初期化時に代入する値から自動的にデータ型を決めてくれます。
例えば、次のように書けます：

var price = 100;

つまり、変数を宣言する際に 初期化（値を代入すること）が必要 で、その値からデータ型が決まります。

💡注意！
var を使う場合、必ず変数の宣言と同時に初期化を行わなければなりません。
例えば、以下のように初期化をしないとエラーになります

var number;  // コンパイルエラー

💡注意！
long 型や float 型の場合、初期化時に接尾辞をつけて明確にデータ型を指定する必要があります

var num = 1000L;  // long 型として推測
var total = 1.41421F;  // float 型として推測

💡注意！
null を初期化で代入する場合、データ型が分からないためエラーが発生します：

var entity = null;  // コンパイルエラー

💡注意！
複数の変数をまとめて宣言することはできません：

var width = 360, height = 180;  // コンパイルエラー

型推論の是非

Java10から導入されたローカル変数の型推論は、コードを簡潔にし、開発者の生産性を高めるために大きな役割を果たしました。
しかし、型推論を使う際には注意が必要です。

型推論のメリット
①コードが簡潔になります
～データ型を明示的に書かなくても良いため、コードがスッキリします。
②開発効率が上がります
～特にコレクションやジェネリクスを使うとき、型を毎回書かなくても良いので、開発が速くなります。
③可読性が向上します
～場合によっては、型を省略することでコードの意図がより明確になることもあります。

型推論のデメリット
①型情報が失われます
～コンパイラが型を推論するため、コードを見ただけでは変数が何の型か分かりにくいことがあります。
特に大規模なプロジェクトや複雑なロジックでは、デバッグが難しくなる可能性があります。
②バグの原因になりやすいです
～型推論に頼りすぎると、意図しない型で変数が初期化されてしまうことがあります。
③チーム開発での理解が難しくなります
～チームで開発している場合、型に関する共通の認識がないと、他のメンバーがコードを理解するのが難しくなり、保守性が低下することがあります。

型推論はコードを簡潔にして効率を上げるメリットがありますが、型がはっきりしなくなることによるデメリットもあるため、状況に応じて適切に使うことが大切です。

前置インクリメント、後置インクリメントはどっちを使うのが良い？

結論、どっちでも構いませんが、後置インクリメントが慣習として多いです。

(余談)
Javaでは中間言語時点、JVMのバイトコード時点では特に差はありませんが、
C/C++の世界では、CPUの段階で前置と後置では異なる差が出始めると報告されています。
また、どちらが早いか最適かは結論がそれぞれ違います。

前置インクリメントを使うべきと主張するケース
C++では、ループなどで繰り返し（イテレーション）を行う際に、後置インクリメント（i++）を使うと余計なコピーが発生してしまうことがあります。
なぜなら、後置インクリメント (i++) は 「現在の値を一時的にコピーしてから、インクリメントを実行する」 という動作をするためです。
一方、前置インクリメント (++i) は 「そのままインクリメントする」 ため、コピーが発生しません。
特に、オブジェクトのコピーにコストがかかる場合（例: イテレーターや大きなオブジェクト）には、前置インクリメント (++i) を使った方が効率的だと考えられています。

class Iterator
{
private:
    int a;
public:
    Iterator operator++()       // a = ++i;
    {
        ++a;
        return *this;
    }
    Iterator operator++(int)    // a = i++;
    {
        Iterator copy = *this;
        ++a;
        return copy;
    }
};
 

後置インクリメントを使うべきと主張するケース
前置インクリメント(++i)は効率的だと言われていますが、値が必要な場合には問題が発生することがあります。
なぜなら、前置インクリメントは「値を書き換えてから戻す」ため、処理が完了するまで戻す値が決まりません。
この影響で、CPUの処理が一時的に止まってしまう「パイプラインストール」が発生することがあります。
一方、後置インクリメント(i++)は「元の値をコピーした後でインクリメントを行う」ため、
コピーした値とインクリメント処理を並行して実行できるというメリットがあります。
そのため、CPUの処理がスムーズに進み、パイプラインストールを防ぐことができます。
特に、ゲームエンジンの設計では、CPUの処理速度を最優先するため、後置インクリメント(i++)を使うべきだという意見があります。

参考資料：
https://ascii.jp/elem/000/000/553/553627/
https://cpp.aquariuscode.com/preincriment-vs-postincriment

前へ 4. データ型
次へ 6. 型変換