第15章 式

バイナリ演算子の左側のオペランドは、右側のオペランドのどの部分も評価される前に完全に評価されるようである。

演算子が複合代入演算子(§15.26.2)の場合、左側のオペランドの評価には、左側のオペランドが示す変数を記憶することと、暗黙のバイナリ演算で使用する変数の値をフェッチおよび保存することの両方が含まれます。

バイナリ演算子の左側のオペランドの評価が突然完了した場合、右側のオペランドの一部は評価されていないように見えます。

class Test1 {
    public static void main(String[] args) {
        int i = 2;
        int j = (i=3) * i;
        System.out.println(j);
    }
}

9

class Test2 {
    public static void main(String[] args) {
        int a = 9;
        a += (a = 3);  // first example
        System.out.println(a);
        int b = 9;
        b = b + (b = 3);  // second example
        System.out.println(b);
    }
}

12
12

class Test3 {
    public static void main(String[] args) {
        int j = 1;
        try {
            int i = forgetIt() / (j = 2);
        } catch (Exception e) {
            System.out.println(e);
            System.out.println("Now j = " + j);
        }
    }
    static int forgetIt() throws Exception {
        throw new Exception("I'm outta here!");
    }
}

java.lang.Exception: I'm outta here!
Now j = 1

Javaプログラミング言語では、演算子のすべてのオペランド(条件演算子&&、||および? :を除く)が、操作自体の任意の部分が実行される前に完全に評価されるように見えます。

2項演算子が整数の除算/ (§15.17.2)または整数の剰余% (§15.17.3)である場合、その実行はArithmeticExceptionを発生させる可能性がありますが、この例外は、2項演算子の両方のオペランドが評価され、これらの評価が正常に完了した場合にのみスローされます。

class Test {
    public static void main(String[] args) {
        int divisor = 0;
        try {
            int i = 1 / (divisor * loseBig());
        } catch (Exception e) {
            System.out.println(e);
        }
    }
    static int loseBig() throws Exception {
        throw new Exception("Shuffle off to Buffalo!");
    }
}

java.lang.Exception: Shuffle off to Buffalo!

java.lang.ArithmeticException: / by zero

Javaプログラミング言語は、カッコで明示的に示され、演算子の優先順位によって暗黙的に示される評価の順序を尊重します。

Javaプログラミング言語の実装では、代入法などの代数的アイデンティティを利用して式をより便利な計算順序に書き換えることはできません。ただし、置換式が次と同等であることが証明される場合を除きます。複数のスレッド(§17 (Threads and Locks)のスレッド実行モデルを使用)が存在する場合でも、関連する可能性のあるすべての計算値について、値とその観察可能な副作用。

浮動小数点計算の場合、このルールは無限大および非数(NaN)値にも適用されます。

たとえば、xまたはyのいずれかがNaNの場合、または両方がNaNの場合、これらの式は異なる値を持つため、!(x<y)をx>=yとしてリライトすることはできません。

具体的には、数学的に連想的であるように見える浮動小数点計算は、計算的に連想的である可能性はほとんどありません。 このような計算は、素直に並べ替えることはできません。

たとえば、Javaコンパイラで4.0*x*0.5を2.0*xとしてリライトするのは正しくありません。ここで丸めが発生しないときは、最初の式が無限大(オーバーフローのため)を生成するが、2番目の式が有限の結果を生成するxの値が大きくなります。

class Test {
    public static void main(String[] args) {
        double d = 8E307;
        System.out.println(4.0 * d * 0.5);
        System.out.println(2.0 * d);
    }
}

Infinity
1.6E308

対照的に、整数の加算と乗算は、Javaプログラミング言語では実質的に連想的です。

たとえば、a、bおよびcがローカル変数であるa+b+c(この簡略化の前提により、複数のスレッドおよびvolatile変数に関する問題が回避されます)は、(a+b)+cまたはa+(b+c)として評価されるかどうかに関係なく、常に同じ回答を生成します。コードの近くに式b+cが存在する場合、スマートJavaコンパイラは、この共通部分正規表現を使用できます。

メソッドまたはコンストラクタの呼出しまたはクラス・インスタンス作成式では、引数式はカンマで区切ってカッコ内に記述できます。 各引数式は、右側の引数式の任意の部分の前に完全に評価されます。

引数式の評価が突然完了した場合、その右側の引数式のどの部分も評価されていないように見えます。

class Test1 {
    public static void main(String[] args) {
        String s = "going, ";
        print3(s, s, s = "gone");
    }
    static void print3(String a, String b, String c) {
        System.out.println(a + b + c);
    }
}

going, going, gone

class Test2 {
    static int id;
    public static void main(String[] args) {
        try {
            test(id = 1, oops(), id = 3);
        } catch (Exception e) {
            System.out.println(e + ", id=" + id);
        }
    }
    static int test(int a, int b, int c) {
        return a + b + c;
    }
    static int oops() throws Exception {
        throw new Exception("oops");
    }
}

java.lang.Exception: oops, id=1

一部の式の評価順序は、これらの一般的なルールでは完全にはカバーされません。これらの式は、指定が必要なときに例外的な条件を発生させる可能性があるためです。 次の種類の式については、評価順序の詳細な説明を参照してください。

リテラル(§3.10)は、変化のない固定値を示します。

ここでは、便宜上、§3.10の次の本番環境を示します。

リテラルの型は次のように決定されます。

字句リテラルの評価は、常に正常に完了します。

クラス・リテラルは、クラス、インタフェース、配列型またはプリミティブ型の名前、または擬似型void、その後に.およびトークンclassが続く式です。

TypeNameは、アクセス可能なクラスまたはインタフェース(§6.6)を示す必要があります。 TypeNameがアクセスできないクラスまたはインタフェースを示している場合、または型変数を示している場合は、コンパイル時にエラーが発生します。

