SJ blog / 講義 / Java Silver (SE 21) 試験対策
初級 65分 Lesson 2

演算子・制御構造

算術・比較・論理演算子の落とし穴、型プロモーション、if/switch/for/while/do-whileとラベル付きbreak/continueを完全解説

Java Java Silver SE21 制御構造 演算子

Chapter 02 ─ 演算子・制御構造

この章を読めば: 演算子の罠（整数除算・剰余の符号・前置/後置・短絡評価）、switch 文と式の違い、ラベル付き break/continue が完全に理解できる。「なんとなく動く」から「確実に正解できる」レベルへ。

2-1. 算術演算子 ─ 基本と落とし穴

基本の5演算子

int a = 10, b = 3;
System.out.println(a + b);   // 13（加算）
System.out.println(a - b);   // 7（減算）
System.out.println(a * b);   // 30（乗算）
System.out.println(a / b);   // 3（除算）← 要注意！
System.out.println(a % b);   // 1（剰余）

整数同士の除算は「切り捨て」

/ 演算子で両辺が整数型（int, long など）の場合、結果も整数になる。小数点以下は切り捨て（truncation）される。四捨五入でも floor（床関数）でもない。単純に小数部を捨てる。

System.out.println(10 / 3);     // 3（3.333...の小数部を捨てる）
System.out.println(7 / 2);      // 3（3.5 → 3）
System.out.println(-7 / 2);     // -3（-3.5 → -3。0方向への切り捨て）
System.out.println(1 / 2);      // 0（0.5 → 0）
System.out.println(0 / 5);      // 0
System.out.println(5 / 0);      // ArithmeticException: / by zero（実行時エラー）

ゼロ除算について:

  • 整数のゼロ除算 → 実行時に ArithmeticException（コンパイルは通る）
  • 浮動小数点のゼロ除算 → 例外ではなく Infinity（無限大）か NaN（非数）になる
System.out.println(5.0 / 0);    // Infinity（正の無限大）
System.out.println(-5.0 / 0);   // -Infinity
System.out.println(0.0 / 0);    // NaN（Not a Number）

double の結果が欲しいなら「先に」キャストする

「10 / 3 の結果を double で欲しい」という場合、どちらかをキャストするタイミングが重要。

int a = 10, b = 3;

double r1 = (double) a / b;    // ✅ 3.3333... → a を double にしてから割る
double r2 = a / (double) b;    // ✅ 3.3333... → b を double にしてから割る
double r3 = (double)(a / b);   // ❌ 3.0 → 整数除算（=3）を後から double に変換
double r4 = (double) a / (double) b; // ✅ 3.3333...

(double)(a / b) は「整数除算を先に終わらせてから double に変換」するので、既に捨てられた小数部は戻ってこない。

試験頻出パターン
「(double)(10/3) の出力は？」→ 3.0（罠は「整数除算が先」）
「(double)10/3 の出力は？」→ 3.3333...（10 を先に double にする）

剰余（%）の符号ルール

剰余の符号は左辺（割られる側）の符号に従う。右辺の符号は無関係。

Java の % は「ゼロ方向への切り捨て除算の余り」として定義されている。-7 / 3 は -3（ゼロに近い方向）、-7 = 3×(-3) + (-1) なので余りは -1。

System.out.println( 7 %  3);   //  1（ 7 = 3× 2 + 1）
System.out.println(-7 %  3);   // -1（-7 = 3×(-2) + (-1)）← 左辺が負なので余りも負
System.out.println( 7 % -3);   //  1（ 7 = (-3)×(-2) + 1）← 右辺の符号は余りの符号に影響しない
System.out.println(-7 % -3);   // -1（-7 = (-3)×2 + (-1)）

覚え方: a % b の結果の符号は a（左辺）と同じ。右辺の符号は一切関係ない。

2-2. インクリメント・デクリメント ─ 前置と後置

基本の動き

