パターン、instanceof、switchのプリミティブ型(第2プレビュー)

このドキュメントでは、Java SE 24のプレビュー機能であるinstanceofのパターン・マッチングに対するプリミティブ型をサポートするためのJava言語仕様の変更について説明します。この機能の概要は、JEP:488を参照してください。

変更は、JLSの既存のセクションについて説明しています。新しいテキストはこのように示され、削除されたテキストはこのように示されます。必要に応じて、説明と考察が端の方にグレーのボックスで囲まれて記載されています。

第1章: 概要

1.4 事前定義済のクラスとインタフェースの関係

前述のように、この仕様は、Java SE Platform APIのクラスとインタフェースを指すことがよくあります。特に、一部のクラスとインタフェースは、Javaプログラミング言語と特別な関係があります。例として、Object、Class、ClassLoader、StringおよびThread、などのクラス、クラスjava.math.BigDecimal、インタフェースjava.io.Serializableおよびパッケージjava.lang.reflectのクラスとインタフェースなどが含まれます。この仕様は、そのようなクラスとインタフェースの動作を制約しますが、それらの完全な仕様は提示しません。読者は、Java SE Platform APIのドキュメントを参照してください。

したがって、この仕様にはリフレクションの詳細な説明はありません。多くの言語構造は、コア・リフレクションAPI (java.lang.reflect)と言語モデルAPI (javax.lang.model)に類似したものがありますが、通常、ここでは説明しません。たとえば、オブジェクトを作成する方法をリストする場合、通常、これをコア・リフレクションAPIで実現する方法は含めていません。読者は、テキストに記載されていなくても、それらの追加のメカニズムに注意する必要があります。

第5章: 変換およびコンテキスト

Javaプログラミング言語で記述されるすべての式は、結果を生成しないか(15.1)、コンパイル時に推論できる型(15.3)のいずれかになります。ほとんどのコンテキストに現れる式は、そのコンテキストで想定される型との互換性がある必要があります。この型はターゲット型と呼ばれます。便宜上、式と式の周囲のコンテキストとの互換性は、次の2つの方法で容易になります:

• まず、多相的な式(15.2)と呼ばれる一部の式では、推論される型がターゲット型の影響を受ける可能性があります。異なるコンテキストでは、同じ式に異なる型を指定できます。

• 次に、式の型が推論された後、式の型からターゲット型への暗黙的な変換を実行できる場合があります。

どちらの方法でも適切な型を生成できない場合は、コンパイル時にエラーが発生します。

式が多相的な式かどうかを決定するルールと、多相的な式の場合の特定のコンテキストでの型と互換性は、コンテキストの種類と式の形式によって異なります。ターゲット型は、式の型に影響を与えることに加えて、適切な型の値を生成するために式の実行時の動作に影響を与えることがあります。

同様に、ターゲット型で暗黙的な変換を許可するかどうかを決定するルールは、コンテキストの種類、式の型、および1つの特殊なケースでは定数式の値(15.29)によって異なります。型Sから型Tへの変換により、コンパイル時に型Sの式を型Tであるかのように処理できます。場合によっては、変換の妥当性をチェックするためや、式の実行時の値を新しい型Tに適した形式に変換するために、実行時に対応する処置が必要になることがあります。

Javaプログラミング言語で可能な変換は、いくつかの広範なカテゴリに分類されます:

• 恒等変換
• プリミティブの拡大変換
• プリミティブの縮小変換
• 参照の拡大変換
• 参照の縮小変換
• ボクシング変換
• アンボクシング変換
• 無検査変換
• 取得変換
• 文字列変換

多相的な式がコンテキストの影響を受ける可能性がある、または暗黙的な変換が発生する可能性のある変換コンテキストには7つの種類があります。コンテキストの種類ごとに、多相的な式の型付けのルールが異なり、前述の一部のカテゴリでは変換できますが、別のカテゴリでは変換できません。コンテキストは次のとおりです:

• 割当てコンテキスト(5.2、15.26)。式の値が名前付き変数にバインドされます。プリミティブ型と参照型は拡大の対象になり、値はボックス化またはボックス化解除されることがあり、一部のプリミティブ定数式は縮小の対象となることがあります。無検査変換が発生することもあります。

• 厳密な呼出しコンテキスト(5.3、15.9、15.12)。引数はコンストラクタまたはメソッドの仮パラメータにバインドされます。プリミティブの拡大変換、参照の拡大変換、無検査変換が発生する可能性があります。

• 緩い呼出しコンテキスト(5.3、15.9、15.12)は、厳密な呼出しコンテキストと同様に、引数は仮パラメータにバインドされます。メソッドまたはコンストラクタの呼出しは、厳密な呼出しコンテキストのみを使用すると適用可能な宣言が見つからない場合に、このコンテキストを提供することがあります。このコンテキストでは、拡大変換および無検査変換に加えて、ボックス化およびボックス化解除の変換を実行できます。

• 文字列コンテキスト(5.4、15.18.1)。任意の型の値がString型のオブジェクトに変換されます。

• キャスト・コンテキスト(5.5)。式の値が、キャスト演算子(15.16)によって明示的に指定された型に変換されます。キャスト・コンテキストは、割当てコンテキストや緩い呼出しコンテキストよりも包括的で、文字列変換以外の特定の変換が可能です。ただし、参照型への特定のキャストは、実行時に正確性が検査されます。

• 数値コンテキスト(5.6)。数値演算子のオペランドまたは数値を操作するその他の式のオペランドは、共通型に拡張できます。

• テスト・コンテキスト(5.7)。式の値が比較され、場合によっては型比較演算子(15.20.2)またはパターン(14.30)パターン・マッチング(14.30.2)によって明示的に指定された型に変換されます。テスト・コンテキストは、割当てコンテキストや緩い呼出しコンテキストよりも包括的ですが、キャスト・コンテキストほど包括的ではありません。

「変換」という用語は、特定のコンテキストで許可される変換を具体的にせずに記述するためにも使用されます。たとえば、ローカル変数のイニシャライザである式が「割当て変換」の対象であると表現した場合は、割当てコンテキストのルールに従って、特定の変換がその式に暗黙的に選択されることを意味します。別の例として、式が「キャスト変換」されると表現した場合は、式の型がキャスト・コンテキストで許可されたとおりに変換されることを意味します。

class Test {
    public static void main(String[] args) {
        // Casting conversion (5.5) of a float literal to
        // type int. Without the cast operator, this would
        // be a compile-time error, because this is a
        // narrowing conversion (5.1.3):
        int i = (int)12.5f;

        // String conversion (5.4) of i's int value:
        System.out.println("(int)12.5f==" + i);

        // Assignment conversion (5.2) of i's value to type
        // float. This is a widening conversion (5.1.2):
        float f = i;

        // String conversion of f's float value:
        System.out.println("after float widening: " + f);

        // Numeric promotion (5.6) of i's value to type
        // float. This is a binary numeric promotion.
        // After promotion, the operation is float*float:
        System.out.print(f);
        f = f * i;

        // Two string conversions of i and f:
        System.out.println("*" + i + "==" + f);

        // Invocation conversion (5.3) of f's value
        // to type double, needed because the method Math.sin
        // accepts only a double argument:
        double d = Math.sin(f);

        // Two string conversions of f and d:
        System.out.println("Math.sin(" + f + ")==" + d);
    }
}

(int)12.5f==12
after float widening: 12.0
12.0*12==144.0
Math.sin(144.0)==-0.49102159389846934

5.1 変換の種類

5.1.2 プリミティブの拡大変換

プリミティブ型に対する19の特定の変換は、プリミティブの拡大変換と呼ばれます:

• byteからshort、int、long、floatまたはdouble

• shortからint、long、floatまたはdouble

• charからint、long、floatまたはdouble

• intからlong、floatまたはdouble

• longからfloatまたはdouble

• floatからdouble

数値の全体的な絶対値に関する情報が失われない拡大プリミティブ変換数値が正確に保たれる次の場合は、正確な拡大プリミティブ変換と呼ばれ、数値は正確に保持されます。このような変換は、次のいずれかになります:

• 整数型から別の整数型

• byte、shortまたはcharから浮動小数点型

• intからdouble

• floatからdouble

intからfloat、longからfloatまたはlongからdoubleへの拡大プリミティブ変換は、制度が失われることがあります。つまり、値の右端ビットの一部が失われる結果を招く可能性があります。この場合、結果の浮動小数点値は、最近接丸めポリシー(15.4)を使用して適切に丸められたバージョンの整数値になります。

