Java SE Silver 無料サンプル

JVM が起動時に呼び出すエントリーポイントは、public・static・戻り値 void・引数が String[]（または可変長引数 String...）という条件をすべて満たすメソッドでなければならない。

• A：条件をすべて満たす標準形。適格。
• B：修飾子 public と static の記述順序は自由（static public でも public static と同じ意味）。適格。
• C：static が無い。JVM はインスタンス生成無しにクラスから直接呼び出すため、static は必須。不適格（コンパイルは通るが、実行時に「main メソッドが static でない」旨のエラーになる）。
• D：引数が配列でない単一の String。エントリーポイントの条件を満たさない。不適格。

よって適格なのは A・B。

A・B：javac 通過・java コマンドで正常起動。
C：javac 通過だが「main メソッドが static でない」旨の実行時エラー（Error: Main method is not static in class クラス名, please define the main method as:）。
D：javac 通過だが「main メソッドが見つからない」旨の実行時エラー（Error: Main method not found in class クラス名, please define the main method as:）＝シグネチャが一致しないため。

1つの .java ファイル（コンパイル単位）に複数のトップレベル型（class/interface/enum等）を書くこと自体は可能だが、 public なトップレベル型は1ファイルにつき最大1つという制約がある。さらに、その唯一の public 型はファイル名と同名でなければならない。

本コードには Q3（ファイル名と一致・public）に加え、Helper も public で宣言されている。 public なトップレベル型が2つ存在するためコンパイルエラーになる。

解決するには Helper から public を外す（パッケージプライベートにする）か、Helper を別ファイル Helper.java に分ける。