++ と -- には「前置（++x）」と「後置（x++）」の2種類がある。単体で使う場合は違いがないが、式の中に埋め込まれたときに結果が変わる。

前置（++x）後置（x++）
動き先に加算してから値を使う先に値を使ってから加算する
式の評価結果加算後の値加算前の値
int x = 5;
System.out.println(++x);  // 6（先に 5→6 に変えてから 6 を出力）
System.out.println(x);    // 6

int y = 5;
System.out.println(y++);  // 5（先に 5 を出力してから 5→6 に変える）
System.out.println(y);    // 6

式の中に混ぜた場合の評価手順

試験でよく出るのは複数の ++ が混在した式。左から右に1ステップずつ評価する。

int a = 3;
int b = a++ + ++a;

ステップを分解:

  1. a++ を評価: 現在の a(=3) を返す。その後 a を 4 にする
  2. ++a を評価: a(=4) を 5 にしてから 5 を返す
  3. b = 3 + 5 = 8
System.out.println(b);  // 8
System.out.println(a);  // 5

試験でよく出る声
「a++ + ++a の計算順序を丁寧に追う問題が出た」
「ここは落ち着いてステップを書き出すと間違えない」

2-3. 比較演算子

int n = 10;
System.out.println(n > 5);     // true
System.out.println(n >= 10);   // true（以上。等号を含む）
System.out.println(n < 10);    // false
System.out.println(n <= 9);    // false
System.out.println(n == 10);   // true（等値。代入の = とは別）
System.out.println(n != 5);    // true（不等）

if の条件式は boolean のみ

C/C++ では if (n = 5) と書いても（n に 5 を代入した結果の評価として）コンパイルが通ることがあるが、Java では if の条件式に boolean 以外は使えない。

int n = 10;
if (n = 5) { }   // ❌ コンパイルエラー
// 「n = 5」は int 型の式。if には boolean が必要

if (n == 5) { }  // ✅ boolean を返す比較式
// 例外: boolean 変数への代入は OK（紛らわしいので避けるべきだが試験には出る）
boolean flag = false;
if (flag = true) {  // ❌に見えるが boolean への代入なので技術的には OK
    System.out.println("ここは実行される");
}

2-4. 論理演算子と短絡評価

4種類の論理演算子

演算子名前動作
&&論理AND両辺が true で true。短絡評価あり
||論理ORどちらかが true で true。短絡評価あり
&ビットAND両辺が true で true。短絡評価なし
|ビットORどちらかが true で true。短絡評価なし
!否定true を false に、false を true に
^排他的論理和(XOR)両辺が異なれば true

短絡評価（Short-Circuit Evaluation）

&& と || は結果が確定した時点で右辺の評価をやめる（短絡する）。

  • &&: 左辺が false → 右辺を評価しない（どうせ全体が false）
  • ||: 左辺が true → 右辺を評価しない（どうせ全体が true）
// 安全な null チェックパターン（頻出イディオム）
String s = null;
if (s != null && s.length() > 0) {
    // s が null なら s.length() は評価されない → NPE が起きない
    System.out.println("空でない文字列");
}

// || の例
int x = 0;
if (x == 0 || (10 / x > 0)) {
    // x == 0 が true なので右辺は評価されない
    // → 10 / 0 の ArithmeticException が起きない！
    System.out.println("OK");
}

& と | は短絡評価しない（両辺を必ず評価する）

int count = 0;

// || → 左辺が true で確定。右辺を評価しない
if (true || (++count > 0)) { }
System.out.println(count);  // 0（右辺は評価されなかった）

count = 0;
// | → 両辺を必ず評価
if (true | (++count > 0)) { }
System.out.println(count);  // 1（右辺が評価された）

& と | はビット演算子としても使われる（整数型に対して使うとビット単位の AND/OR になる）。論理値（boolean）に対して使うと副作用（カウントアップなど）を含む処理でも両辺が必ず評価される。