符号付き整数値から整数型Tへの拡大変換は、より幅が広い形式を満たすために単に整数値の2の補数表現を符号拡張します。

charから整数型Tへの拡大変換は、より幅が広い形式を満たすためにchar値の表現をゼロ拡張します。

intからfloat、longからfloat、intからdoubleまたはlongからdoubleへの拡大変換は、整数形式からバイナリ浮動小数点形式への変換に関するIEEE 754のルールに従います。

floatからdoubleへの拡大変換は、バイナリ浮動小数点形式間の変換に関するIEEE 754のルールに従います。

精度の損失が発生する可能性はありますが、プリミティブの拡大変換によって実行時の例外が発生することはありません(11.1.1)。

class Test {
    public static void main(String[] args) {
        int big = 1234567890;
        float approx = big;
        System.out.println(big - (int)approx);
    }
}

-46

5.1.3 プリミティブの縮小変換

プリミティブ型に対する22の特定の変換は、プリミティブの縮小変換と呼ばれます:

• shortからbyteまたはchar

• charからbyteまたはshort

• intからbyte、shortまたはchar

• longからbyte、short、charまたはint

• floatからbyte、short、char、intまたはlong

• doubleからbyte、short、char、int、longまたはfloat

プリミティブの縮小変換では、数値の全体的な絶対値に関する情報が失われ、精度と範囲も失われる可能性があります。

符号付き整数を整数型Tに縮小変換すると、右端のn個のビットを除くすべてのビットが単に破棄されます。このnは、型Tを表すために使用されるビット数です。数値の絶対値に関する情報が失われる可能性に加えて、結果の値の符号が入力値の符号と異なることもあります。

charを整数型Tに縮小変換すると、同様に右端のn個のビットを除くすべてのビットが単に破棄されます。このnは、型Tを表すために使用されるビット数です。数値の絶対値に関する情報が失われる可能性に加えて、charが16ビットの符号なし整数値を表す場合でも、結果の値は負の数値になることがあります。

浮動小数点数を整数型Tに縮小変換するには、次の2つのステップを実行します:

1. 最初のステップでは、浮動小数点数がlong (Tがlongの場合)またはint (Tがbyte、short、charまたはintの場合)に変換されます。

   • 浮動小数点数がNaN (4.2.3)の場合、変換の最初のステップの結果は、intまたはlong 0になります。

   • それ以外の場合、浮動小数点数が無限大でない場合、浮動小数点値はゼロ丸めポリシー(4.2.4)に従って整数値Vに丸められます。その次には、2つのケースがあります:

     1. Tがlongのときに、この整数値がlongとして表すことができる場合、最初のステップの結果はlong値Vになります。

     2. それ以外の場合、この整数値がintとして表すことができる場合、最初のステップの結果はint値Vになります。

   • それ以外の場合は、次の2つのケースのいずれかに当てはまる必要があります:

     1. 値は小さすぎるもの(大きな負の値または負の無限大)であることが必要で、最初のステップの結果は、型intまたは型longで表現可能な最小値になります。

     2. 値は大きすぎる(大きな正の値または正の無限大)ものであることが必要で、最初のステップの結果は、型intまたは型longで表現可能な最大値になります。

2. 2番目のステップ:

   • Tがintまたはlongの場合、変換の結果は最初のステップの結果になります。

   • Tがbyte、charまたはshortの場合、変換の結果は、最初のステップの結果の型Tへの縮小変換(5.1.3)になります。

doubleからfloatへの縮小変換は、バイナリ浮動小数点形式間の変換に関するIEEE 754のルールによって決定され、最近接丸めポリシー(15.4)が使用されます。この変換では精度だけでなく範囲も失われることがあり、ゼロ以外のdoubleからfloatゼロ、および有限のdoubleからfloat無限大の結果を得る可能性があります。double NaNはfloat NaNに変換され、double無限大は同じ符号が付いたfloat無限大に変換されます。

オーバーフローやアンダーフローなどの情報の損失が発生する可能性はありますが、プリミティブの縮小変換で実行時の例外が発生することはありません(11.1.1)。

class Test {
    public static void main(String[] args) {
        float fmin = Float.NEGATIVE_INFINITY;
        float fmax = Float.POSITIVE_INFINITY;
        System.out.println("long: " + (long)fmin +
                           ".." + (long)fmax);
        System.out.println("int: " + (int)fmin +
                           ".." + (int)fmax);
        System.out.println("short: " + (short)fmin +
                           ".." + (short)fmax);
        System.out.println("char: " + (int)(char)fmin +
                           ".." + (int)(char)fmax);
        System.out.println("byte: " + (byte)fmin +
                           ".." + (byte)fmax);
    }
}

long: -9223372036854775808..9223372036854775807
int: -2147483648..2147483647
short: 0..-1
char: 0..65535
byte: 0..-1

class Test {
    public static void main(String[] args) {
        // A narrowing of int to short loses high bits:
        System.out.println("(short)0x12345678==0x" +
                           Integer.toHexString((short)0x12345678));
        // An int value too big for byte changes sign and magnitude:
        System.out.println("(byte)255==" + (byte)255);
        // A float value too big to fit gives largest int value:
        System.out.println("(int)1e20f==" + (int)1e20f);
        // A NaN converted to int yields zero:
        System.out.println("(int)NaN==" + (int)Float.NaN);
        // A double value too large for float yields infinity:
        System.out.println("(float)-1e100==" + (float)-1e100);
        // A double value too small for float underflows to zero:
        System.out.println("(float)1e-50==" + (float)1e-50);
    }
}

(short)0x12345678==0x5678
(byte)255==-1
(int)1e20f==2147483647
(int)NaN==0
(float)-1e100==-Infinity
(float)1e-50==0.0

5.5 キャスト・コンテキスト

キャスト・コンテキストを使用すると、キャスト式(15.16)のオペランドは、キャスト演算子によって明示的に指定された型に変換されるようになります。割当てコンテキストおよび呼出しコンテキストとは対照的に、キャスト・コンテキストでは、5.1で定義されている変換をさらに多用できるとともに、これらの変換の組合せをより多く使用できます。

式がプリミティブ型の場合は、キャスト・コンテキストに次のいずれかを使用できます。

• 恒等変換(5.1.1)

• 拡張プリミティブ変換(5.1.2)

• 縮小プリミティブ変換(5.1.3)

• 拡張および縮小プリミティブ変換(5.1.4)

• ボックス化変換(5.1.7)

• ボックス化変換後の拡張参照変換(5.1.5)

式が参照型の場合は、キャスト・コンテキストに次のいずれかを使用できます。

• 恒等変換(5.1.1)

• 拡張参照変換(5.1.5)

• 拡張参照変換後のボックス化解除変換

• 拡張参照変換後のボックス化解除変換に続く拡張プリミティブ変換

• 縮小参照変換(5.1.6)

• 縮小参照変換後のボックス化解除変換

• ボックス化解除変換(5.1.8)

• ボックス化解除変換後の拡張プリミティブ変換

式にNULL型がある場合は、式は任意の参照型にキャストされることがあります。

キャスト・コンテキストで、検査されているか部分的に検査されていない参照の縮小変換(5.1.6.2、5.1.6.3)が使用されると、実行時に検査が実行されます。変換では、実行時に妥当性検査が式の値のクラスに対して実行され、ClassCastExceptionが発生する可能性があります。それ以外の場合は、実行時の検査は実行されません実行時に妥当性検査は実行されませんが、その他の処置は実行時に実行されます。

5.7 テスト・コンテキスト

ある型の値が比較されるときや、場合によっては別の型に変換されるときに、式のテスト・コンテキストが発生します。テスト・コンテキストでは、型比較演算子(15.20.2)のオペランドを別の型と比較できます。テスト・コンテキストでは、パターン一致演算子(15.20.2)のオペランド、またはswitchブロック(14.11.1)に関連付けられている少なくとも1つのパターンcaseラベルを持つswitch式または文のセレクタ式を比較し、パターン・マッチングのプロセスの一部として型に変換することもできます。パターン・マッチングは本質的に条件付きプロセス(14.30.2)であるため、テスト・コンテキストでは、実行時に失敗することや情報が失われることがある変換が使用されると予測されます。