C.classの型(Cはクラス、インタフェースまたは配列型の名前(§4.3)は、Class<C>です。

p.classの型(pはプリミティブ型の名前(§4.2))、Class<B>(Bはボクシング変換後の型pの式のタイプ(§5.1.7)です。

void.class (§8.4.5)の型は、Class<Void>です。

クラス・リテラルは、現在のインスタンスのクラスの定義クラス・ローダー(§12.2)で定義されているように、名前付きクラス、インタフェース、配列型またはプリミティブ型(またはvoid)のClassオブジェクトに評価されます。

キーワードthisは、次のコンテキストで式として使用できます。

式として使用する場合、キーワードthisは、インスタンス・メソッドが呼び出されたオブジェクト(§15.12)または構築されるオブジェクトへの参照である値を示します。 ラムダ本体でthisで示される値(§15.27.2)は、周囲のコンテキストでthisで示される値と同じです。

キーワードthisは、コンストラクタ呼出し(§8.8.7.1)でも使用され、メソッドまたはコンストラクタの受信者パラメータ(§8.4)を示します。

this式が静的コンテキスト(§8.1.3)で発生した場合、コンパイル時にエラーが発生します。

Cを、this式の最も内側の包含クラスまたはインタフェース宣言にします。

this式がCの早期構成コンテキスト(§8.8.7)で発生した場合、フィールド・アクセス式の修飾子(§15.11)として表示されないかぎり、コンパイル時にエラーが発生します。単純代入式の左側のオペランド(§15.26)および単純代入式は、Cの初期構成コンテキストに含まれるラムダ式または内部クラス宣言には含まれません。

Cが汎用で、型パラメータF₁、...F_nの場合、thisの型はC<F₁、...、F_n>です。 それ以外の場合、thisの型はCです。

実行時に、参照される実際のオブジェクトのクラスは、CまたはCのサブクラス(§8.1.5)です。

class IntVector {
    int[] v;
    boolean equals(IntVector other) {
        if (this == other)
            return true;
        if (v.length != other.v.length)
            return false;
        for (int i = 0; i < v.length; i++) {
            if (v[i] != other.v[i]) return false;
        }
        return true;
    }
}

字句的に囲むインスタンス(§8.1.3)は、キーワードthisを明示的に修飾することで参照できます。

nは、TypeNameがnの字句で囲まれたクラスまたはインタフェース宣言を示す整数で、その宣言が修飾されたthis式をすぐに包含します。

修飾されたthis式TypeName.thisの値は、thisのn番目の字句で囲まれたインスタンスです。

TypeNameが、型パラメータF₁、...F_nを持つ汎用クラスを示している場合、修飾されたthis式の型はTypeName<F₁、...、F_n>です。 それ以外の場合、修飾されたthis式の型はTypeNameです。

修飾this式が静的コンテキスト(§8.1.3)で発生した場合、コンパイル時にエラーが発生します。

TypeNameで指定されたクラスの初期構成コンテキスト(§8.8.7)で修飾されたthis式が発生した場合、その式がフィールド・アクセス式の修飾子(§15.11)として表示されないかぎり、コンパイル時にエラーが発生します。単純代入式の左側のオペランド(§15.26)であり、単純代入式は、TypeNameで指定されたクラスの初期構成コンテキストに含まれるラムダ式または内部クラス宣言には含まれません。

修飾されたthis式をすぐに包含する宣言を持つクラスまたはインタフェースが、TypeNameまたはTypeName自体の内部クラスでない場合、コンパイル時にエラーが発生します。

カッコ化された式は、含まれる式の型であり、実行時にその値が含まれる式の値であるプライマリ式です。 含まれる式が変数を示す場合、カッコで囲まれた式もその変数を示します。

カッコの使用は評価の順序にのみ影響します。ただし、(-2147483648)および(-9223372036854775808L)は有効ですが、-(2147483648)および-(9223372036854775808L)は不正です。

これは、小数点リテラル2147483648および9223372036854775808Lが単項マイナス演算子(§3.10.1)のオペランドとしてのみ許可されるためです。

特に、式を囲むカッコの有無は、変数が確実に割当てられるかどうか、trueのときに確実に割り当てられるかどうか、falseのときに確実に割り当てられるか、trueのときは絶対に割り当てられないか、falseのときは絶対に割り当てられないか(§16 (Definite Assignment))に影響しません。

ターゲット・タイプT (§5 (Conversions and Contexts))の特定の種類のコンテキストにカッコで囲まれた式が含まれている場合、その含まれる式は、ターゲット・タイプTと同じ種類のコンテキストに類似して表示されます。

含まれる式が多式(§15.2)の場合、カッコで囲まれた式も多式です。 それ以外の場合はスタンドアロン式です。

ポリカッコで囲まれた式は、含まれる式がTと互換性がある場合、ターゲット・タイプTと互換性があります。

ClassOrInterfaceTypeToInstantiateが(<>ではなく)TypeArgumentsで終わる場合、ClassOrInterfaceTypeToInstantiateは整形式のパラメータ化された型(§4.5)を示す必要があります。そうしないと、コンパイル時にエラーが発生します。

ClassOrInterfaceTypeToInstantiateが<>で終了するが、ClassOrInterfaceTypeToInstantiateのIdentifierで示されるクラスまたはインタフェースが汎用でない場合は、コンパイル時にエラーが発生します。

クラス・インスタンス作成式がクラス本文で終了する場合、インスタンス化されるクラスは匿名クラスです。 次に、

クラス・インスタンス作成式で匿名クラスが宣言されていない場合は、次のようになります:

Cをインスタンス化するクラスにし、iを作成中のインスタンスにします。 Cが内部クラスである場合、iは、次のように決定される即時包含インスタンス(§8.1.3)を持つことができます。

Cが匿名クラスで、その直接スーパークラスSが内部クラスである場合、iはSに関してすぐに包含するインスタンスを持つことができ、次のように決定されます。

Cは、インスタンス化対象のクラスであるとします。 Cのインスタンスを作成するには、次のルールによってコンパイル時にCのコンストラクタiが選択されます。

まず、コンストラクタ呼出しの実際の引数が決定します。

次に、Cのコンストラクタと、対応するthrows句および戻り型が決定されます。

クラス・インスタンス作成式の引数が、呼出しタイプ(§15.12.2.6)から導出されたターゲット・タイプと互換性がない場合、コンパイル時にエラーが発生します。

コンパイル時宣言が変数引数の呼出し(§15.12.2.4)によって適用される場合、コンストラクタの呼出しタイプの最後の仮パラメータ型がF_n[]の場合、F_nの消去である型が呼出しの時点でアクセスできない場合、コンパイル時にエラーが発生します。

クラス・インスタンス作成式の型は、前述の定義のとおり、選択されたコンストラクタに対応する戻り型です。

実行時の、クラス・インスタンス作成式の評価は、次のようになります。

まず、クラス・インスタンス作成式が、修飾されたクラス・インスタンス作成式である場合、修飾する1次式が評価されます。 修飾式がnullと評価されると、NullPointerExceptionが生成され、クラス・インスタンス作成式が突然完了します。 修飾する式が突然完了する場合、クラス・インスタンス作成式が同じ理由で突然完了します。

次に、新しいクラス・インスタンスに領域が割り当てられます。 オブジェクトを割り当てるための領域が不足している場合は、OutOfMemoryErrorをスローして、クラス・インスタンス作成式の評価が突然完了します。

新しいオブジェクトには、指定されたクラスとそのすべてのスーパークラスで宣言されたすべてのフィールドの新しいインスタンスが含まれます。 新しいフィールド・インスタンスが作成されるたびに、そのデフォルト値(§4.12.5)に初期化されます。

次に、コンストラクタの実際の引数が左から右に評価されます。 いずれかの引数の評価が突然完了する場合、その右の引数式は評価されず、クラス・インスタンス作成式が同じ理由で突然完了します。

次に、指定されたクラスの選択されたコンストラクタが呼び出されます。 これにより、クラスのスーパークラスごとに少なくとも1つのコンストラクタが呼び出されます。 このプロセスは、明示的なコンストラクタ呼出し(§8.8.7.1)によって指示され、§12.5で詳細に規定されています。

クラス・インスタンス作成式の値は、指定されたクラスの新しく作成されたオブジェクトへの参照です。 式が評価されるたびに、新しいオブジェクトが作成されます。

class List {
    int value;
    List next;
    static List head = new List(0);
    List(int n) { value = n; next = head; head = this; }
}
class Test {
    public static void main(String[] args) {
        int id = 0, oldid = 0;
        try {
            for (;;) {
                ++id;
                new List(oldid = id);
            }
        } catch (Error e) {
            List.head = null;
            System.out.println(e.getClass() + ", " + (oldid==id));
        }
    }
}

class java.lang.OutOfMemoryError, false

匿名クラスは、クラス・インスタンス作成式またはクラス本体で終わるenum定数(§8.9.1)によって暗黙的に宣言されます。

匿名クラスはabstractではありません(§8.1.1.1)。

匿名クラスはsealed (§8.1.1.2)ではないため、直接サブクラスが許可されていません(§8.1.6)。

クラス・インスタンス作成式によって宣言された匿名クラスは、final (§8.1.1.2)ではありません。

enum定数によって宣言される匿名クラスは、常にfinalです。

final以外である匿名クラスは、キャスト、特にキャスト演算子(§5.5)で許可される絞込み参照変換に関連します。 一方、匿名クラスが非finalであるにもかかわらず、匿名クラスのサブクラスを宣言することは不可能であるため(匿名クラスはextends句で指定できません)、サブクラス化には関係ありません。

無名クラスは、常に内部クラス(§8.1.3)です。

ローカル・クラスまたはインタフェース(§14.3)と同様に、匿名クラスはパッケージ、クラスまたはインタフェースのメンバーではありません(§7.1、§8.5)。

クラス・インスタンス作成式によって宣言された匿名クラスの直接スーパークラス型または直接スーパーインタフェース型は、式(§15.9.1)によって指定され、コンストラクタの選択中に型引数が必要に応じて推測されます(§15.9.3)。 直接スーパーインタフェース型が指定されている場合、直接スーパークラス型はObjectです。

enum定数によって宣言される匿名クラスの直接スーパークラス型は、宣言するenumクラスの型です。

クラス・インスタンス作成式または列挙定数ClassBodyは、匿名クラスのフィールド(§8.3)、メソッド(§8.4)、メンバー・クラス(§8.5)、メンバー・インタフェース(§9.1.1.3)、インスタンス・イニシャライザ(§8.6)および静的イニシャライザ(§8.7)を宣言します。 匿名クラスのコンストラクタは、常に暗黙的です(§15.9.5.1)。

ClassBodyを持つクラス・インスタンス作成式で、インスタンス化されるクラスの型引数にダイヤモンド(<>)を使用する場合、ClassBodyで宣言されたすべての非privateメソッドに対して、メソッド宣言に@Override (§9.6.4.4)の注釈が付けられているかのようになります。

<>を使用する場合、推測型引数はプログラマが予想するほどでない可能性があります。 したがって、匿名クラスのスーパータイプは予想どおりではなく、匿名クラスで宣言されたメソッドが意図したとおりにスーパータイプ・メソッドをオーバーライドしない場合があります。 @Overrideで注釈が付けられているようなメソッド(@Overrideで明示的に注釈が付けられていない場合)を処理すると、サイレントに誤ったプログラムを回避できます。

配列作成式は、新しい配列を作成するために使用されます(§10 (Arrays))。

ここでは、便宜上、§4.3の次の本番環境を示します。

配列作成式は、PrimitiveTypeまたはClassOrInterfaceTypeで指定された型の要素を持つ新しい配列であるオブジェクトを作成します。

ClassOrInterfaceTypeが再可能な型(§4.7)を示さない場合、コンパイル時にエラーが発生します。 それ以外の場合、ClassOrInterfaceTypeは、abstractクラス型(§8.1.1.1)またはインタフェース型であっても、任意の名前付き参照型に名前を付けることができます。

前述のルールは、パラメータ化された型に対するすべての型引数がバインドされていないワイルドカードでないかぎり、配列作成式の要素型をパラメータ化された型にできないことを意味します。

DimExpr内の各ディメンション式の型は、整数型に変換可能な型(§5.1.8)である必要があります。そうでない場合、コンパイル時にエラーが発生します。

各ディメンション式は、単項数値プロモーション(§5.6)の対象となります。 プロモートされた型はintである必要があります。そうでないと、コンパイル時にエラーが発生します。

配列作成式の型は、newキーワードとすべてのDimExpr式および配列イニシャライザが削除された配列作成式のコピーで示すことができる配列型です。

new double[3][3][]

double[][][]

実行時には、配列作成式の評価は次のように動作します。

class Test1 {
    public static void main(String[] args) {
        int     i  = 4;
        int[][] ia = new int[i][i=3];
        System.out.println(
            "[" + ia.length + "," + ia[0].length + "]");
    }
}

[4,3]

class Test2 {
    public static void main(String[] args) {
        int[][] a = { { 00, 01 }, { 10, 11 } };
        int i = 99;
        try {
            a[val()][i = 1]++;
        } catch (Exception e) {
            System.out.println(e + ", i=" + i);
        }
    }
    static int val() throws Exception {
        throw new Exception("unimplemented");
    }
}

java.lang.Exception: unimplemented, i=99

float[][] matrix = new float[3][3];

float[][] matrix = new float[3][];
for (int d = 0; d < matrix.length; d++)
    matrix[d] = new float[3];

Age[][][][][] Aquarius = new Age[6][10][8][12][];

Age[][][][][] Aquarius = new Age[6][][][][];
for (int d1 = 0; d1 < Aquarius.length; d1++) {
    Aquarius[d1] = new Age[10][][][];
    for (int d2 = 0; d2 < Aquarius[d1].length; d2++) {
        Aquarius[d1][d2] = new Age[8][][];
        for (int d3 = 0; d3 < Aquarius[d1][d2].length; d3++) {
            Aquarius[d1][d2][d3] = new Age[12][];
        }
    }
}

Age[] Hair = { new Age("quartz"), new Age("topaz") };
Aquarius[1][9][6][9] = Hair;

float[][] triang = new float[100][];
for (int i = 0; i < triang.length; i++)
    triang[i] = new float[i+1];

配列作成式の評価で、作成操作を実行するのに十分なメモリーがないことがわかった場合は、OutOfMemoryErrorがスローされます。 配列作成式に配列イニシャライザがない場合、このチェックは、すべてのディメンション式の評価が正常に完了した後にのみ行われます。 配列作成式に配列イニシャライザが含まれている場合、変数イニシャライザ式の評価中に参照型のオブジェクトが割り当てられるとき、または(ネストされた)配列イニシャライザの値を保持するために配列に領域が割り当てられるときに、OutOfMemoryErrorが発生する可能性があります。

class Test3 {
    public static void main(String[] args) {
        int len = 0, oldlen = 0;
        Object[] a = new Object[0];
        try {
            for (;;) {
                ++len;
                Object[] temp = new Object[oldlen = len];
                temp[0] = a;
                a = temp;
            }
        } catch (Error e) {
            System.out.println(e + ", " + (oldlen==len));
        }
    }
}

java.lang.OutOfMemoryError, true

配列アクセス式は、配列のコンポーネントである変数を参照します。

配列アクセス式には、配列参照式(左カッコの前)と索引式(カッコの内側)の2つの副式が含まれています。

配列参照式は、配列作成式に配列イニシャライザ(§15.10.1)が含まれていないかぎり、名前または配列作成式ではない任意のプライマリ式にすることができます。

配列参照式の型は、配列型(T[]、コンポーネントがT型である配列)である必要があります。そうでないと、コンパイル時にエラーが発生します。

索引式には、単項数値プロモーション(§5.6)が適用されます。 プロモートされた型はintである必要があります。そうでないと、コンパイル時にエラーが発生します。

配列アクセス式の型は、取得変換(§5.1.10)をTに適用した結果です。

配列アクセス式の結果は、T型の変数、つまり索引式の値によって選択された配列内の変数です。

この結果生成される変数は、配列参照式がfinal変数を示している場合でも、finalとはみなされません。

実行時には、配列アクセス式の評価は次のように動作します。

class Test1 {
    public static void main(String[] args) {
        int[] a = { 11, 12, 13, 14 };
        int[] b = { 0, 1, 2, 3 };
        System.out.println(a[(a=b)[3]]);
    }
}

14

class Test2 {
    public static void main(String[] args) {
        int index = 1;
        try {
            skedaddle()[index=2]++;
        } catch (Exception e) {
            System.out.println(e + ", index=" + index);
        }
    }
    static int[] skedaddle() throws Exception {
        throw new Exception("Ciao");
    }
}

java.lang.Exception: Ciao, index=1

class Test3 {
    public static void main(String[] args) {
        int index = 1;
        try {
            nada()[index=2]++;
        } catch (Exception e) {
            System.out.println(e + ", index=" + index);
        }
    }
    static int[] nada() { return null; }
}

java.lang.NullPointerException, index=2

class Test4 {
    public static void main(String[] args) {
        int[] a = null;
        try {
            int i = a[vamoose()];
            System.out.println(i);
        } catch (Exception e) {
            System.out.println(e);
        }
    }
    static int vamoose() throws Exception {
        throw new Exception("Twenty-three skidoo!");
    }
}

java.lang.Exception: Twenty-three skidoo!

「プライマリ」の型は、参照型Tである必要があります。そうしないと、コンパイル時にエラーが発生します。

フィールドアクセス式の意味は、次のように決定されます。

実行時に、フィールド・アクセス式の結果は次のように計算されます: (プログラムが明確な割当て分析に関して正しいと仮定します。つまり、すべての空白のfinal変数がアクセス前に必ず割り当てられます)

実行時に参照される実際のオブジェクトのクラスではなく、プライマリ式の型のみが、使用するフィールドの決定に使用されます。

class S           { int x = 0; }
class T extends S { int x = 1; }
class Test1 {
    public static void main(String[] args) {
        T t = new T();
        System.out.println("t.x=" + t.x + when("t", t));
        S s = new S();
        System.out.println("s.x=" + s.x + when("s", s));
        s = t;
        System.out.println("s.x=" + s.x + when("s", s));
    }
    static String when(String name, Object t) {
        return " when " + name + " holds a "
                        + t.getClass() + " at run time.";
    }
}

t.x=1 when t holds a class T at run time.
s.x=0 when s holds a class S at run time.
s.x=0 when s holds a class T at run time.

class S           { int x = 0; int z() { return x; } }
class T extends S { int x = 1; int z() { return x; } }
class Test2 {
    public static void main(String[] args) {
        T t = new T();
        System.out.println("t.z()=" + t.z() + when("t", t));
        S s = new S();
        System.out.println("s.z()=" + s.z() + when("s", s));
        s = t;
        System.out.println("s.z()=" + s.z() + when("s", s));
    }
    static String when(String name, Object t) {
        return " when " + name + " holds a "
                        + t.getClass() + " at run time.";
    }
}

t.z()=1 when t holds a class T at run time.
s.z()=0 when s holds a class S at run time.
s.z()=1 when s holds a class T at run time.

class Test3 {
    static String mountain = "Chocorua";
    static Test3 favorite(){
        System.out.print("Mount ");
        return null;
    }
    public static void main(String[] args) {
        System.out.println(favorite().mountain);
    }
}

Mount Chocorua

super.Identifierという形式は、現行オブジェクトのIdentifierというフィールドを指しますが、現行オブジェクトは現行クラスのスーパークラスのインスタンスとして表示されます。

T.super.Identifierという形式は、Tに対応する字句で囲んでいるインスタンスのIdentifierという名前のフィールドを指しますが、そのインスタンスはTのスーパークラスのインスタンスとして表示されます。

キーワードsuperを使用するフォームは、キーワードthisを式として許可するクラス宣言内の場所で使用できます(§15.8.3)。

キーワードsuperを使用したフィールド・アクセス式が静的コンテキスト(§8.1.3)または現在のクラスの初期構成コンテキスト(§8.8.7)で発生した場合、コンパイル時にエラーが発生します。

super.Identifier形式のフィールド・アクセス式の場合:

T.super.Identifierという形式のフィールド・アクセス式の場合:

フィールド・アクセス式super.fがクラスC内にあり、Cの直接スーパークラスがクラスSであるとします。 SのfにクラスC (§6.6)からアクセスできる場合、super.fは、クラスSの本体で式this.fであったかのように扱われます。 そうでない場合、コンパイル時にエラーが発生します。

したがって、super.fは、クラスSでアクセス可能なフィールドfにアクセスできます。これは、そのフィールドがクラスCのフィールドfの宣言によって非表示になっている場合でも同様です。

フィールド・アクセス式T.super.fがクラスC内にあり、Tで示されるクラスの即時スーパークラスが完全修飾名がSのクラスであるとします。 SのfにCからアクセスできる場合、T.super.fは、クラスSの本体で式this.fであったかのように処理されます。 そうでない場合、コンパイル時にエラーが発生します。

したがって、T.super.fは、クラスTのフィールドfの宣言によってそのフィールドが非表示になっている場合でも、クラスSでアクセス可能なフィールドfにアクセスできます。

interface I           { int x = 0; }
class T1 implements I { int x = 1; }
class T2 extends T1   { int x = 2; }
class T3 extends T2 {
    int x = 3;
    void test() {
        System.out.println("x=\t\t"          + x);
        System.out.println("super.x=\t\t"    + super.x);
        System.out.println("((T2)this).x=\t" + ((T2)this).x);
        System.out.println("((T1)this).x=\t" + ((T1)this).x);
        System.out.println("((I)this).x=\t"  + ((I)this).x);
    }
}
class Test {
    public static void main(String[] args) {
        new T3().test();
    }
}

x=              3
super.x=        2
((T2)this).x=   2
((T1)this).x=   1
((I)this).x=    0

コンパイル時のメソッド呼出しの処理での最初のステップは、呼び出されるメソッドの名前およびその名前のメソッドの定義の検索対象の型を把握することです。

メソッドの名前は、MethodNameまたはIdentifierで指定します。この識別子は、MethodInvocationの左カッコの直前にあります。

検索する型については、MethodInvocationの左カッコの前にあるフォームに応じて、次の6つのケースを考慮する必要があります。

class Superclass {
    void foo() { System.out.println("Hi"); }
}

class Subclass1 extends Superclass {
    void foo() { throw new UnsupportedOperationException(); }

    Runnable tweak = new Runnable() {
        void run() {
            Subclass1.super.foo();  // Gets the 'println' behavior
        }
    };
}

interface Superinterface {
    default void foo() { System.out.println("Hi"); }
}

class Subclass2 implements Superinterface {
    void foo() { throw new UnsupportedOperationException(); }

    void tweak() {
        Superinterface.super.foo();  // Gets the 'println' behavior
    }
}

class Subclass3 implements Superinterface {
    void foo() { throw new UnsupportedOperationException(); }

    Runnable tweak = new Runnable() {
        void run() {
            Subclass3.Superinterface.super.foo();  // Illegal
        }
    };
}

2番目のステップでは、前のステップで決定した型でメンバー・メソッドを検索します。 このステップでは、メソッドの名前と引数式を使用して、accessibleとapplicableの両方、つまり、指定された引数で正しく起動できる宣言を検索します。

このようなメソッドが複数存在する場合があり、その場合は最も具体的なメソッドが選択されます。 最も具体的なメソッドの記述子(シグネチャと戻り値の型)は、メソッドのディスパッチを実行するために実行時に使われる記述子です。

暗黙的に型指定されたラムダ式(§15.27.1)または不正確なメソッド参照(§15.13.1)を含む特定の引数式は、呼出しのターゲット型が選択されるまで意味を決定できないため、適用性テストでは無視されます。 一方、メソッド呼出し式が多式であっても、適用性テストに影響を与えるのは、呼出しのターゲット・タイプではない引数式のみです。

適用性を決定するプロセスは、潜在的に適用可能なメソッド(§15.12.2.1)を決定することから始まります。 その後、Java SE 5.0より前のJavaプログラミング言語との互換性を確保するために、プロセスは3つのフェーズで続行されます。

メソッドが厳密な呼出し(第1フェーズ、§15.12.2.2)、ルース呼出し(第2フェーズ、§15.12.2.3)または可変アリティ呼出し(第3フェーズ、§15.12.2.4)のいずれかによって適用される場合、メソッドは適用可能です。 汎用メソッド(§8.4.4)の場合、メソッドが適用可能かどうかを判断するには、型引数の分析が必要です。 型引数は、明示的または暗黙的に渡すことができます。暗黙的に渡される場合は、型引数の境界を引数式(§18 (Type Inference))から推測する必要があります。

適用性テストの3つのフェーズのいずれかでいくつかの適用可能な方法が特定された場合、§15.12.2.5で指定されているように、最も具体的な方法が選択されます。

適用性をチェックするために、呼出しの引数の型は、通常、分析への入力にはできません。 この理由は次のとおりです。

かわりに、適用性チェックへの入力は、引数自体のリストです。 引数の最終的な型が不明な場合でも、潜在的なターゲット型との互換性を確認できます。

オーバーロード解決は、ターゲット・タイプとは無関係です。 これは、次の2つの理由によります。

class Doubler {
            static int two()      { return two(1); }
    private static int two(int i) { return 2*i;    }
}
class Test extends Doubler {
    static long two(long j) { return j+j; }

    public static void main(String[] args) {
        System.out.println(two(3));
        System.out.println(Doubler.two(3)); // compile-time error
    }
}

class ColoredPoint {
    int x, y;
    byte color;
    void setColor(byte color) { this.color = color; }
}
class Test {
    public static void main(String[] args) {
        ColoredPoint cp = new ColoredPoint();
        byte color = 37;
        cp.setColor(color);
        cp.setColor(37);  // compile-time error
    }
}

void setColor(int color) { this.color = (byte)color; }

class Point { int x, y; }
class ColoredPoint extends Point { int color; }
class Test {
    static void test(ColoredPoint p, Point q) {
        System.out.println("(ColoredPoint, Point)");
    }
    static void test(Point p, ColoredPoint q) {
        System.out.println("(Point, ColoredPoint)");
    }
    public static void main(String[] args) {
        ColoredPoint cp = new ColoredPoint();
        test(cp, cp);  // compile-time error
    }
}

static void test(ColoredPoint p, ColoredPoint q) {
    System.out.println("(ColoredPoint, ColoredPoint)");
}

class Point { int x, y; }
class ColoredPoint extends Point { int color; }
class Test {
    static int test(ColoredPoint p) {
        return p.color;
    }
    static String test(Point p) {
        return "Point";
    }
    public static void main(String[] args) {
        ColoredPoint cp = new ColoredPoint();
        String s = test(cp);  // compile-time error
    }
}

package points;
public class Point {
    public int x, y;
    public Point(int x, int y) { this.x = x; this.y = y; }
    public String toString() { return toString(""); }
    public String toString(String s) {
        return "(" + x + "," + y + s + ")";
    }
}

package points;
public class ColoredPoint extends Point {
    public static final int
        RED = 0, GREEN = 1, BLUE = 2;
    public static String[] COLORS =
        { "red", "green", "blue" };

    public byte color;
    public ColoredPoint(int x, int y, int color) {
        super(x, y);
        this.color = (byte)color;
    }

    /** Copy all relevant fields of the argument into
        this ColoredPoint object. */
    public void adopt(Point p) { x = p.x; y = p.y; }

    public String toString() {
        String s = "," + COLORS[color];
        return super.toString(s);
    }
}

import points.*;
class Test {
    public static void main(String[] args) {
        ColoredPoint cp =
            new ColoredPoint(6, 6, ColoredPoint.RED);
        ColoredPoint cp2 =
            new ColoredPoint(3, 3, ColoredPoint.GREEN);
        cp.adopt(cp2);
        System.out.println("cp: " + cp);
    }
}

cp: (3,3,red)

public void adopt(ColoredPoint p) {
    adopt((Point)p);
    color = p.color;
}

cp: (3,3,red)

cp: (3,3,green)

public void adopt(Point p) {
    if (p instanceof ColoredPoint)
        color = ((ColoredPoint)p).color;
    x = p.x; y = p.y;
}

メソッド呼出しに対して最も具体的なメソッド宣言がある場合は、メソッド呼出しに対してコンパイル時宣言と呼ばれます。

メソッド呼出しの引数が、コンパイル時宣言の呼出しタイプから導出されたターゲット・タイプと互換性がない場合は、コンパイル時エラーです。

コンパイル時宣言が可変アリティ呼出しによって適用される場合、メソッドの呼出しタイプの最後の仮パラメータ型がF_n[]の場合、F_nの消去である型が呼出しの時点でアクセスできない(§6.6)ときは、コンパイル時にエラーが発生します。

コンパイル時宣言がvoidの場合、メソッド呼出しは最上位の式(つまり、式文の式、またはfor文のForInitまたはForUpdate部分)である必要があります。そうしないと、コンパイル時にエラーが発生します。 このようなメソッド呼出しでは値が生成されないため、値が不要な状況でのみ使用する必要があります。

また、コンパイル時の宣言が適切かどうかは、次のように、左カッコの前のメソッド呼出し式の形式によって異なります:

compile-timeパラメータ・タイプおよびcompile-time resultは次のように決定されます。

次のすべてに当てはまる場合、メソッドは署名多相です。

次のコンパイル時情報は、実行時に使用するメソッド呼出しに関連付けられます:

コンパイル時宣言の呼出し型の結果がvoidでない場合、取得変換(§5.1.10)をコンパイル時宣言の呼出し型の戻り型に適用することで、メソッド呼出し式の型が取得されます。

実行時に、メソッドの起動には5つのステップが必要です。 まず、ターゲット参照を計算できます。 次に、引数式が評価されます。 次に、呼び出されるメソッドのアクセシビリティをチェックします。 4つ目は、実行するメソッドの実際のコードです。 5番目には、新しいアクティブ化フレームが作成され、必要に応じて同期が実行され、制御がメソッド・コードに転送されます。

class Test1 {
    static void mountain() {
        System.out.println("Monadnock");
    }
    static Test1 favorite(){
        System.out.print("Mount ");
        return null;
    }
    public static void main(String[] args) {
        favorite().mountain();
    }
}

Mount Monadnock

class Test2 {
    public static void main(String[] args) {
        String s = "one";
        if (s.startsWith(s = "two"))
            System.out.println("oops");
    }
}

class Point {
    final int EDGE = 20;
    int x, y;
    void move(int dx, int dy) {
        x += dx; y += dy;
        if (Math.abs(x) >= EDGE || Math.abs(y) >= EDGE)
            clear();
    }
    void clear() {
        System.out.println("\tPoint clear");
        x = 0; y = 0;
    }
}
class ColoredPoint extends Point {
    int color;
    void clear() {
        System.out.println("\tColoredPoint clear");
        super.clear();
        color = 0;
    }
}

class Test1 {
    public static void main(String[] args) {
        Point p = new Point();
        System.out.println("p.move(20,20):");
        p.move(20, 20);

        ColoredPoint cp = new ColoredPoint();
        System.out.println("cp.move(20,20):");
        cp.move(20, 20);

        p = new ColoredPoint();
        System.out.println("p.move(20,20), p colored:");
        p.move(20, 20);
    }
}

p.move(20,20):
        Point clear
cp.move(20,20):
        ColoredPoint clear
        Point clear
p.move(20,20), p colored:
        ColoredPoint clear
        Point clear

class T1 {
    String s() { return "1"; }
}
class T2 extends T1 {
    String s() { return "2"; }
}
class T3 extends T2 {
    String s() { return "3"; }
    void test() {
        System.out.println("s()=\t\t"          + s());
        System.out.println("super.s()=\t"      + super.s());
        System.out.println("((T2)this).s()=\t" + ((T2)this).s());
        System.out.println("((T1)this).s()=\t" + ((T1)this).s());
    }
}
class Test2 {
    public static void main(String[] args) {
        T3 t3 = new T3();
        t3.test();
    }
}

s()=            3
super.s()=      2
((T2)this).s()= 3
((T1)this).s()= 3

abstract class C<T> {
    abstract T id(T x);
}
class D extends C<String> {
    String id(String x) { return x; }
}

C c = new D();
c.id(new Object());  // fails with a ClassCastException

Object id(Object x) { return id((String) x); }

メソッド参照式のコンパイル時宣言は、式が参照するメソッドです。 特別なケースでは、コンパイル時の宣言は実際には存在しませんが、クラス・インスタンスの作成または配列の作成を表すノーショナル・メソッドです。 コンパイル時宣言の選択は、メソッド呼出しのコンパイル時宣言が呼出しの引数(§15.12.3)に依存するのと同様に、式がターゲットとする関数型に依存します。

コンパイル時宣言の検索では、次のように§15.12.1および§15.12.2のメソッド呼出しのプロセスがミラー化されます。

メソッド参照式の形式がReferenceType :: [TypeArguments] Identifierで、コンパイル時宣言がstaticで、ReferenceTypeが単純名または修飾名(§6.2)でない場合、コンパイル時にエラーが発生します。

メソッド参照式の形式がsuper :: [TypeArguments] IdentifierまたはTypeName . super :: [TypeArguments] Identifierで、コンパイル時宣言の形式がabstractの場合、コンパイル時にエラーが発生します。

メソッド参照式の形式がsuper :: [TypeArguments] IdentifierまたはTypeName . super :: [TypeArguments] Identifierで、メソッド参照式が現在のクラスの静的コンテキスト(§8.1.3)または初期構成コンテキスト(§8.8.7)で発生した場合、コンパイル時にエラーが発生します。

メソッド参照式の形式がTypeName . super :: [TypeArguments] Identifierで、TypeNameがクラスCを示し、メソッド参照式の即時包含クラスまたはインタフェース宣言がCまたは内部クラスCではない場合、コンパイル時にエラーが発生します。

メソッド参照式の形式がTypeName . super :: [TypeArguments] Identifierで、TypeNameがインタフェースを示し、コンパイル時宣言とは異なるメソッドが存在する場合、コンパイル時宣言はメソッド参照式をすぐに囲むクラスまたはインタフェースの直接スーパークラスまたは直接スーパーインタフェースからのコンパイル時宣言をオーバーライドします(§8.4.8、§9.4.1)。

メソッド参照式がClassType :: [TypeArguments] newの形式であり、§15.9.2で指定されているClassTypeの包含インスタンスを決定するときにコンパイル時エラーが発生した場合(メソッド参照式を不適格クラス・インスタンス作成式であるかのように処理する場合)、コンパイル時エラーです。

ReferenceType :: [TypeArguments] Identifierという形式のメソッド参照式は、様々な方法で解釈できます。 Identifierがインスタンス・メソッドを参照する場合、Identifierがstaticメソッドを参照する場合と比較して、暗黙的なラムダ式に余分なパラメータがあります。 ReferenceTypeは、両方の種類の適用可能なメソッドを持つことができるため、前述の検索アルゴリズムは、各ケースに異なるパラメータ・タイプがあるため、それらを個別に識別します。

あいまいさの例を次に示します:

interface Fun<T,R> { R apply(T arg); }

class C {
    int size() { return 0; }
    static int size(Object arg) { return 0; }

    void test() {
        Fun<C, Integer> f1 = C::size;
          // Error: instance method size()
          // or static method size(Object)?
    }
}

このあいまいさを解決するには、適用可能なstaticメソッドよりも具体的な適用可能なインスタンス・メソッドを指定します。

interface Fun<T,R> { R apply(T arg); }

class C {
    int size() { return 0; }
    static int size(Object arg) { return 0; }
    int size(C arg) { return 0; }

    void test() {
        Fun<C, Integer> f1 = C::size;
          // Error: instance method size()
          // or static method size(Object)?
    }
}

検索は、(両方の検索から)で適用可能なすべてのメソッドがインスタンス・メソッドであるあいまいさを無視するのに十分なスマートです:

interface Fun<T,R> { R apply(T arg); }

class C {
    int size() { return 0; }
    int size(Object arg) { return 0; }
    int size(C arg) { return 0; }

    void test() {
        Fun<C, Integer> f1 = C::size;
          // OK: reference is to instance method size()
    }
}

便宜上、汎用型の名前を使用してインスタンス・メソッド(レシーバが最初のパラメータになる場所)を参照する場合、ターゲット型を使用して型引数が決定されます。 これにより、Pair<String,Integer>::firstのかわりにPair::firstなどの使用が容易になります。 同様に、Pair::newのようなメソッド参照は、ダイヤモンド・インスタンス作成(new Pair<>())のように扱われます。 "diamond"は暗黙的であるため、この形式はRAW型をインスタンス化しません。実際、RAW型のコンストラクタへの参照を表現する方法はありません。

一部のメソッド参照式では、対象となる関数型に関係なく、可能な呼出し型(§15.12.2.6)が1つのみのコンパイル時宣言が1つのみ存在できます。 このようなメソッド参照式は、完全です。 完全ではないメソッド参照式は、inexactと呼ばれます。

Identifierで終わるメソッド参照式は、次のすべてを満たす場合に正確です。

ClassType :: [TypeArguments] newという形式のメソッド参照式は、次のすべてを満たす場合に正確です。

ArrayType :: new形式のメソッド参照式は、常に正確です。

メソッド参照式は、Tがファンクション・インタフェース・タイプ(§9.8)で、式がTから導出されたグラウンド・ターゲット・タイプのファンクション・タイプを持つcongruentの場合、割当てコンテキスト、呼出しコンテキストまたはターゲット・タイプTとのキャスト・コンテキストで互換性があります。

グラウンド・ターゲット・タイプは、次のようにTから導出されます。

次の両方に当てはまる場合、メソッド参照式はファンクション・タイプと一致します。

コンパイル時宣言を適用するために未チェックの変換が必要で、この変換によって起動コンテキストで未チェックの警告が発生した場合、@SuppressWarnings (§9.6.4.5)によって抑制されないかぎり、コンパイル時の未チェックの警告が発生します。

前述の戻り型Rで、ファンクション型の戻り型Rと互換性があるために、未チェックの変換が必要だった場合、この変換によって割当てコンテキストで未チェックの警告が発生し、@SuppressWarningsで抑制されないかぎり、コンパイル時の未チェックの警告が発生します。

メソッド参照式がターゲット・タイプTと互換性がある場合、式の型Uは、Tから導出された接地ターゲット型です。

Uまたは Uの関数型が、メソッド参照式が出現するクラスまたはインタフェースからアクセスできない(§6.6)場合は、コンパイル時にエラーが発生します。

Uのstatic以外のメンバー・メソッドmごとに、Uのファンクション・タイプにmのシグネチャのサブシグネチャがある場合、メソッド・タイプがUのファンクション・タイプであるノーショナル・メソッドはmをオーバーライドすると言われ、§8.4.8.3で指定されたコンパイル時エラーまたはチェックされていない警告が発生する可能性があります。

コンパイル時宣言の起動タイプのthrows句にリストされているチェックされた例外タイプXごとに、XまたはXのスーパークラスがUファンクション・タイプのthrows句で指定されている必要があり、そうでない場合はコンパイル時にエラーが発生します。

互換性定義を駆動する主な考え方は、同等のラムダ式(x, y, z) -> exp.<T1, T2>method(x, y, z)に互換性がある場合にのみ、メソッド参照に互換性があることです。 (これは非公式であり、このようなリライトの観点からセマンティクスを正式に定義することが困難または不可能になる問題があります。)

これらの互換性ルールは、ある機能インタフェースから別の機能インタフェースに変換するための便利な機能を提供します。

Task t = () -> System.out.println("hi");
Runnable r = t::invoke;

ラムダ派生オブジェクトが渡されて様々な型に変換される場合に、コア・ラムダ本体の周りに多くのレベルの適応ロジックが生成されないように、実装を最適化できます。

ラムダ式とは異なり、メソッド参照は汎用関数型(型パラメータを持つ関数型)に準拠できます。 これは、ラムダ式で型パラメータを宣言できる必要があり、構文でこれがサポートされないためです。メソッド参照の場合、そのような宣言は必要ありません。 たとえば、次のプログラムは有効です。

interface ListFactory {
    <T> List<T> make();
}

ListFactory lf  = ArrayList::new;
List<String> ls = lf.make();
List<Number> ln = lf.make();

実行時、メソッド参照式の評価はクラス・インスタンス作成式の評価と似ていますが、通常の完了によってオブジェクトへの参照が生成されるかぎりです。 メソッド参照式の評価は、メソッド自体の呼出しとは異なります。

まず、メソッド参照式がExpressionNameまたはPrimaryで始まる場合、このサブ式が評価されます。 サブ式がnullと評価されると、NullPointerExceptionが生成され、メソッド参照式が突然完了します。 サブ式が突然完了すると、メソッド参照式も同じ理由で突然完了します。

次に、次のプロパティを持つクラスの新規インスタンスが割り当てられて初期化されるか、または次のプロパティを持つクラスの既存のインスタンスが参照されます。 新規インスタンスを作成するが、オブジェクトを割り当てるための領域が不足している場合、メソッド参照式の評価はOutOfMemoryErrorをスローして突然完了します。

メソッド参照式の値は、次のプロパティを持つクラスのインスタンスへの参照です。

呼出しメソッドの本体は、次のようにメソッド参照式の形式によって異なります。