試験頻出
&& と & の違いを問う問題は頻出。特に「++ が入った右辺が評価されるかどうか」がポイントになる。

! と ^ の動き

boolean t = true, f = false;

System.out.println(!t);     // false
System.out.println(!f);     // true
System.out.println(!!t);    // true（二重否定で元に戻る）

// XOR（^）: 両辺が異なれば true、同じなら false
System.out.println(t ^ t);  // false（true と true → 同じ）
System.out.println(t ^ f);  // true（true と false → 異なる）
System.out.println(f ^ f);  // false（false と false → 同じ）

XOR は「2人の答えが違うときだけ true」と覚えると分かりやすい。

2-5. 代入演算子（複合代入）と暗黙キャスト

複合代入演算子

int n = 10;
n += 5;   // n = n + 5 → 15
n -= 3;   // n = n - 3 → 12
n *= 2;   // n = n * 2 → 24
n /= 4;   // n = n / 4 → 6
n %= 4;   // n = n % 4 → 2

複合代入には暗黙のキャストが含まれる（超頻出）

Chapter 01 の型プロモーションと組み合わせた最重要ポイント。

byte b = 10;
b = b + 1;    // ❌ コンパイルエラー
              // 理由: b + 1 は int 型に昇格。int → byte の縮小変換は自動では行われない

b += 1;       // ✅ OK！
              // 理由: += には暗黙の (byte) キャストが含まれている
              //      実質的に b = (byte)(b + 1) と同じ

b++;          // ✅ OK！（++ も同様の暗黙キャストあり）
b--;          // ✅ OK！

「b = b + 1 と b += 1 は同じことでしょ？」と思いがちだが、コンパイラの扱いが違う。

試験でよく出るパターン
「次のうちコンパイルエラーになる行はどれか」という問題で、
short s = 5; s = s + 1; → エラー
short s = 5; s += 1; → OK
という組み合わせが頻出。

2-6. 三項演算子

条件式 ? 真のとき返す値 : 偽のとき返す値

if-else の「値を返すバージョン」。変数への代入や式の中に使える。

int score = 75;

// 基本
String result = (score >= 70) ? "合格" : "不合格";
System.out.println(result);  // "合格"

// 式の中に使う
System.out.println("結果: " + (score >= 70 ? "合格" : "不合格"));

// ネスト（読みにくくなるので多用は禁止）
String grade = score >= 90 ? "A"
             : score >= 70 ? "B"
             : score >= 50 ? "C"
             : "D";

三項演算子の型の制約

? と : の両辺の型は互換している必要がある。型変換のルールが適用される。

int    a = 1;
double b = 2.0;
var    r = true ? a : b;   // a が double に昇格 → r は double 型
System.out.println(r);     // 1.0

// 型が互換しない例
// Object o = true ? "hello" : 42;  // String と int → Object（共通の親クラス）に昇格

2-7. instanceof 演算子

オブジェクトが指定した型かどうかを実行時に判定する。

Object obj = "hello";

System.out.println(obj instanceof String);   // true（String のインスタンス）
System.out.println(obj instanceof Object);   // true（すべてのクラスは Object のサブクラス）
System.out.println(obj instanceof Integer);  // false

// null に対しては常に false（例外にならない）
Object n = null;
System.out.println(n instanceof String);   // false（null は何の型でもない）
System.out.println(n instanceof Object);   // false

パターンマッチング（Java 16+）

従来は instanceof でチェックしてからキャストが必要だったが、同時に行える。

// 従来の書き方（冗長）
if (obj instanceof String) {
    String s = (String) obj;    // 改めてキャストが必要
    System.out.println(s.toUpperCase());
}

// Java 16+ パターンマッチング（Silver SE21 対象）
if (obj instanceof String s) {   // 型チェックとキャストとスコープ宣言を一度に
    System.out.println(s.toUpperCase());
}

// if の条件式の中で && と組み合わせられる
if (obj instanceof String s && s.length() > 3) {
    System.out.println("長い文字列: " + s);
}