テスト・コンテキストでは、参照型のキャスト・コンテキストと同様の変換が使用されますが、無検査の参照の縮小変換は許可されません(5.1.6.2)。

式がプリミティブ型の場合は、テスト・コンテキストに恒等変換(5.1.1)を使用できます。次のいずれかになります:

式が参照型の場合は、テスト・コンテキストに次のいずれかを使用できます:

• 恒等変換(5.1.1)

• 拡張参照変換(5.1.5)

• チェックされる参照の縮小変換(5.1.6.2)

式にNULL型がある場合、式は任意の参照型に変換されることがあります。

(int)(char) x == (int) x

(byte)(char) x == x

byte x = 127
(byte)(char) x == x // evaluates to true

byte x = -128
(byte)(char) x == x // also evaluates to true

(byte)(char) x // evaluates to -128

第14章: ブロックと文およびパターン

14.11 switch文

switch文は、式の値に応じて、いくつかの文または式の1つに制御を転送します。

SwitchStatement:

switch ( Expression ) SwitchBlock

Expressionはセレクタ式と呼ばれます。セレクタ式の型は、char、byte、short、intまたは参照型である必要があり、それ以外の場合はコンパイル時にエラーが発生します任意の型にできます。

14.11.1 Switchブロック

switch文およびswitch式(15.28)の両方の本体は、switchブロックと呼ばれます。このサブセクションでは、switch文またはswitch式のどちらに出現するかに関係なく、すべてのswitchブロックに適用される一般的なルールを示します。他のサブセクションでは、switch文のswitchブロック(14.11.2)またはswitch式のswitchブロック(15.28.1)のいずれかに適用される追加ルールを示します。

SwitchBlock:

{ SwitchRule {SwitchRule} }

{ {SwitchBlockStatementGroup} {SwitchLabel :} }

SwitchRule:

SwitchLabel -> Expression ;

SwitchLabel -> Block

SwitchLabel -> ThrowStatement

SwitchBlockStatementGroup:

SwitchLabel : {SwitchLabel :} BlockStatements

SwitchLabel:

case CaseConstant {, CaseConstant}

case null [, default]

case CasePattern {, CasePattern} [Guard]

default

CaseConstant:

ConditionalExpression

CasePattern:

Pattern

Guard:

when Expression

switchブロックは次のいずれかで構成できます。

• Switchルール。これは、->を使用して、switchルール式、switchルール・ブロックまたはswitchルールthrow文を導入します。または

• Switchラベルが付いた文グループ。これは:を使用してswitchラベルが付いたブロック文を導入します。

すべてのswitchルールおよびswitchラベルの付いた文グループは、switchラベル (caseラベルまたはdefaultラベルのいずれか)で始まります。複数のswitchラベルが、1つのswitchラベルが付いた文グループに許可されます。

caseラベルは、case定数の(空でない)リスト、nullリテラル、caseパターンの(空でない)リストのいずれかを持ちます。

すべてのcase定数は、定数式(15.29)またはenum定数の名前(8.9.1)のいずれかである必要があり、そうでない場合、コンパイル時にエラーが発生します。

nullリテラルを持つcaseラベルは、オプションのdefaultを持つことがあります。

caseパターンを持つcaseラベルには、ガードと呼ばれるオプションのwhen式を含めることができます。これは、パターンに一致する値に対する追加のテストを表します。caseラベルは、(i)その要素にガードがない場合、または(ii)値がtrueの定数式(15.29)であるガードがその要素にある場合に、ガードなしと表現されます。それ以外の場合はガード付きです。

caseラベルが複数のcaseパターンを持っているときにパターン変数(caseラベルに関連付けられたガードによって宣言された変数を除く)を宣言すると、コンパイル時にエラーが発生します。

caseラベルにパターン変数を宣言するcaseパターンが複数あると、caseラベルが適用された場合に、どの変数が初期化されるかが明確になりません。次に例を示します。

Object obj = ...;
switch (obj) {
  case Integer i, Boolean b -> {
    ...       // Error! Is i or b initialized?
  }
  ...
}

caseパターンのうち1つのみがパターン変数を宣言している場合でも、変数が初期化されたかどうかは明らかではありません。次に例を示します:

Object obj = ...;
switch (obj) {
  case Integer i, Boolean _ -> {
    ...       // Error! Is i initialized?
  }
  ...
}

次の場合はコンパイル時にエラーが発生しません:

Object obj = ...;
switch (obj) {
  case Integer _, Boolean _ -> {
    ...       // Matches both an Integer and a Boolean
  }
  ...
}

switchラベルとそのcase定数、nullリテラルおよびcaseパターンは、switchブロックに関連付けられていると表現されます。

特定のswitchブロックの場合は、次の両方すべてに当てはまる必要があり、そうでない場合はコンパイル時にエラーが発生します:

• switchブロックに関連付けられている2つのcase定数が同じ値を持つことがない。

• switchブロックに関連付けられているnullリテラルは1つのみ。

• defaultラベルが1つのみ、switchブロックに関連付けられている。

caseラベルに関連付けられたガードは、次のすべての条件を満たす必要があります。そうでない場合は、コンパイル時にエラーが発生します。

• ガードの型は、booleanまたはBooleanであることが必要です。

• 使用されていてもガードで宣言されていないローカル変数、仮パラメータまたは例外パラメータは、finalまたは事実上のfinal (4.12.4)であることが必要です。

• ガードで使用されていても宣言されていない空白のfinal変数は、ガードの前に明確に割り当てる(16)ことが必要です。

• ガードは、値がfalseの定数式(15.29)にすることはできません。

次のすべてに該当する場合、switch文またはswitch式のswitchブロックは、セレクタ式T型とのswitch互換性があります:

• nullリテラルがswitchブロックに関連付けられている場合、Tは参照型である。

• 列挙定数を指名するswitchブロックに関連付けられた各case定数について、case定数の型はTとの代入互換性がある(5.2)。

• switchブロックに関連付けられているすべてのパターンpは、型T (14.30.3)に適用できます。

switch文またはswitch式のswitchブロックは、セレクタ式の型とのswitch互換性が必要であり、そうでない場合はコンパイル時にエラーが発生します。

switchブロック内のswitchラベルは、それが適用されるすべての値に対して前のswitchラベルのいずれかにも適用されると判断できる場合、優先されると見なされます。switchブロック内のどのswitchラベルも優先されない場合、コンパイル時にエラーになります。switchラベルが優先されるかどうかを判断するするためのルールは次のとおりです。

• switchブロック内に、caseパターンpを持つガードされていないcaseラベルが先行し、pがq (14.30.3)より優先される場合、caseパターンqを持つcaseラベルは優先されません。

  パターンが別のパターンより優先される定義は型に基づきます。たとえば、型パターンObject oは型パターンString sより優先されるため、次の結果はコンパイル時エラーになります:

  Object obj = ...
  switch (obj) {
      case Object o ->
          System.out.println("An object");
      case String s ->                 // Error!
          System.out.println("A string");
  }

  caseパターンを持つガード付きcaseラベルよりも、同じパターンを持つガードのないcaseラベルが優先されます。たとえば、次はコンパイル時にエラーになります。

  String str = ...;
  switch (str) {
      case String s ->
          System.out.println("A string");
      case String s when s.length() == 2 ->  // Error!
          System.out.println("Two character string");
      ...
  }

  一方、caseパターンを持つガード付きcaseラベルは、同じcaseパターンを持つガード付きでないcaseラベルより優先されるとみなされません。これにより、次の一般的なパターン・プログラミング・スタイルが可能になります。

  Integer j = ...;
  switch (j) {
      case Integer i when i <= 0 ->
          System.out.println("Less than or equal to zero");
      case Integer i ->
          System.out.println("An integer");
  }

  唯一の例外は、ガードが値trueを含む定数式の場合です。次に例を示します。

  Integer j = ...;
  switch (j) {
      case Integer i when true ->            // Ok
          System.out.println("An integer");
      case Integer i ->                      // Error!
          System.out.println("An integer");
  }

  複数のcaseパターンを持つcaseラベルは、それらのパターンのいずれかが、先行するガードされていないcaseラベルでcaseパターンとして出現するパターンより優先される場合に優先されます。そのため、次のものはコンパイル時にエラーが発生します(型パターンInteger _は型パターンNumber _より優先されるため):

      Object obj = ...
      switch (obj) {
        case Number _ ->
          System.out.println("A Number");
        case Integer _, String _ ->       // Error - dominated!
          System.out.println("An Integer or a String");
        ...
      }