javac でコンパイル：
Q3.java:6: error: class Helper is public, should be declared in a file named Helper.java
public class Helper {
       ^
→ コンパイル不成立（実行に至らない）。

ワイルドカードインポート（import パッケージ.*;）は、そのパッケージ配下の全ての型を「使用可能な候補」として取り込むだけで、 実際にどの型を指すかはコード中で使われた時点で解決される。

java.util と java.sql の両方に Date という同名クラスが存在する。 両方をワイルドカードインポートした状態で単に Date と書くと、コンパイラはどちらの Date か一意に決定できず、曖昧な参照としてコンパイルエラーになる。

解消するには java.util.Date d = new java.util.Date(); のように完全修飾名で指定するか、片方だけを単一型インポート（import java.util.Date;）にする。

javac でコンパイル：
Q4.java:5: error: reference to Date is ambiguous
        Date d = new Date();
        ^
  both class java.util.Date in java.util and class java.sql.Date in java.sql match
→ コンパイル不成立（実行に至らない）。

通常の import が「型（クラス／インタフェース）」を無修飾で使えるようにするのに対し、 import static は特定クラスの static メンバ（フィールドやメソッド）を、クラス名で修飾せず直接使えるようにする。

1行目 import static java.lang.Math.PI; により定数 Math.PI を単に PI と書ける。 2行目 import static java.lang.Math.sqrt; により Math.sqrt(...) を単に sqrt(...) と書ける。

PI は正の値であり、sqrt(PI)（平方根）は必ず0より大きいので sqrt(PI) > 0 は常に true。 Math.PI の値そのものは 3.141592653589793（double 定数）。

出力：
true
3.141592653589793

トップレベル型が public として宣言されている場合、その型名はソースファイル名（拡張子 .java を除いた部分）と完全に一致していなければならない。

本コードのクラス名は Runner だが、ファイル名は Main.java であり一致しない。よってコンパイルエラーになる。

解決するには、ファイル名を Runner.java に変更するか、クラス名を Main に変更する（クラス名を public のまま変えない場合はファイル名の方を合わせるのが一般的）。

javac Main.java：
Main.java:1: error: class Runner is public, should be declared in a file named Runner.java
public class Runner {
       ^
→ コンパイル不成立（実行に至らない）。

main の引数 args には、java クラス名 の後ろに続けて書いたコマンドライン引数だけが渡される（実行対象のクラス名自体は含まれない）。

java Q7 hello では引数は "hello" の1個だけなので、args = {"hello"}、args.length = 1。 3行目 args.length の出力は1。

4行目 args[1] は存在しないインデックス（有効なのは args[0] のみ）。配列の範囲外アクセスはコンパイル時には検出されず、実行時に ArrayIndexOutOfBoundsException がスローされる。

出力と例外：
1
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 1 out of bounds for length 1
（3行目の 1 は出力された後、4行目で例外が発生し以降は実行されない）

byte 型の実引数に対して f(int)・f(long)・f(double) のいずれも暗黙の拡大変換（widening）で呼び出し可能であり、複数のオーバーロードが候補になる。

このように複数の候補がある場合、コンパイラは最も小さい（変換段階の少ない）拡大変換で到達できるオーバーロードを優先する。 プリミティブの拡大変換の順序は byte → short → int → long → float → double。

byte から最も近い（変換1段階）候補は int であり、long・double はさらに遠い（変換段階が多い）。 よってコンパイラは f(int) を選択し、出力は int になる。

出力：
int

クラスには3種類の初期化コードがあり、実行タイミングが異なる。

• static 初期化子（static { ... }）：クラスが最初にロードされた時に1回だけ実行される。
• インスタンス初期化子（{ ... }）：インスタンスが生成されるたびに、コンストラクタ本体の実行より前に実行される。
• コンストラクタ：インスタンス初期化子の後に実行される。

main 実行時、Q9 クラスが初めてロードされ static 初期化子が1回だけ走り "S" を出力。 その後 new Q9() のたびに「インスタンス初期化子→コンストラクタ」の順で "I"→"C" が出力される。 2回の new Q9() でこれが2セット走るので、全体は "S" + "IC" + "IC" → SICIC。

出力：
SICIC

import は「毎回完全修飾名を書く手間を省くための構文糖衣」であり、必須ではない。 型を使用するたびに完全修飾名（パッケージ名を含むフルネーム）で記述すれば、import 文が無くてもコンパイル・実行できる。

本コードは java.util.List・java.util.ArrayList をそれぞれ完全修飾名で記述しており、意味的には import java.util.*; をした上で List・ArrayList と書くのと同じ。 list.add(42) でオートボクシングされた Integer(42) が追加され、list の toString()（AbstractCollection 由来）は要素をカンマ区切りで [ ] 内に出力する。

出力：
[42]

byte の表現範囲は -128 〜 127（符号付き8ビット）。

リテラルの右辺がコンパイル時定数式であり、かつ代入先の型の範囲に収まる場合に限り、明示的なキャスト無しで int リテラルを byte 変数へ代入できる（縮小変換の特例）。

3行目 byte b1 = 127; は範囲の上限ちょうどなので適格。 4行目 byte b2 = 128; は 128 が byte の範囲（最大127）を超えているため、この特例が適用できずコンパイルエラーになる。

javac でコンパイル：
Q11.java:4: error: incompatible types: possible lossy conversion from int to byte
        byte b2 = 128;
                  ^
→ コンパイル不成立（実行に至らない）。

数値リテラルには可読性のためにアンダースコア（_）を桁区切りとして挿入できるが、挿入できる位置には制約がある。 禁止位置は「リテラルの先頭・末尾」「小数点（.）の直前直後」「L・f・d などの型サフィックスの直前」「基数プレフィックス（0x・0b）の直後」。それ以外の数字と数字の間であれば自由に置ける。

• 3行目 1_000_000：数字同士の間のみ。適格。
• 4行目 3_14.159：アンダースコアは 3 と 14 の間（数字同士）にあり、小数点には接していない。適格。
• 5行目 9_999_999_999L：どのアンダースコアも数字同士の間で、L サフィックスの直前は数字（9）。適格。
• 6行目 10_00_.5f：末尾のアンダースコア _ が小数点 . の直前に置かれている。これは禁止位置でありコンパイルエラーになる。

6行目のみが不正であり、そこでコンパイルが失敗する。

javac でコンパイル：
Q12.java:6: error: illegal underscore
        float f = 10_00_.5f;
                        ^
→ コンパイル不成立（実行に至らない）。

整数リテラル（L サフィックスの無いもの）は既定で int 型として解釈される。これは代入先の変数の型（ここでは long）とは無関係で、リテラル自体が先に int として評価される。

int の表現範囲は約 -21億〜+21億（正確には -2147483648 〜 2147483647）。3000000000 はこの範囲を超えているため、 リテラルの時点で「too large」なリテラルとしてコンパイルエラーになる。long 型の変数へ代入しようとしていることは救済にならない。

正しく書くには long x = 3000000000L; のようにL サフィックスを付け、リテラル自体を long として扱わせる必要がある。

javac でコンパイル：
Q13.java:3: error: integer number too large: 3000000000
        long x = 3000000000;
                 ^
→ コンパイル不成立（実行に至らない）。

浮動小数点リテラル（f／F サフィックスの無いもの）は既定で double 型として解釈される。

double（64ビット）から float（32ビット）への代入は精度が落ちる縮小変換であり、 int→byte のような「定数式が範囲に収まれば無条件OK」という特例は浮動小数点には適用されない。 そのため 3.14（double）をキャストや f サフィックス無しで float 変数へ代入するとコンパイルエラーになる。

正しく書くには float f = 3.14f;（f サフィックスでリテラル自体を float にする）か、float f = (float) 3.14;（明示キャスト）のいずれかが必要。

javac でコンパイル：
Q14.java:3: error: incompatible types: possible lossy conversion from double to float
        float f = 3.14;
                  ^
→ コンパイル不成立（実行に至らない）。

char は文字コードを保持する16ビットの符号無し整数型で、算術演算子（+ など）に使うと int に二項数値昇格（binary numeric promotion）される。

c + 1 は char と int の演算であり、結果の型はint になる（値としては 'A' の文字コード65に1を足した66）。

4行目 c = c + 1; はint 型の式を char 型の変数へキャスト無しで代入しようとしており、これは縮小変換にあたるためコンパイルエラーになる。 正しく書くには c = (char) (c + 1);（明示キャスト）または c += 1;（複合代入演算子には暗黙のキャストが組み込まれている）を使う。

javac でコンパイル：
Q15.java:4: error: incompatible types: possible lossy conversion from int to char
        c = c + 1;
              ^
→ コンパイル不成立（実行に至らない）。

var（Java 10〜・ローカル変数型推論）は「型を書かなくてよい」だけであり、あくまで静的型付けの範囲内で使われる点が最大の注意点。

• A：正しい。var は初期化子から型を推論するため、宣言と同時の初期化が必須。var x;（初期化子無し）はコンパイルエラー。
• B：誤り。var が使えるのはローカル変数（メソッド内・forの初期化子・try-with-resources等）のみ。フィールド・メソッドの引数・戻り値の型には使えない。
• C：正しい。var は動的型付けではない。コンパイル時に初期化式から具体的な型（例：String）が確定し、以降はその型の変数として扱われる（別の型の値を代入すれば通常の型不一致エラーになる）。
• D：誤り。null 単体からは推論すべき具体的な型が存在しないため、var x = null; はコンパイルエラーになる（var x = (String) null; のように明示すれば型が定まり可）。

したがって正しいのは A・C。

A・C：正しい記述（コンパイル時挙動として確認可能）。
B：フィールドに var を使うとコンパイルエラー「var is not allowed here」。
D：var x = null; はコンパイルエラー「cannot infer type for local variable x（variable initializer is 'null'）」。

var は配列型の変数にも使える。3行目 var arr = new int[]{1, 2, 3}; では、初期化式 new int[]{1, 2, 3} の型が int[] であることから、 arr の型はint[] と推論される。

4行目の拡張for文 for (var v : arr) でも var が使え、arr の要素型 int から v の型はint と推論される。

ループは arr の要素 1, 2, 3 を順に v へ束縛し、System.out.print(v + " ") を3回実行する。 出力は 1 2 3 （各数値の後に半角スペースが1つ付き、末尾にもスペースが1つ残る）。

出力：
1 2 3
（末尾に半角スペース1個。改行なし）

Integer a = 100; のような記述はオートボクシングにより内部的に Integer.valueOf(100) が呼ばれる。 Integer.valueOf(int) は-128 〜 127 の範囲の値については、あらかじめ用意されたキャッシュ済みインスタンスを使い回す（同じ値なら同一オブジェクトを返す）。

a・b は 100（キャッシュ範囲内）なので、同一のキャッシュ済みオブジェクトを参照する。参照を比較する == は true。

c・d は 200（キャッシュ範囲外）なので、valueOf は都度新しい Integer オブジェクトを生成する。 値は等しくても参照が異なるため、c == d は false。

出力は "true false"。

出力：
true false

• A：正しい。x は null。x + 1 の演算では x を int にアンボクシングする必要があるが、参照先が無いため NullPointerException が実行時にスローされる（コンパイルエラーではない＝コンパイル自体は通る）。
• B：正しい。int と Integer が混在する算術演算では、Integer 側が自動的にアンボクシングされて int 同士の演算になる。
• C：誤り。== はラッパーオブジェクトの参照を比較する演算子であり、-128〜127のキャッシュ範囲外では別オブジェクトになり false になり得る。「常に true」は誤り。
• D：誤り。オートボクシングは内部的に Integer.valueOf(int) を呼び出す。valueOf はキャッシュ範囲内なら既存オブジェクトを再利用するため、常に新規オブジェクトになるわけではない（new Integer(...) は常に新規生成するが、それとオートボクシングの経路は同じではない）。

したがって正しいのは A・B。

実行結果：
Exception in thread "main" java.lang.NullPointerException
    at Q19.main(Q19.java:4)
（4行目のアンボクシングで例外・5行目には到達しない）

Integer.parseInt(String) と Integer.valueOf(String) はどちらも文字列を数値に変換するが、戻り値の型が異なる。

• Integer.parseInt(String)：戻り値はプリミティブ int。
• Integer.valueOf(String)：戻り値はInteger（ラッパー・オブジェクト）。

3・4行目はどちらも "123"（正しい整数形式）なので問題なく変換される（a=123、b=Integer型の123）。

しかし5行目 Integer.parseInt("12.3") は、小数点を含む文字列は整数として解釈できないため、実行時に NumberFormatException がスローされる（これはコンパイル時ではなく、渡された文字列の内容次第で実行時に判明する）。 例外は6行目の println より前に発生するため、"123 123" は出力されない。

実行結果：
Exception in thread "main" java.lang.NumberFormatException: For input string: "12.3"
    at java.base/java.lang.Integer.parseInt(Integer.java:...)
    at Q20.main(Q20.java:5)
（5行目で例外がスローされ、6行目の println には到達しない＝"123 123" は出力されない）

int 同士の除算 / は小数点以下を切り捨てる（ゼロ方向へ丸める＝truncation）。数学的な「切り下げ（floor）」ではない点に注意する。

• 7 / 2 ＝ 3.5 → ゼロ方向に切り捨てて 3。
• -7 / 2 ＝ -3.5 → ゼロ方向に切り捨てて -3（floor すると -4 になるがJavaはそうならない）。

したがって a=3, b=-3 となり、出力は 3 -3。

出力：
3 -3

Java の剰余演算子 % の結果の符号は左辺（被除数）の符号と一致する。これは (a / b) * b + (a % b) == a という恒等式から導かれる（/ がゼロ方向への切り捨てであることと整合する）。

• -7 % 3：-7 / 3 はゼロ方向切り捨てで -2。-2 * 3 = -6。-7 - (-6) = -1 → -1。
• 7 % -3：7 / -3 はゼロ方向切り捨てで -2。-2 * -3 = 6。7 - 6 = 1 → 1。

よって a=-1, b=1、出力は -1 1。

出力：
-1 1

後置 i++ は「現在の値を式の値として使い、その後に i を1増やす」。前置 ++i は「先に i を1増やし、増やした後の値を式の値として使う」。この違いを左から順に追う。

• i++：式の値は増やす前の i＝5。副作用として i は 6 になる。
• ++i：まず i を 7 に増やし、式の値も7。

j = 5 + 7 = 12。最終的な i は 7。よって出力は 7 12。

出力：
7 12

複合代入演算子 E1 op= E2 は、単なる E1 = E1 op E2 の省略形ではなく、結果を E1 の型へ自動的にキャストし直すという特別な意味を持つ（JLS §15.26.2）。等価な形は次の通り：

E1 = (T) ((E1) op (E2))

ここで T は E1（byte b）の型。b + 5 は二項数値昇格により int 演算（15）になるが、b += 5 はこれを暗黙に (byte) へキャストしてから b へ代入する。15 は byte の範囲（-128〜127）に収まるため実行時エラーにもならず、b は 15 になる。

出力：
15

+ 演算子は左から右へ結合（left-associative）し、途中で数値の加算と文字列連結が切り替わる点が重要。String が一度でも登場すると、それ以降の + はすべて文字列連結になる。

• 1 + 2：どちらも int → 加算 → 3（int）。
• 3 + "3"：右辺が String → 文字列連結 → "33"。
• "33" + 4：左辺が既に String → 文字列連結 → "334"。
• "334" + 5：同様に連結 → "3345"。

出力は 3345。

出力：
3345

&&（条件積・短絡評価）は、左辺が false であればその時点で式全体が false と確定し、右辺は評価されない（呼び出されない）。

• check(-1, sb) が実行される：sb に "-1" が追加され、-1 > 0 は false を返す。
• 左辺が false なので && は短絡し、check(2, sb) は呼ばれない（sb に "2" は追加されない）。
• r = false、sb の内容は "-1" のまま。

出力は false -1。

出力：
false -1

& と | は「int 同士のビット演算子」というイメージが強いが、実はboolean 同士にも適用でき、その場合は「短絡評価をしない論理演算子」として働く（JLS §15.22）。

• &&：左辺が false なら右辺を評価しない（短絡評価）。
• ||：左辺が true なら右辺を評価しない（短絡評価）。
• &（boolean版）：両辺を必ず評価してから論理積を取る（短絡しない）。
• |（boolean版）：両辺を必ず評価してから論理和を取る（短絡しない）。

したがって & は int のビット演算専用ではなく boolean にも使え、| も同様に boolean に使える。「| は int のビット演算にしか使えない」という記述は誤り。

検証（例）：
static boolean check(int x, StringBuilder sb){ sb.append(x); return x>0; }
StringBuilder sb = new StringBuilder();
boolean r = check(1, sb) | check(-2, sb);
// r=true、sb="1-2" （両辺とも呼ばれる＝非短絡）

条件演算子 ? : の結果の型は、条件が実際に true／false のどちらであったかとは無関係に、第2・第3オペランドの型から静的に決まる（JLS §15.25）。

第2オペランドが int（x）、第3オペランドが double（3.0）で、両者が数値型かつ定数の特別扱い（byteへの収まり等）に該当しない場合、二項数値昇格（binary numeric promotion）が適用され、式全体の型はより広い double に統一される。

したがって、条件が true で選ばれるのは x の枝でも、評価結果は int の 5 のままではなく、double に昇格された 5.0 になる。println(double) は 5.0 と表示する。

出力：
5.0

Java の演算子優先順位は概ね 乗除算（*／/／%） > 加減算（+／-） > 関係演算子（<／> 等） > 論理演算子（&&／||）の順（数値が大きいものから低くなる）。この順で式を分解する。

• 乗算：5 * 2 = 10。
• 加算：10 + 10 = 20。
• 関係演算子：20 > 15 → true、3 < 4 → true。
• 論理積：true && true → true。

出力は true。

出力：
true

代入演算子まわりのコンパイル可否は「暗黙の縮小変換が許される場面か」と「final 変数への再代入か」で決まる。

• A：x += 3.5; は複合代入演算子。x = (int)(x + 3.5) と等価に暗黙キャストされるためコンパイルが通る（x は (int)13.5 = 13）。
• B：x = x + 3.5; は単純代入。右辺 x + 3.5 は double になり、それを int 変数へ明示キャスト無しで代入しようとするためコンパイルエラー（double→int の暗黙の縮小変換は不可）。
• C：b++; は増分演算子。複合代入と同様に暗黙キャストが働くため byte に対してもコンパイルが通る。
• D：final 変数への再代入はコンパイルエラー（final は「一度だけ代入可・以後変更不可」を意味する）。

コンパイルが通るのは A と C。

検証：
A) int x=10; x+=3.5; → コンパイル可・x=13
B) int x=10; x=x+3.5; → コンパイルエラー（incompatible types: possible lossy conversion from double to int）
C) byte b=10; b++;   → コンパイル可・b=11
D) final int y=5; y=6; → コンパイルエラー（cannot assign a value to final variable y）

配列要素への代入 arr[E2] = E3; の評価順は JLS で厳密に決まっている（§15.26.1）。

1. まず配列参照 arr を評価する。
2. 次に添字（インデックス）式 i++ を評価する。ここで後置インクリメントの副作用（i を1増やす）がこの時点で発生する。式の値としては増やす前の 0 が使われるので、代入先は arr[0]。同時に i は 1 になる。
3. 最後に右辺 i を評価する。この時点で i は既に 1 に更新済みなので、右辺の値は 1。
4. arr[0] = 1; が実行される。

結果：arr = {1, 20, 30}、i = 1。出力は 1 20 1。

出力：
1 20 1