s のスコープは if ブロック内のみ（パターン変数のスコープは通常のローカル変数と同じ）。

✏️ 練習問題 1

次のコードの出力を答えよ。

int a = 5;
int b = a++;   // 1
int c = ++a;   // 2
System.out.println(a + " " + b + " " + c);

また、count = 0 として次を評価するとき count の最終値を答えよ。

int count = 0;
boolean r1 = (true) || (++count > 0);   // 3
System.out.println(count);

count = 0;
boolean r2 = (false) && (++count > 0);  // 4
System.out.println(count);

count = 0;
boolean r3 = (true) | (++count > 0);    // 5
System.out.println(count);
答え

出力1: 7 5 7

  • b = a++: a(=5) を返してから a を 6 に → b=5, a=6
  • c = ++a: a を 7 にしてから返す → c=7, a=7

3: count = 0（|| の左辺が true → 右辺は評価されない）

4: count = 0（&& の左辺が false → 右辺は評価されない）

5: count = 1（| は短絡評価なし。右辺も必ず評価される）

2-8. if / else if / else ─ 完全解説

基本構文

int score = 75;

if (score >= 90) {
    System.out.println("A ランク");
} else if (score >= 70) {
    System.out.println("B ランク");  // これが実行される
} else if (score >= 50) {
    System.out.println("C ランク");
} else {
    System.out.println("D ランク");
}

else if は上から順に評価され、最初に true になった1つだけが実行される。それ以降の else if や else はスキップされる。

波カッコを省略したときの落とし穴

処理が1文のとき波カッコを省略できる。しかし直後の1文だけが if の対象になる。

// 危険！意図した動きと違う
if (score > 70)
    System.out.println("合格");
    System.out.println("おめでとう");  // ← これは if に関係なく「常に」実行される！

// 正しい書き方
if (score > 70) {
    System.out.println("合格");
    System.out.println("おめでとう");
}

試験では「波カッコなし if」の後に2行書かれていて、2行目が条件に関係なく実行されることを問う問題が出る。見た目のインデントに騙されないように注意。

else の対応関係（ぶら下がり else 問題）

int a = 1, b = 2;

if (a > 0)
    if (b > 10)
        System.out.println("A");
else    // ← この else はどちらの if に属するか？
    System.out.println("B");

Java の規則: else は最も近い if に対応する。上のコードでは内側の if (b > 10) に対応する。

// 実行すると...
// a=1 > 0 なので内側 if へ
// b=2 は 10 より大きくないので内側 if は false → else へ
// "B" が出力される

インデントは関係なく、コンパイラはコードの論理構造だけを見る。

2-9. switch 文 ─ フォールスルーの仕組みを完全理解

switch 文の基本構文

switch (変数や式) {
    case 値1:
        処理1;
        break;     // ← ここで switch を抜ける
    case 値2:
        処理2;
        break;
    default:
        デフォルト処理;
        break;     // default の break は省略可だが書く習慣を
}

switch 文で使える型と使えない型

使える型: byte, short, int, char, Byte, Short, Integer, Character, String, enum

使えない型（試験頻出）: long, float, double, boolean

long l = 1L;
switch (l) {  // ❌ コンパイルエラー！long は不可
    case 1 -> System.out.println("one");
}

boolean b = true;
switch (b) {  // ❌ コンパイルエラー！boolean は不可
    ...
}

試験での引っかけ
char c = 'A'; switch (c) → OK（char は使える）
long l = 1; switch (l) → エラー（long は使えない）
String s = "hello"; switch (s) → OK（Java 7+ から String が使える）

フォールスルーの仕組み

break がない case は次の case の処理に流れ込む（フォールスルー）。

int x = 2;
switch (x) {
    case 1:
        System.out.println("one");
        // break なし → case 2 に流れる
    case 2:
        System.out.println("two");
        // break なし → case 3 に流れる
    case 3:
        System.out.println("three");
        break;   // ここで止まる
    default:
        System.out.println("other");
}
// 出力: two, three