• 次のいずれかが保持されている場合、case定数cを持つcaseラベルは優先されません。

  • cはプリミティブ型Sの定数式であり、switchブロックには先行するcaseラベルがあり、ガードされていないcaseパターンpがあります。このpはSのラッパー・クラスでは制限されていません(14.30.3)。

  • cは参照型Tの定数式であり、switchブロックには先行するcaseラベルがあり、ガードされていないcaseパターンpがあります。ここで、pは型Tでは制限されていません。

  • cは、enumクラスEの列挙定数を指名します。switchブロックには先行するcaseラベルがあり、ガードされていないcaseパターンpがあります。このpは型Eに対して無条件です。

  たとえば、Integer型パターンを持つcaseラベルは、整数リテラルを持つcaseラベルより優先されます。

  Integer j = ...;
  switch (j) {
      case Integer i ->
          System.out.println("An integer");
      case 42 ->                              // Error - dominated!
          System.out.println("42!");
  }

• caseパターンp (pがセレクタ式の型(14.30.3)に対して無条件)で、switchブロック内に先行するガードされていないcaseラベルがある場合は、defaultラベルまたはcase null, defaultラベルが優先されます。

  セレクタ式の型で無条件であるcaseパターンを持つcaseラベルは、名前が示すように、すべての値に一致するため、defaultラベルのように動作します。switchブロックは、defaultのように動作する複数のswitchラベルを持つことはできません。

switchブロック内にn (n>1) caseパターンp₁, ..., p_nのcaseラベルがあり、パターンの1つp_i (1≤i<n)が他のパターンp_j (i<j≤n)よりも優先される場合、コンパイル時にエラーが発生します。

次のいずれかに該当する場合は、コンパイル時にエラーが発生します:

• switchブロックに、caseパターンを持つcaseラベルの前にdefaultラベルがある。

• switchブロックに、nullリテラルを持つcaseラベルの前にdefaultラベルがある。

• switchブロックにcase null, defaultラベルがあり、その後に他のswitchラベルが続いている。

使用する場合、defaultラベルはswitchブロックの最後に配置します。

互換性の理由から、defaultラベルは、nullリテラルまたはcaseパターンを持たないcaseラベルの前に指定できます。

int i = ...;
switch(i) {
    default ->
        System.out.println("Some other integer");
    case 42 -> // allowed
        System.out.println("42");
}

使用する場合、case null, defaultラベルはswitchブロックの最後に配置します。

switchラベルが付いた文グループで構成されるswitchブロックで、1つ以上のパターン変数([6.3.3])を宣言するcaseラベルで文がラベル付けされており、次のいずれかの場合は、コンパイル時にエラーが発生します:

• switchブロックの前述の文が正常に完了する可能性がある(14.22)、または

• 文に複数のswitchラベルが付けられている。

最初の条件により、文グループがパターン変数を初期化せずに別の文グループにフォール・スルーすることがなくなります。たとえば、前述の文グループから到達可能なcase Integer iというラベルが付けられた文では、パターン変数iは初期化されていません:

Object o = "Hello";
switch (o) {
    case String s:
        System.out.println("String: " + s );  // No break!
    case Integer i:
        System.out.println(i + 1);            // Error! Can be reached
                                              // without matching the
                                              // pattern `Integer i`
    default:
}

switchラベル文グループで構成されるswitchブロックでは、複数のラベルを文グループに適用できます。2番目の条件は、別のラベルのパターン変数を初期化せずに、あるラベルに基づいて文グループが実行されないようにします。次に例を示します。

Object o = "Hello World";
switch (o) {
    case String s:
    case Integer i:
        System.out.println(i + 1);  // Error! Can be reached
                                    // without matching the
                                    // pattern `Integer i`
    default:
}
Object obj = null;
switch (obj) {
    case null:
    case String s:
        System.out.println(s);      // Error! Can be reached
                                    // without matching the
                                    // pattern `String s`
    default:
}

これらの条件は両方とも、caseパターンがパターン変数を宣言している場合にのみ適用されます。一方、次の例は問題ありません:

record R() {}
record S() {}
Object o = "Hello World";
switch (o) {
    case String s:
        System.out.println(s);      // No break
    case R():                       // No pattern variables declared
        System.out.println("It's either an R or a string");
        break;
    default:
}
Object ob = new R();
switch (ob) {
    case R():
    case S():                       // Multiple case labels
        System.out.println("Either R or an S");
        break;
    default:
}
Object obj = null;
switch (obj) {
    case null:
    case R():                       // Multiple case labels
        System.out.println("Either null or an R");
        break;
    default:
}

14.11.1.1 網羅的なSwitchブロック

次のケースのいずれかが当てはまる場合、switch式またはswitch文のswitchブロックは、セレクタ式eについて網羅的です:

• switchブロックに関連付けられたdefaultラベルがある。

• switchブロックに関連付けられたcase null, defaultラベルがある。

• switchブロックに関連付けられている、ガードされていないcaseラベル(総称してcase要素)に示されるすべてのcase定数とcaseパターンを含むセットが空ではなく、セレクタ式eの型をカバーしている。

case要素のセットPCEは、次のいずれかの場合に型Tをカバーします:

• PCEは、TとUが同じイレイジャを持つ型Uをカバーする。

• PCEには、Tに対して無条件(14.30.3)のパターンが含まれている。

• Tは上限がBの型変数であり、PCEはBをカバーしている。

• Tは交差型T₁& ... &T_nであり、PCEは型T_i (1≤ i ≤ n)のいずれかのT_iをカバーしている。

• 型Tはenumクラス型Eであり、PCEにはEの列挙定数のすべての名前が含まれている。

  defaultラベルは許容されますが、すべての列挙定数の名前がcase定数として示される場合は必須ではありません。次に例を示します。

  enum E { F, G, H }
  static int testEnumExhaustive(E e) {
    return switch(e) {
        case F -> 0;
        case G -> 1;
        case H -> 2;    // No default required!
    };
  }

• 型Tは、abstract sealedクラスまたはsealedインタフェースCを指名していて、Cの許可されるすべての直接のサブクラスまたはサブインタフェースDについて、次の2つの条件のいずれかが成立する場合:

  1. Dという名前で、Tのサブタイプである型は存在しない。または

  2. 型UはDという名前のTのサブタイプであり、PCEはUをカバーしている。

  defaultラベルは許可されますが、abstract sealedクラスまたはsealedインタフェースの許容された直接のサブクラスおよびサブインタフェースのすべてをswitchブロックが網羅する場合は不要です。次に例を示します。

  sealed interface I permits A, B, C {}
  final class A   implements I {}
  final class B   implements I {}
  record C(int j) implements I {}  // Implicitly final
  
  static int testExhaustive1(I i) {
      return switch(i) {
          case A a -> 0;
          case B b -> 1;
          case C c -> 2;           // No default required!
      };
  }

  switchブロックには、型A、BおよびCのすべての値と一致するcaseパターンが含まれていて、それ以外の型Iのインスタンスは許可されていないため、このswitchブロックは網羅的です。

  許容された直接サブクラスまたはサブインタフェースは、汎用sealedスーパークラスまたはスーパーインタフェースの特定のパラメータ化のみを拡張できるという事実は、switchブロックが網羅的であるかどうかを判断するときには考慮が不要な場合があることを意味します。次に例を示します。

  sealed interface J<X> permits D, E {}
  final class D<Y> implements J<String> {}
  final class E<X> implements J<X> {}
  
  static int testExhaustive2(J<Integer> ji) {
      return switch(ji) {          // Exhaustive!
          case E<Integer> e -> 42;
      };
  }

  このセレクタ式には型J<Integer>があり、jiの値がDのインスタンスである可能性はないため、許可された直接のサブクラスDについて考慮する必要はありません。

• 型TはレコードクラスRという名前で、PCEにはRという名前の型を持つレコード・パターンpが含まれていて、型UのRのすべてのレコード・コンポーネント(存在する場合)について、対応するコンポーネント・パターンpを含むシングルトン・セットがUをカバーしている。

  対応するレコード・コンポーネントの型をすべてカバーするコンポーネント・パターンは、レコード型をカバーするとみなされます。次に例を示します。

  record Test<X>(Object o, X x){}
      static int testExhaustiveRecordPattern(Test<String> r) {
      return switch(r) {                           // Exhaustive!
          case Test<String>(Object o, String s) -> 0;
      };
  }