x = 2 なので case 2 にジャンプ。そこから break が出てくるまで下へ流れ続ける。

フォールスルーの意図的な活用

複数の case に同じ処理をしたいとき便利。

int month = 4;
String season;
switch (month) {
    case 3:
    case 4:
    case 5:
        season = "春";
        break;
    case 6:
    case 7:
    case 8:
        season = "夏";
        break;
    default:
        season = "その他";
}

default は最後でなくてもよい

int x = 5;
switch (x) {
    default:
        System.out.println("D");  // ← 最初に書いても動作は変わらない
        break;
    case 1:
        System.out.println("A");
        break;
    case 2:
        System.out.println("B");
        break;
}
// x = 5 は case 1,2 にマッチしないので default が実行される → "D"

default はどこに書いても「どの case にもマッチしないとき」に実行される。ただし break がないとフォールスルーが起きる点は同じ。

case に定数が必要

case の値にはコンパイル時定数しか使えない。変数は使えない。

final int ONE = 1;   // final は定数 → OK
int two = 2;         // final でない変数 → NG

switch (x) {
    case ONE:        // ✅ final 定数は OK
        break;
    case two:        // ❌ コンパイルエラー（変数は不可）
        break;
    case 1 + 1:      // ✅ コンパイル時に計算できる式は OK
        break;
}

2-10. switch 式 ─ Java 14+ の新構文

アロー構文（->）

switch 式ではアロー -> を使う。フォールスルーが起きない。複数の値をカンマ区切りで並べられる。

int day = 3;
String dayName = switch (day) {
    case 1 -> "月曜";
    case 2 -> "火曜";
    case 3, 4 -> "水/木曜";   // 複数値をカンマで指定
    case 5 -> "金曜";
    default -> "週末";
};                             // ← セミコロン必須（式文として使う場合）

System.out.println(dayName);   // "水/木曜"

case 3, 4 -> で case 3 と case 4 に同じ処理をする。switch 文の case 3: case 4: と書くよりスッキリ。

ブロックの戻り値は yield

処理が複数行必要なとき {} ブロックを書く。その場合、値を返すには yield を使う。

int score = 75;
String grade = switch (score / 10) {
    case 10, 9 -> "A";
    case 8     -> "B";
    case 7 -> {
        System.out.println("C ランク（7X点）");   // 副作用のある処理
        yield "C";    // ← ブロック内で値を返すには yield
    }
    case 6 -> "D";
    default -> {
        System.out.println("再試験が必要");
        yield "F";
    }
};

yield は switch 式のブロック専用。switch 文では使わない（使えない）。

switch 文 vs switch 式の比較

項目switch 文switch 式
値を返せるか返せない返せる（変数への代入可）
フォールスルーある（break 忘れで発生）ない（アロー構文）
ブロック内の戻り値なしyield
複数 case のまとめcase 1: case 2:case 1, 2 ->
式文末のセミコロン不要必要
全 case の網羅必須でない必須（default か全 enum など）

試験で重要
switch 式は default か、全ケースを網羅する case がないとコンパイルエラー。
switch 文は default がなくてもコンパイルできる（マッチしないときは何もしない）。

✏️ 練習問題 2

Q1: 次のコードの出力を答えよ。

int x = 2;
switch (x) {
    case 1:
        System.out.println("one");
    case 2:
        System.out.println("two");
    case 3:
        System.out.println("three");
        break;
    default:
        System.out.println("other");
}

Q2: 次のコードはコンパイルできるか？

double d = 3.14;
switch (d) {
    case 3.14 -> System.out.println("pi");
    default   -> System.out.println("other");
}
答え

Q1の出力:

two
three

case 2 に break がないので case 3 へフォールスルー。case 3 の break で終了。

Q2: コンパイルエラー。double は switch で使えない型。

2-11. for ループ ─ 完全解説