• PCEはセットQQEに書き換え、QQEはTをカバーします。

  case要素のセットPCEは、PCEのサブセットがパターンpに削減され、QQEがパターンpとともにPCEの残りの要素から構成される場合、セットQQEに書き換えられます。

  次のいずれかが成立する場合は、空でないパターンのセットRPが単一のパターンrpに削減されます:

  • RPは型Uをカバーし、rpは型Uの型パターンである。

  • RPは、すべての型がk (k≥1)個のコンポーネントを持つ同じレコード・クラスRに消去される型のレコード・パターンで構成されていて、他のコンポーネントc_i (1≤i≤k, i≠r)ごとに、コンポーネントc_iに対応するレコード・パターンからのコンポーネント・パターンを含んでいるセットが単一のパターンq_iと等価であり、コンポーネントc_rに対応するレコード・パターンからのコンポーネント・パターンを含んでいるセットが単一のパターンqに削減され、rpがパターンq₁, ..., q_r-1, q, q_r+1, ..., q_kから構成されるパターン・リストを持つ型Rのレコード・パターンであるようなRの識別されたコンポーネントc_r (1≤r≤k)が存在する。

    次のいずれかが成立する場合、空でないパターンのセットEPは単一のパターンepと等価です:

    • EPは型がすべて同じイレイジャTを持つ型パターンで構成されていて、epは型Tの型パターンである。

    • EPはk (k≥1)個のコンポーネントを持つ同じレコード・クラスRにすべて消去される型を持つレコード・パターンで構成されていて、それぞれのレコード・コンポーネントについては、レコード・パターンからの対応するコンポーネント・パターンを含んでいるセットが単一のパターンq_j (1≤j≤k)と等価であり、epがコンポーネント・パターンq₁,...q_kで構成されるコンポーネント・パターン・リストを持つ型Rレコード・パターンである。

通常、レコード・パターンはレコード型の値のサブセットにのみ一致します。ただし、switchブロック内の複数のレコード・パターンを組み合せて、実際にレコード型のすべての値に一致させることができます。次に例を示します。

sealed interface I permits A, B, C {}
final class A   implements I {}
final class B   implements I {}
record C(int j) implements I {}  // Implicitly final
record Box(I i) {}

int testExhaustiveRecordPatterns(Box b) {
    return switch (b) {     // Exhaustive!
        case Box(A a) -> 0;
        case Box(B b) -> 1;
        case Box(C c) -> 2;
    };
}

このswitchブロックが網羅的かどうかを判断するには、レコード・パターンの組合せを分析する必要があります。レコード・パターンBox(I i)を含むセットは型Boxをカバーするため、パターンBox(A a)、Box(B b)およびBox(C c)を含むセットは、パターンBox(I i)を含むセットに書き換えることができます。これは、パターンA a、B b、C cを含むセットがパターンI iに削減されるため(同じセットが型Iをカバーするため)、パターンBox(A a)、Box(B b)、Box(C c)を含むセットがパターンBox(I i)に削減されます。

ただし、レコード・パターンのセットの書き換えは必ずしも単純ではありません。次に例を示します。

record IPair(I i, I j){}

int testNonExhaustiveRecordPatterns(IPair p) {
    return switch (p) {     // Not Exhaustive!
        case IPair(A a, A a) -> 0;
        case IPair(B b, B b) -> 1;
        case IPair(C c, C c) -> 2;
    };
}

前述の例のロジックを適用して、パターンIPair(A a, A a)、IPair(B b, B b)、IPair(C c, C c)を含むセットをパターンIPair(I i, I j)を含むセットに書き換えて、switchブロックが型IPairを使い果たすと結論付けたくなります。ただし、これは正しくありません。たとえば、switchブロックには、最初のコンポーネントがA値で、2番目のコンポーネントがB値であるIPair値と一致するラベルが実際にはないためです。あるコンポーネントのレコード・パターンを組み合せることは、その他のコンポーネントの同じ値と一致する場合にのみ有効です。たとえば、3つのレコード・パターンIPair(A a, I i)、IPair(B b, I i)およびIPair(C c, I i)を含むセットは、パターンIPair(I j, I i)に削減できます。

switch文または式は、そのswitchブロックがセレクタ式に対して網羅的である場合、網羅的になります。

14.11.1.2 実行時に適用されるswitchラベルの決定

switch文の実行(14.11.3)およびswitch式の評価(15.28.2)の両方で、switchブロックに関連付けられたswitchラベルがセレクタ式の値に適用されるかどうかを判断する必要があります。これは次のように処理されます。

1. Tが参照型で、もし値がnull参照の場合は、nullリテラルを含むcaseラベルが適用されます。

2. 値がnull参照ではない場合は、その後値に適用されるswitchブロックの最初の(ある場合) caseラベルを次のように決定します:

   • Tが参照型のときに値がnull参照でない場合は、値が最初にボックス化解除変換(5.1.8)の対象になり、定数cがボックス化解除された値と等しい場合、case定数cのあるcaseラベルがCharacter、Byte、Short、またはInteger、Long、Float、DoubleまたはBoolean型の値に適用されます。

     ボックス化解除変換は、ボックス化解除される値がNULL参照にならないことが保証されるため、正常に完了します。

     等価性は、==演算子で定義されます(15.21)。

   • Tがプリミティブ型の場合、case定数がcのあるcaseラベルは、char、byte、short、int、またはlong、float、double、booleanまたはString型の値または列挙型(定数cが値と等しい場合)に適用されます。

     等価性は、整数型およびブール型の場合は==演算子(15.21)および浮動小数点型の場合は表現等価性(java.lang.Double)によって定義されます。ただし値がStringの場合、その場合は等価性はクラスStringのequalsメソッドによって定義されます。

   • caseパターンpを持つcaseラベルが値に適用されることを確認するには、最初に、値がパターンp (14.30.2)に一致するかどうかをチェックします。

     パターン・マッチングが突然完了した場合は、適用されるswitchラベルを判断するプロセスについても同じ理由で突然完了します。

     パターン・マッチングが成功し、caseラベルがガードされていない場合は、このcaseラベルが適用されます。

     パターン・マッチングが成功し、caseラベルがガードされている場合は、ガードが評価されます。その結果がBoolean型の場合は、ボックス化解除変換(5.1.8)の対象になります。

     ガードまたは後続のボックス化解除変換(ある場合)の評価がなんらかの理由で突然完了した場合、適用するswitchラベル・パターンを判断するプロセスは同じ理由で突然完了します。

     それ以外の場合は、その結果の値がtrueのときに、caseラベルが適用されます。

   • caseパターンp₁、...、p_n (n≥1)を持つcaseラベルが値に適用されることを確認するには、値に適用される最初のcaseパターンp_i (1≤i≤n)を見つけます(存在する場合)。

     caseパターンが値に適用されるかどうかを判断するには、まず、値がパターン(14.30.2)に一致するかどうかをチェックします。その場合:

     • パターン・マッチングが突然完了した場合は、適用されるswitchラベルを判断するプロセス全体が同じ理由で突然完了します。

     • パターン・マッチングが成功し、caseラベルがガードされていない場合は、このcaseパターンが適用されます。

     • パターン・マッチングが成功し、caseラベルがガードされている場合は、ガードが評価されます。その結果がBoolean型の場合は、ボックス化解除変換(5.1.8)の対象になります。

       ガードまたは後続のボックス化解除変換(ある場合)の評価がなんらかの理由で突然完了した場合、適用するswitchラベル・パターンを判断するプロセス全体が同じ理由で突然完了します。

       それ以外の場合は、その結果の値がtrueのときに、caseパターンが適用されます。

   • case null, defaultラベルはすべての値に適用されます。

3. 値がnull参照ではなく、Tが参照型のときに、ステップ2のルールに従ってcaseラベルが適用されないが、switchブロックに関連付けられたdefaultラベルがある場合は、defaultラベルが適用されます。

単一のcaseラベルには、複数のcase定数を含めることができます。ラベルは、その定数のいずれかがセレクタ式の値と等しい場合、セレクタ式の値に適用されます。たとえば、次のコードでは、enum変数dayがコードに示した列挙定数のいずれかである場合に、caseラベルが適用されます:

switch (day) {
    ...
    case SATURDAY, SUNDAY :
        System.out.println("It's the weekend!");
        break;
    ...
}

caseパターンのあるcaseラベルが適用される場合、これは、パターンに対する値のパターン・マッチング・プロセスが成功したことによるものです(14.30.2)。値がパターンと正常に一致すると、パターン・マッチングのプロセスは、パターンによって宣言されたパターン変数を初期化します。

CおよびC++で、switch文の本体は文(単数および複数)にすることができ、caseラベルをその文で直接含む必要はありません。単純なループを考えてみましょう。

for (i = 0; i < n; ++i) foo();

ここでnは正であると知られています。ダフスデバイスとして知られているトリックは、ループをアンロールするためにCまたはC++で使用できますが、これはJavaプログラミング言語では有効なコードではありません。

int q = (n+7)/8;
switch (n%8) {
    case 0: do { foo();    // Great C hack, Tom,
    case 7:      foo();    // but it's not valid here.
    case 6:      foo();
    case 5:      foo();
    case 4:      foo();
    case 3:      foo();
    case 2:      foo();
    case 1:      foo();
            } while (--q > 0);
}

幸いにも、このトリックは広く認識または使用されてはいないようです。さらに、今日ではあまり必要ではなくなりました。この種のコード変換は、適切に最新式の最適化コンパイラの領域にあります。

14.11.2 switch文のSwitchブロック

switchブロック(14.11.1)の一般的なルールに加えて、switch文のswitchブロックにはさらにルールがあります。

拡張されたswitch文とは、(i)セレクタ式の型がchar、byte、short、int、Character、Byte、Short、Integer、Stringまたは列挙型ではない、または(ii) switchブロックに関連付けられたcaseパターンまたはnullリテラルが存在しているもののことです。

switch文のswitchブロックに対して次のすべてが当てはまる必要があり、そうでない場合はコンパイル時にエラーが発生します:

• 1つのみのdefaultラベルがswitchブロックに関連付けられています。

• switchブロックのすべてのswitchルール式は、文の式です(14.8)。

  switch文は、switchブロックの矢印(->)の右にどの式が出現するか、つまり、どの式をswitchルール式として使用できるかという観点で、switch式と異なります。switch文では、文の式のみをswitchルール式として使用できますが、switch式では、任意の式を使用できます(15.28.1)。

• switch文が拡張switch文の場合、それは網羅的である必要があります(14.11.1.1)。

Java SE 21より前のswitch文(およびswitch式)は、(i)セレクタ式の型が整数型(longを除く)、列挙型またはStringに制限されており、(ii) case nullラベルはサポートされていませんでした。さらに、switch式とは異なり、switch文は網羅的である必要はありませんでした。これは多くの場合、バグの検出を困難にする原因になり、switchラベルは適用されず、switch文は何もしません。次に例を示します。

enum E { A, B, C }
E e = ...;
switch (e) {
   case A -> System.out.println("A");
   case B -> System.out.println("B");
   // No case for C!
}

Java SE 21では、caseパターンのサポートに加えて、前述のswitch文(およびswitch式)の2つの制限が緩和され、(i)任意の参照型のセレクタ式を許可し、(ii)nullリテラルを持つcaseラベルを許可するようになりました。また、Javaプログラミング言語の設計者が、拡張switch文はswitch式と揃える必要があり、網羅的である必要があると決定しました。多くの場合、これは自明的なdefaultラベルの追加によって達成されます。たとえば、次の拡張switch文は網羅的ではありません。

Object o = ...;
switch (o) {    // Error - non-exhaustive switch!
    case String s -> System.out.println("A string!");
}

しかし、それは簡単に網羅的にすることができます。

Object o = ...;
switch (o) {
    case String s -> System.out.println("A string!");
    default -> {}
}

互換性の理由で、拡張されたswitch文ではないswitch文は網羅的である必要はありません。

14.30 パターン

14.30.1 パターンの種類

型パターンは、値がパターンに出現する型のインスタンスであるかどうかをテストするために使用されます。レコード・パターンは、値がレコード・クラス型のインスタンスであるかどうかをテストし、そうである場合は、レコード・コンポーネント値に対してパターン・マッチングを再帰的に実行するために使用されます。

Pattern:

TypePattern

RecordPattern

TypePattern:

LocalVariableDeclaration

RecordPattern:

ReferenceType ( [ComponentPatternList] )

ComponentPatternList:

ComponentPattern {, ComponentPattern }

ComponentPattern:

Pattern

MatchAllPattern

MatchAllPattern:

_

便宜上、ここでは4.3、8.3、8.4.1、および14.4の次のプロダクションを示します。

LocalVariableDeclaration:

{VariableModifier} LocalVariableType VariableDeclaratorList

VariableModifier:

Annotation

final

LocalVariableType:

UnannType

var

VariableDeclaratorList:

VariableDeclarator {, VariableDeclarator}

VariableDeclarator:

VariableDeclaratorId [= VariableInitializer]

VariableDeclaratorId:

Identifier [Dims]

_

Dims:

{Annotation} [ ] {{Annotation} [ ]}

UnannTypeについては、8.3を参照してください。

(1)レコード・パターンのコンポーネント・パターン・リストに直接示されている場合、または(2)レコード・パターンのコンポーネント・パターン・リストに直接示されているレコード・パターンにネストされている場合、パターンはレコード・パターンにネストされます。レコード・パターンにネストされていない場合、パターンは最上位です。

型パターンは、パターン変数として知られる1つのローカル変数を宣言します。宣言に識別子が含まれている場合、これはパターン変数の名前を指定します。それ以外の場合、パターン変数は名前のないパターン変数と呼ばれます。

型パターンで宣言されたローカル変数のルールについては、14.4に規定されています。さらに、次のすべてが当てはまる必要があり、そうでない場合、コンパイル時にエラーが発生します。

• 最上位型パターンのLocalVariableTypeは、任意の参照型(さらに言えば、varではないこと)を示します。

• VariableDeclaratorListは単一のVariableDeclaratorで構成されています。

• VariableDeclaratorにはイニシャライザがありません。

• VariableDeclaratorIdにカッコのペアがありません。

最上位型パターンで宣言されたパターン変数の型は、LocalVariableTypeによって示される参照型です。

ネストされた型パターンで宣言されたパターン変数の型は、次のように決定されます。

• LocalVariableTypeがUnannTypeの場合、パターン変数の型はUnannTypeで示されます

• LocalVariableTypeがvarの場合、型パターンは、レコード・パターンのコンポーネント・パターン・リストに直接示される必要があります。そうしないと、コンパイル時にエラーが発生します。

  Rをレコード・パターンの型とし、TをRの対応するコンポーネント・フィールドの型(8.10.3)とします。パターン変数の型はTで指定しているすべての合成型変数に関するTの上方投影です。

  次のレコード・クラスの宣言について考えます:

  record R<T>(ArrayList<T> a){}

  レコード・パターンR<String>(var b)の場合、パターン変数bの型はArrayList<String>です。

型パターンは、型Rのレコード・パターンのコンポーネント・パターン・リストに直接示される場合、null一致と呼ばれます。ここで、Rの対応するレコード・コンポーネントは型U、Uは参照型であり、型パターンは型Uに対して無条件です(14.30.3)。

この型パターンのコンパイル時プロパティは、パターン・マッチング(14.30.2)の実行時プロセスで使用されるため、実行時に使用する型パターンに関連付けられています。

レコード・パターンは、ReferenceTypeと、コンポーネント・パターンを含むコンポーネント・パターン・リスト(ある場合)で構成されます。ReferenceTypeがレコード・クラス・タイプ(8.10)でない場合、コンパイル時エラーが発生します。

ReferenceTypeがRAW型である場合、18.5.5で説明されているように、レコード・パターンの型が推論されます。レコード・パターンに対して型を推論できない場合、コンパイル時にエラーが発生します。

ReferenceType (またはその一部)に注釈が付けられていると、コンパイル時にエラーが発生します。

Javaプログラミング言語の将来のバージョンでは、この注釈に対する制限が解除される可能性があります。

それ以外の場合、レコード・パターンの型はReferenceTypeです。

レコード・パターンのコンポーネント・パターン・リストの長さは、ReferenceTypeで指定されたレコード・クラスの宣言内のレコード・コンポーネント・リストと同じ長さである必要があります。そうでない場合はコンパイル時にエラーが発生します。