基本 for の構造

for (初期化式; 条件式; 更新式) {
    本体;
}

3つの式はすべて省略可能（セミコロンだけは必要）。

// 通常
for (int i = 0; i < 5; i++) {
    System.out.print(i + " ");   // 0 1 2 3 4
}

// 初期化を外に出す（i を後で参照したいとき）
int i = 0;
for (; i < 5; i++) {
    System.out.print(i + " ");
}
System.out.println(i);  // 5（ループ後も使える）

// 更新式を省略（本体内で更新）
for (int j = 0; j < 5; ) {
    System.out.print(j + " ");
    j += 2;   // 本体で更新: 0 2 4
}

// 全省略（無限ループ）
for (;;) {
    // break がないと永遠に回る
    break;   // とりあえず即終了
}

変数スコープ

for (int i = ...) で宣言した変数のスコープはそのループブロック内のみ。

for (int i = 0; i < 5; i++) { }
System.out.println(i);  // ❌ コンパイルエラー！i はここでは使えない

// スコープを外に出したい場合
int i = 0;
for (; i < 5; i++) { }
System.out.println(i);  // ✅ 5（i は外で宣言されているので使える）

複数変数の同時制御

初期化式と更新式はカンマ区切りで複数書ける。

for (int i = 0, j = 10; i < j; i++, j--) {
    System.out.println(i + " : " + j);
}
// 0:10, 1:9, 2:8, 3:7, 4:6

ただし初期化式で宣言する変数はすべて同じ型でなければならない（型宣言は一度しか書けない）。

for (int i = 0, double d = 0.0; ...) { }  // ❌ エラー（型が違う）

拡張 for（for-each）

コレクションや配列を先頭から順番に舐めるときに使う。簡潔に書けるが制約もある。

int[] nums = {10, 20, 30, 40, 50};
for (int n : nums) {
    System.out.print(n + " ");  // 10 20 30 40 50
}

List<String> names = List.of("Alice", "Bob", "Charlie");
for (String name : names) {
    System.out.println(name);
}

拡張 for の制約（試験で問われる）:

  • 配列の要素を変更できない（ループ変数を変更しても元の配列に反映されない）
  • インデックスが取得できない（何番目の要素か分からない）
  • 逆順のイテレーションができない
  • これらが必要なら基本 for を使う
int[] arr = {1, 2, 3};
for (int n : arr) {
    n = n * 2;   // この変更は arr に反映されない！
}
System.out.println(Arrays.toString(arr));  // [1, 2, 3]（変わっていない）

2-12. while と do-while

while（前判定）

条件を先に評価する。最初から条件が偽なら1回も実行されない。

int i = 0;
while (i < 5) {
    System.out.print(i + " ");  // 0 1 2 3 4
    i++;
}

// 最初から偽なら0回
int x = 10;
while (x < 5) {
    System.out.println("絶対実行されない");
}
// ← 何も出力されない

do-while（後判定）

本体を先に実行してから条件を評価する。必ず1回は実行される。

int i = 0;
do {
    System.out.print(i + " ");  // 0 1 2 3 4
    i++;
} while (i < 5);   // ← セミコロン必須

// 条件が最初から偽でも1回実行される
int x = 10;
do {
    System.out.println("1回は実行される！");  // ← 出力される
} while (x < 5);   // x=10 < 5 は偽 → ループ終了

試験の超頻出パターン
「do-while が最初から条件 false の場合、何回実行されるか？」
答えは常に「1回」。

while vs do-while の使い分けイメージ

// while の使いどころ: 「0回実行されることもある処理」
Scanner sc = new Scanner(System.in);
while (sc.hasNextLine()) {
    System.out.println(sc.nextLine());
}

// do-while の使いどころ: 「最低1回は実行する処理」（入力の再試行など）
String input;
do {
    System.out.print("1〜10の数を入力: ");
    input = sc.nextLine();
} while (!input.matches("[1-9]|10"));

2-13. break / continue / ラベル付き制御

break ─ ループを即座に終了

for (int i = 0; i < 10; i++) {
    if (i == 5) break;           // i=5 になったらループを抜ける
    System.out.print(i + " ");   // 0 1 2 3 4
}

break は switch 文の中でも使う（case から抜ける）。

continue ─ 今回のイテレーションをスキップ

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) continue;   // 偶数はスキップして次のイテレーションへ
    System.out.print(i + " ");  // 1 3 5 7 9
}
// i=0: continue → i=1: 出力 → i=2: continue → i=3: 出力 ...

break はループを「終わる」、continue はループを「次へ進める」。

ラベル付き break ─ 外側のループを直接抜ける

ネストしたループで内側のループの break を使うと、内側のループだけが終わる。外側のループを抜けたい場合にラベルを使う。

// ラベルなし break（内側ループのみ抜ける）
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 1) break;       // 内側だけ終わる
        System.out.print(i + ":" + j + " ");
    }
}
// 0:0  1:0  2:0（各外ループで j=0 のみ出力）

System.out.println();

// ラベル付き break（外側ループごと抜ける）
outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) break outer;   // outer ラベルのループを終了
        System.out.print(i + ":" + j + " ");
    }
}
// 0:0  0:1  0:2  1:0（i=1,j=1 で両方のループが終わる）

ラベルは任意の識別子で付けられる（慣習的に UPPER_CASE か outer inner など）。

ラベル付き continue ─ 外側ループの次のイテレーションへ

outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 1) continue outer;  // 外側ループの次の i に進む
        System.out.print(i + ":" + j + " ");
    }
}
// 0:0  1:0  2:0
// j=1 になるたびに外側の次の i へジャンプ → j=0 だけが出力される

「内側ループを終わらせて外側ループの次へ」という感じ。

✏️ 練習問題 3

Q1: 次のコードの出力を答えよ。

outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i + j >= 3) break outer;
        System.out.print(i + "" + j + " ");
    }
}

Q2: 次の do-while は何回 "loop" を出力するか。

int x = 100;
do {
    System.out.println("loop");
} while (x < 0);
答え

Q1の出力:

00 01 02 10 11
  • i=0: j=0(合計0)→出力、j=1(合計1)→出力、j=2(合計2)→出力
  • i=1: j=0(合計1)→出力、j=1(合計2)→出力、j=2(合計3)→break outer

i=1, j=2 で合計 3 になり break outer で両方のループ終了。

Q2: 1回。do-while は本体を先に実行してから条件を確認する。1回実行後、100 < 0 が false なのでループ終了。

Chapter 02 まとめチェックリスト

  • 整数の / は小数切り捨て（10 / 3 → 3）
  • (double)(a / b) は整数除算後の変換（3.0）、(double)a / b は先に変換（3.333...）
  • % の符号は左辺の符号に従う（-7 % 3 = -1）
  • 整数のゼロ除算は ArithmeticException、浮動小数点は Infinity か NaN
  • 前置 ++x は先に加算してから値を使う。後置 x++ は先に値を使ってから加算
  • && / || は短絡評価あり。& / | は短絡評価なし（両辺を必ず評価）
  • if の条件式は boolean のみ（if (n = 5) はエラー）
  • 波カッコなしの if は直後の1文だけを制御
  • b = b + 1 はエラー（型プロモーション）、b += 1 は OK（暗黙キャストあり）
  • switch で使えない型: long, float, double, boolean
  • switch 文の break 忘れはフォールスルー
  • switch 式のアロー構文はフォールスルーなし
  • switch 式のブロック内では yield で値を返す
  • do-while は条件が最初から偽でも必ず1回実行される
  • 拡張 for はコレクション/配列の前から順番のみ。変更・インデックス取得不可
  • ラベル付き break で外側ループを直接終了できる
  • ラベル付き continue で外側ループの次のイテレーションに進める