レコード・パターンでは、パターン変数自体を直接宣言しませんが、コンポーネント・パターン・リスト内のパターン変数の宣言を含めることができます。

レコード・パターンに同じ名前のパターン変数の宣言が複数含まれていると、コンパイル時にエラーが発生します。

match-allパターンは、パターン変数を宣言しない特殊なパターンであり、レコード・パターンrのコンポーネント・パターン・リストにのみ直接示すことができます。

Rをレコード・パターンrの型とし、TをRの対応するコンポーネント・フィールドの型(8.10.3)とします。match-allパターンの型は、Tで指定しているすべての合成型変数に関するTの上方投影です。

match-allパターンは、名前なしパターン変数を宣言し、LocalVariableTypeがvarであるネストした型パターンと同等であることがわかります。

14.30.2 パターン・マッチング

パターン・マッチングは、実行時にパターンに対して値をテストするプロセスです。パターン・マッチングは、文実行(14.1)および式評価(15.1)とは異なります。値がパターンに正常に一致する場合、パターン・マッチング・プロセスが、パターンによって宣言されたすべてのパターン変数(ある場合)を初期化します。

パターン・マッチングのプロセスには、式の評価または文の実行が関与する場合があります。したがって、式の評価または文の実行が突然完了する場合は、パターン・マッチングが突然完了すると表現されます。突然の完了には常に理由が関連付けられており、それは常に、指定された値を持つthrowです。パターン・マッチングは、突然完了しない場合、正常に完了すると言い表されます。

値がパターンと一致するかどうかを決定するルールおよびパターン変数を初期化するルールは、次のとおりです。

• 型パターンがnull一致の場合(14.30.1)、null参照は型パターンに一致し、それ以外の場合は一致しません。

  null参照が一致する場合は、型パターンによって宣言されたパターン変数がnull参照に初期化されます。

  null参照が一致しない場合、型パターンによって宣言されたパターン変数は初期化されません。

• null参照でない値vは、vがターゲット型Tに対して正確(5.7.1)であるいずれかのテスト変換(5.7)によってClassCastExceptionの発生なしに変換可能なできる場合に、型Tの型パターンと一致します。それ以外の場合は、一致しません。

  vが一致する場合、型パターンによって宣言されたパターン変数はvに初期化されます。

  vが一致しない場合、型パターンによって宣言されたパターン変数は初期化されません。

• null参照は、レコード・パターンと一致しません。

  この場合、レコード・パターンに含まれる宣言に示される任意のパターン変数は初期化されません。

• null参照でない値vは、(i) vが、ClassCastExceptionを発生させることなく、正確な(5.7.1)テスト変換(5.7)によってターゲット型Rに変換できる場合と、(ii) vの各レコード・コンポーネントがLの対応するコンポーネント・パターンと一致する場合に、型Rおよびコンポーネント・パターン・リストLのレコード・パターンに一致し、それ以外の場合は一致しません。

  vの各レコード・コンポーネントは、そのコンポーネントに対応するvのアクセサ・メソッドを呼び出すことによって決定されます。アクセサ・メソッドの呼出しの実行が理由Sのために突然完了した場合、パターン・マッチングは原因SによるMatchExceptionをスローすることで突然完了します。

  レコード・パターンのコンポーネント・パターン・リストに示されるパターンで宣言されたパターン変数は、リスト内のすべてのパターンが一致する場合にのみ初期化されます。

• すべての値はmatch-allパターンと一致します。

14.30.3 パターンのプロパティ

次のいずれかの規則が適用される場合、パターンpは型Tで適用可能であると表現されます。

• 型Tから型Uへのテスト変換(5.7)がある場合、参照型Uのパターン変数を宣言する型パターンは、参照型Tに適用できます。

• プリミティブ型Pのパターン変数を宣言する型パターンは、型Pで適用可能です。

• 型Rとパターン・リストLのレコード・パターンは、(i)型Tから型Rへのテスト変換(5.7)があり、(ii) Lに現れるすべてのコンポーネント・パターンp (ある場合)について、pがRの対応するコンポーネント・フィールドの型で適用可能な場合に、型Tで適用できます。

• match-allパターンは、すべての型Tに適用できます。

パターンpは、型Tのすべての値がpと一致することがある一致する場合に型Tに対して無条件と表現されます。そのため、パターン・マッチングのテストの側面は排除できますそのため、実行時のパターン・マッチングに処置は不要になります。次のように定義されます:

• 参照型Sのパターン変数を宣言する型パターンはTのイレイジャがSのイレイジャのサブタイプである|T|から|S|への無条件に正確(5.7.2)なテスト変換が存在する場合に、参照型Tに対して無条件です。

• match-allパターンは、すべての型Tに対して無条件です。

null参照はレコード・パターンと一致しないため、無条件であるレコード・パターンはありません。

qと一致するすべての値がpとも一致する場合、パターンpは別のパターンqよりも優先されると表現され、次のように定義されます。

• パターンpは、pがTに対して無条件の場合、型Tのパターン変数を宣言する型パターンよりも優先されます。

• パターンpは、pがRに対して無条件である場合、型Rのレコード・パターンよりも優先されます。

• (i) RとSが同じレコード・クラスを指定し、(ii) Lの各コンポーネント・パターンが対応するMのコンポーネント・パターンを優先する場合、型Rでパターン・リストLのレコード・パターンは、型Sでパターン・リストMの別のレコード・パターンよりも優先されます。

• パターンpは、pがTに対して無条件である場合、型Tのすべての一致するパターンよりも優先されます。

第15章: 式

15.5 式と実行時のチェック

式の型がプリミティブ型の場合、式の値は同じプリミティブ型になります。

式の型が参照型の場合、参照されるオブジェクトのクラスや、その値がnullではなくオブジェクトへの参照であるかどうかは、コンパイル時にはわからないことがあります。

Javaプログラミング言語には、参照されるオブジェクトの実際のクラスまたはプリミティブ型の値が、式の型からは推論できない方法でプログラムの実行に影響を与える場所がいくつかあります。パラメータは次のとおりです。

• メソッドの呼出し(15.12)。呼出しo.m(...)に使用される特定のメソッドは、型がoのクラスまたはインタフェースの一部であるメソッドに基づいて選択されます。インスタンス・メソッドの場合、サブクラスが親クラスですでに宣言されている特定のメソッドをオーバーライドして、このオーバーライド・メソッドが呼び出されることがあるため、oの実行時の値によって参照されるオブジェクトのクラスが加わります。(オーバーライド・メソッドは、元のオーバーライドされたmメソッドをさらに呼び出すかどうかを選択できます。)

• instanceof演算子(15.20.2)。型が参照型の式は、a)式の実行時の値で参照されるクラスまたはb)式の値のプリミティブ型が、別の参照型に変換される可能性があるかどうかを調べるためにinstanceofを使用してテストできます。

• キャスト(15.16)。オペランド式の実行時の値によって参照されるオブジェクトのクラスは、キャスト演算子で指定された型と互換性がないことがあります。参照型の場合、実行時に決定された参照オブジェクトのクラスをターゲット型に変換できない場合に、例外をスローする実行時のチェックが必要になることがあります。

• 参照型(10.5、15.13、15.26.1)の配列コンポーネントへの割当て。型チェック・ルールでは、SがTのサブタイプである場合に、配列型S[]をT[]のサブタイプとして処理できますが、これには、キャストについて実行されるチェックと同様に、配列コンポーネントへの割当てについて実行時のチェックが必要です。

• 例外処理(14.20)。例外は、スローされた例外オブジェクトのクラスがcatch句の仮パラメータの型であるinstanceofの場合にのみcatch句で捕捉されます。

オブジェクトのクラスが静的に認識されていない状況では、実行時の型エラーが発生する可能性があります。

また、実行時に静的に認識されいる型が正確でない場合もあります。そのような状況は、コンパイル時に無検査の警告が発生するプログラムで発生する可能性があります。このような警告は、静的に安全が保証できない操作と、非具象化可能型(4.7)が含まれるためにすぐに動的チェックの対象にできない操作に応じて提示されます。その結果として、プログラムの実行の後半で動的チェックを行うと、不整合が検出されて実行時の型エラーが発生する可能性があります。

実行時の型エラーは、次の状況でのみ発生する可能性があります:

• オペランド式の値によって参照されるオブジェクトの実際のクラスが、キャスト演算子(5.5、15.16)で指定されたターゲット型と互換性がないときのキャスト。この場合は、ClassCastExceptionがスローされます。

• 非具象化可能型(4.7)に対する操作の妥当性を保証するために導入される、自動的に生成されたキャスト。

• 割り当てられる値によって参照されるオブジェクトの実際のクラスが、配列の実際の実行時コンポーネント型(10.5、15.13、15.26.1)と互換性がない場合の参照型の配列コンポーネントへの割当て。この場合は、ArrayStoreExceptionがスローされます。

• try文(14.20)のcatch句で例外が捕捉されないとき。この場合は、例外を検出した制御スレッドは、最初に捕捉されない例外のハンドラ(11.3)を呼び出して終了します。

15.16 Cast式

キャスト式は、実行時にある数値型の値を別の数値型の同様の値に変換します。または、コンパイル時に式の型がbooleanであることを確認します。または、実行時に参照値が指定された参照型または参照型のリストと互換性のあるクラスを持つオブジェクトを指しているか、プリミティブ型の値を実装するオブジェクトを指しているかをチェックします。

CastExpression:

( PrimitiveType ) UnaryExpression

( ReferenceType {AdditionalBound} ) UnaryExpressionNotPlusMinus

( ReferenceType {AdditionalBound} ) LambdaExpression #

便宜上、ここでは[4.4]の次のプロダクションを示します:

AdditionalBound:

& InterfaceType

括弧と括弧内に含まれる型または型のリストは、キャスト演算子と呼ばれることもあります。

キャスト演算子に型のリストが含まれている(つまり、ReferenceTypeの後に1つ以上のAdditionalBound項が続く)場合は、次のすべてに当てはまる必要があります。それ以外の場合は、コンパイル時にエラーが発生します:

• ReferenceTypeは、クラスまたはインタフェース型を示している必要があります。

• リストされているすべての型のイレイジャ(4.6)は、ペア単位で異なっている必要があります。

• リストされた2つの型は、同じ汎用インタフェースの異なるパラメータ化のサブタイプにすることはできません。

キャスト式によって導入されたキャスト・コンテキストのターゲット型(5.5)は、キャスト演算子に示されるPrimitiveTypeまたはReferenceType (その後にAdditionalBound項が続いていない場合)か、キャスト演算子に示されるReferenceTypeとAdditionalBound項が表す交差型です。

キャスト式の型は、このターゲット型に取得変換(5.1.10)を適用した結果です。

キャストは、ラムダ式またはメソッド参照式に特定のターゲット型を明示的に"タグ付け"するために使用できます。適度の柔軟性を提供するために、交差が関数インタフェース(9.8)を導入する場合、ターゲット型は交差型を示す型のリストにすることもできます。

キャスト式の結果は、オペランド式を評価した結果が変数であっても、変数ではなく値になります。

キャスト演算子で指定されたターゲット型へのキャスト変換(5.5)ではオペランドのコンパイル時の型が変換できない場合は、コンパイル時にエラーが発生します。

それ以外の場合は、キャスト演算子で指定されたターゲット型へのキャスト変換によって、実行時にオペランド値が変換されます(必要な場合)。

実行時にキャストが許容されない場合は、ClassCastExceptionがスローされます。

一部のキャストでは、コンパイル時にエラーが発生します。一部のキャストは、実行時に常に正しいことをコンパイル時に証明できます。たとえば、クラス型の値をそのスーパークラスの型に変換することは常に正しく、このようなキャストでは実行時に特別な処置が不要になります。最後に、一部のキャストは、コンパイル時に常に正しいか、常に正しくないかを証明できません。そのようなキャストでは、実行時にテストが必要になります。詳細は、5.5を参照してください。

15.20 関係演算子

15.20.2 instanceof演算子

instanceof式は型比較またはパターン・マッチングのいずれかを実行できます。

InstanceofExpression:

RelationalExpression instanceof ReferenceType型

RelationalExpression instanceof Pattern

instanceofキーワードの右側のオペランドがReferenceTypeTypeの場合、instanceofキーワードは型比較演算子です。

instanceofキーワードの右側のオペランドがPatternである場合、instanceofキーワードはパターン一致演算子です。

式RelationalExpressionの型は、参照型、プリミティブ型またはNULL型を指定できます。

次のルールは、instanceofが型比較演算子の場合に適用されます。

• 式RelationalExpressionの型は、参照型またはnull型である必要があり、そうでない場合、コンパイル時にエラーが発生します。

• RelationalExpressionの型は、ReferenceTypeとのキャスト互換可能性をチェックする必要があります(5.5)型へのテスト変換で変換可能になる必要があります(5.7)。それ以外の場合は、コンパイル時にエラーが発生します。

• 実行時に型比較演算子の結果は次のように決定されます。

  • Typeが参照型でRelationalExpressionの値がnull参照(4.1)の場合、結果はfalseになります。

  • Typeが参照型でRelationalExpressionの値がnull参照ではないとき、またはTypeがプリミティブ型のとき、値をClassCastExceptionを発生させずにReferenceTypeにキャスト正確なテスト変換(5.7.1)によってTypeに変換できる場合、結果はtrueになります。それ以外の場合は、falseになります。

次のルールは、instanceofがパターン一致演算子の場合に適用されます。

• 式RelationalExpressionの型は、参照型またはnull型である必要があり、そうでない場合、コンパイル時にエラーが発生します。

• パターンは、式RelationalExpressionの型(14.30.3)で適用可能である必要があります。それ以外の場合は、コンパイル時にエラーが発生します。

• 実行時に、パターン一致演算子の結果は次のように決定されます:

  • Typeが参照型でRelationalExpressionの値がnull参照の場合、結果はfalseになります。

  • Typeが参照型で、RelationalExpressionの値がNULL参照でないとき、またはTypeがプリミティブ型のとき、値がPattern (14.30.2)と一致する場合、結果はtrueになり、それ以外の場合はfalseになります。

    trueの結果の悪影響は、パターンで宣言されたすべてのパターン変数(ある場合)が初期化されることです。

class Point   { int x, y; }
class Element { int atomicNumber; }
class Test {
    public static void main(String[] args) {
        Point   p = new Point();
        Element e = new Element();
        if (e instanceof Point) {  // compile-time error
            System.out.println("I get your point!");
            p = (Point)e;  // compile-time error
        }
    }
}

class Point extends Element { int x, y; }

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

class Test2 {
    public static void main(String[] args) {
        List<Integer> x = new ArrayList<Integer>();

        if (x instanceof ArrayList<Integer>) {  // OK
            System.out.println("ArrayList of Integers");
        }
        if (x instanceof ArrayList<String>) {  // error
            System.out.println("ArrayList of Strings");
        }
        if (x instanceof ArrayList<Object>) {  // error
            System.out.println("ArrayList of Objects");
        }
    }
}

15.28 switch式

switch式は、式の値に応じて、いくつかの文または式の1つに制御を転送します。その式のすべての可能な値が処理される必要があり、いくつかの文または式のすべてがswitch式の結果の値を生成する必要があります。

SwitchExpression:

switch ( Expression ) SwitchBlock

Expressionはセレクタ式と呼ばれます。セレクタ式の型は、char、byte、short、intまたは参照型である必要があります。それ以外の場合は、どの型でもコンパイル時にエラーが発生します。

switch式およびswitch文(14.11)の両方の本体は、switchブロックと呼ばれます。switch式またはswitch文のどちらに出現するかに関係なく、すべてのswitchブロックに適用される一般的なルールは、14.11.1に示されています。便宜上、ここでは14.11.1の次のプロダクションを示します。

SwitchBlock:

{ SwitchRule {SwitchRule} }

{ {SwitchBlockStatementGroup} {SwitchLabel :} }

SwitchRule:

SwitchLabel -> Expression ;

SwitchLabel -> Block

SwitchLabel -> ThrowStatement

SwitchBlockStatementGroup:

SwitchLabel : {SwitchLabel :} BlockStatements

SwitchLabel:

case CaseConstant {, CaseConstant}

case null [, default]

case CasePattern {, CasePattern} [Guard]

default

CaseConstant:

ConditionalExpression

CasePattern:

Pattern

Guard:

when Expression

第19章: 構文

この章では、第4章、第6章から第10章、第14章、第15章に示した構文文法と、第3章の字句文法の主要部分を、2.4の表記法を使用して繰り返します。