第8章 クラス

クラス宣言には、クラス修飾子を含めることができます。

クラス宣言の注釈修飾子に関する規則は、§9.7.4および§9.7.5で指定されています。

アクセス修飾子public (§6.6)は、最上位クラス(§7.6)およびメンバー・クラス(§8.5、§9.5)にのみ関連し、ローカル・クラス(§14.3)または匿名クラス(§15.9.5)には関連しません。

アクセス修飾子protectedおよびprivateは、メンバー・クラスにのみ関係します。

修飾子staticは、メンバー・クラスおよびローカル・クラスにのみ関係します。

同じキーワードがクラス宣言の修飾子として複数回出現する場合、またはクラス宣言に複数のアクセス修飾子public、protectedおよびprivateがある場合、コンパイル時にエラーが発生します。

クラス宣言に複数の修飾子sealed、non-sealedおよびfinalがある場合、コンパイル時にエラーが発生します。

2つ以上の(個別)クラス修飾子がクラス宣言に表示される場合、ClassModifierの本番で前述したものと一致する順序で表示されることは、必須ではありませんが慣例です。

abstract class Point {
    int x = 1, y = 1;
    void move(int dx, int dy) {
        x += dx;
        y += dy;
        alert();
    }
    abstract void alert();
}
abstract class ColoredPoint extends Point {
    int color;
}
class SimplePoint extends Point {
    void alert() { }
}

Point p = new Point();

Point p = new SimplePoint();

interface Colorable {
    void setColor(int color);
}
abstract class Colored implements Colorable {
    public abstract int setColor(int color);
}

public final class Math {
    private Math() { }  // never instantiate this class
    . . . declarations of class variables and methods . . .
}

クラス宣言で1つ以上の型変数が宣言されている場合、クラスは汎用です(§4.4)。

これらの型変数は、クラスの型パラメータと呼ばれます。 タイプ・パラメータ・セクションは、クラス名の後に山カッコで区切られます。

ここでは、便宜上、§4.4からの次のプロダクションを示します。

型パラメータ宣言の注釈修飾子に関する規則は、§9.7.4および§9.7.5に記載されています。

クラスの型パラメータ・セクションで、型変数T直接依存は型変数S(SがTの境界である場合)に依存し、TはS(TがSに直接依存している場合)またはTのいずれかがSに直接依存している場合(この定義を再帰的に使用する場合)は、Sに依存する型変数Uに依存します。

クラス型パラメータ・セクションの型変数がそれ自体に依存している場合は、コンパイル時エラーです。

クラスの型パラメータのスコープとシャドウ化は、§6.3および §6.4.1で規定されています。

静的コンテキストまたはネストされたクラスまたはインタフェースからのクラスの型パラメータへの参照は、§6.5.5.1で指定されているように制限されます。

汎用クラス宣言は、パラメータ化された型のセット(§4.5)を定義し、型引数による型パラメータ・セクションの可能なパラメータ化ごとに1つずつ定義します。 これらのパラメータ化された型はすべて、実行時に同じクラスを共有します。

Vector<String>  x = new Vector<String>();
Vector<Integer> y = new Vector<Integer>();
boolean b = x.getClass() == y.getClass();

汎用クラスがThrowableの直接または間接のサブクラス(§11.1.1)である場合、コンパイル時にエラーが発生します。

Java Virtual Machineのキャッチ・メカニズムは非汎用クラスでのみ機能するため、この制限が必要です。

interface ConvertibleTo<T> {
    T convert();
}
class ReprChange<T extends ConvertibleTo<S>,
                 S extends ConvertibleTo<T>> {
    T t;
    void set(S s) { t = s.convert();    }
    S get()       { return t.convert(); }
}

class Seq<T> {
    T      head;
    Seq<T> tail;

    Seq() { this(null, null); }
    Seq(T head, Seq<T> tail) {
        this.head = head;
        this.tail = tail;
    }
    boolean isEmpty() { return tail == null; }

    class Zipper<S> {
        Seq<Pair<T,S>> zip(Seq<S> that) {
            if (isEmpty() || that.isEmpty()) {
                return new Seq<Pair<T,S>>();
            } else {
                Seq<T>.Zipper<S> tailZipper =
                    tail.new Zipper<S>();
                return new Seq<Pair<T,S>>(
                    new Pair<T,S>(head, that.head),
                    tailZipper.zip(that.tail));
            }
        }
    }
}
class Pair<T, S> {
    T fst; S snd;
    Pair(T f, S s) { fst = f; snd = s; }
}
class Test {
    public static void main(String[] args) {
        Seq<String> strs =
            new Seq<String>(
                "a",
                new Seq<String>("b",
                                new Seq<String>()));
        Seq<Number> nums =
            new Seq<Number>(
                Integer.valueOf(1),
                new Seq<Number>(Double.valueOf(1.5),
                                new Seq<Number>()));

        Seq<String>.Zipper<Number> zipper =
            strs.new Zipper<Number>();

        Seq<Pair<String,Number>> combined =
            zipper.zip(nums);
    }
}

内部クラスは、明示的にまたは暗黙的にstaticでないネストされたクラスです。

内部クラスは次のいずれかです。

次のネストされたクラスは暗黙的にstaticであるため、内部クラスではありません。

ネストされたクラスに適用されるルールはすべて、内部クラスに適用されます。 特に、内部クラスは、内部クラス自体がstaticでない場合でも、staticメンバー(§8.2)を宣言および継承し、静的イニシャライザ(§8.7)を宣言できます。

すべてのネストされたインタフェースは暗黙的にstatic (§9.1.1.3)であるため、「内部インタフェース」はありません。

class HasStatic {
    static int j = 100;
}

class Outer {
    class Inner extends HasStatic {
        static {
            System.out.println("Hello from Outer.Inner");
        }

        static       int x = 3;
        static final int y = 4;

        static void hello() {
            System.out.println("Hello from Outer.Inner.hello");
        }

        static class VeryNestedButNotInner
            extends NestedButNotInner {}
    }

    static class NestedButNotInner {
        int z = Inner.x;
    }

    interface NeverInner {}  // Implicitly static, so never inner
}

構成(文、ローカル変数宣言文、ローカル・クラス宣言、ローカル・インタフェース宣言または式)は、静的コンテキストで発生します(最も内側の場合)。

この構成要素を含むのは、次のいずれかです。

なお、コンストラクタ宣言またはインスタンス・イニシャライザにおいて出現する構成要素は、静的コンテキストにおいては出現しません。

静的コンテキストの目的は、宣言が静的コンテキストを字句的に包含するクラスの現在のインスタンスが定義されていないコードを境界指定することです。 したがって、静的コンテキストにおいて出現するコードには、次のような制約があります。

内部クラスCはクラスまたはインタフェースOの直接内部クラスです。OがCの直近のクラスまたはインタフェース宣言で、Cの宣言が静的コンテキストで発生しない場合です。

内部クラスがローカル・クラスまたは無名クラスである場合は静的コンテキストで宣言でき、その場合、包含クラスまたはインタフェースの内部クラスとみなされることはありません。

クラス Cは、クラスまたはインタフェース Oの内部クラス(Oの直接内部クラス、または Oの内部クラスの内部クラス)です。

内部クラスのクラスまたはインタフェース宣言をすぐに囲むことは異常ですが、インタフェースになる可能性があります。 これは、クラスがdefaultまたはstaticメソッド本体(§9.4)で宣言されたローカル・クラスまたは匿名クラスである場合にのみ発生します。

クラスまたはインタフェース Oは、ゼロの字句で囲まれたクラスまたはそれ自体のインタフェース宣言です。

クラスOは、クラスCがn-1の字句的に包含するクラス宣言のCのn番目の字句で包含するクラス宣言である場合、そのクラスCのクラス宣言です。

クラスまたはインタフェースOの直接内部クラスCのインスタンスiは、Oのインスタンス(iの即時包含インスタンス)に関連付けることができます。 オブジェクト(存在する場合)の直近の包含インスタンスは、オブジェクトの作成時に決定されます(§15.9.2)。

オブジェクトoは、それ自体を字句的に包含するインスタンスです。

オブジェクトoが、iのn-1の字句的に囲まれたiインスタンスの直近の包含インスタンスである場合、オブジェクトoはn番目の字句で囲まれているインスタンスです。

宣言が静的コンテキストにおいて出現する内部ローカル・クラスまたは無名クラスのインスタンスには、直接包含インスタンスはありません。 また、staticネスト・クラスのインスタンス(§8.1.1.4)には、すぐに包含されるインスタンスはありません。

CのすべてのスーパークラスS(それ自体がクラスまたはインタフェースSOの直接内部クラス)について、iに関連付けられたSOのインスタンスがあります。これは、Sに関してiの即時包含インスタンスと呼ばれます。 クラスの直接スーパークラス(存在する場合)に関するオブジェクトの直近の包含インスタンスは、スーパークラス・コンストラクタがコンストラクタ呼出し(§8.8.7.1)を介して呼び出されたときに決定されます。

内部クラスに、字句として包含するクラスまたはインタフェースの宣言のメンバーであるインスタンス変数への有効な参照が含まれている場合は、対応する字句的に包含するインスタンスの変数が使用されます。

内部クラスで使用されているが宣言されていないローカル変数、仮パラメータまたは例外パラメータは、§6.5.6.1で指定されているとおり、finalまたは実質的にfinal (§4.12.4)である必要があります。

内部クラスで使用されていても宣言されていない局所変数は、内部クラスの本体の前に必ず割り当てる必要があります(§16 (Definite Assignment))。そうしないと、コンパイル時にエラーが発生します。

ラムダ式の本体(§15.27.2)には、変数の使用に関する同様の規則が適用されます。

字句的に囲まれているクラスまたはインタフェース宣言の空白のfinalフィールド(§4.12.4)は、内部クラス内で割り当てられないか、コンパイル時にエラーが発生します。

class Outer {
    int i = 100;
    static void classMethod() {
        final int l = 200;
        class LocalInStaticContext {
            int k = i;  // Compile-time error
            int m = l;  // OK
        }
    }
    void foo() {
        class Local {  // A local class
            int j = i;
        }
    }
}

class WithDeepNesting {
    boolean toBe;
    WithDeepNesting(boolean b) { toBe = b; }

    class Nested {
        boolean theQuestion;
        class DeeplyNested {
            DeeplyNested(){
                theQuestion = toBe || !toBe;
            }
        }
    }
}

通常のクラス宣言のオプションのextends句では、宣言するクラスのダイレクト・スーパークラス型を指定します。

extends句は、Objectクラスの定義内に指定しないでください。指定しないと、コンパイル時にエラーが発生します。これは、この句が初期クラスであり、直接スーパークラス型を持たないためです。

ClassTypeは、アクセス可能なクラス(§6.6)に名前を付ける必要があります。そうしないと、コンパイル時にエラーが発生します。

ClassTypeがsealed (§8.1.1.2)のクラスに名前を付け、宣言されているクラスが指定されたクラスの許可された直接サブクラスでない場合(§8.1.6)、コンパイル時にエラーが発生します。

ClassTypeがfinalのクラスに名前を付けると、コンパイル時にエラーが発生します。これは、finalクラスがサブクラスを持つことが許可されないためです(§8.1.1.2)。

ClassTypeがenumクラス(§8.9)によってのみ拡張できるクラスEnumに名前を付ける場合、またはレコード・クラス(§8.10)によってのみ拡張できるクラスRecordに名前を付ける場合、コンパイル時にエラーが発生します。

ClassTypeに型引数がある場合、整形式のパラメータ化された型(§4.5)を示す必要があり、型引数にワイルドカード型引数を指定できないか、コンパイル時にエラーが発生します。

宣言にextends句がないクラスの直接スーパークラス型は、次のとおりです。

クラスのダイレクト・スーパークラスは、そのダイレクト・スーパークラス・タイプによって命名されたクラスです。 直接スーパークラスは、宣言されているクラスの実装を導出するためにその実装が使用されるため、重要です。

スーパークラス関係は、直接スーパークラス関係の推移的クローズです。 次のいずれかが当てはまる場合、クラス Aはクラス Cのスーパークラスです。

クラスは、その直接スーパークラスの直接サブクラスであり、各スーパークラスのサブクラスであると言われています。

class Point { int x, y; }
final class ColoredPoint extends Point { int color; }
class Colored3DPoint extends ColoredPoint { int z; }  // error

class Point { int x, y; }
class ColoredPoint extends Point { int color; }
final class Colored3dPoint extends ColoredPoint { int z; }

クラスCは、クラスまたはインタフェースAに直接依存します。Aが、スーパークラスまたはスーパーインタフェースとして、あるいはスーパークラスまたはスーパーインタフェース名の完全修飾形式の修飾子としてCのextends句またはimplements句で指定されている場合です。

次のいずれかに該当する場合、クラスCはクラスまたはインタフェースAに依存します。

クラスがそれ自体に依存する場合は、コンパイル時にエラーが発生します。

循環宣言されたクラスが実行時に検出され、クラスがロードされると、ClassCircularityErrorがスローされます(§12.2.1)。

class Point extends ColoredPoint { int x, y; }
class ColoredPoint extends Point { int color; }

クラス宣言のオプションのimplements句では、宣言するクラスのダイレクト・スーパーインタフェース型を指定します。

各InterfaceTypeはアクセス可能なインタフェースに名前を付ける必要があります(§6.6)。そうしないと、コンパイル時にエラーが発生します。

いずれかのInterfaceTypeがsealed (§9.1.1.4)のインタフェースに名前を付け、宣言されているクラスが指定されたインタフェースの許可された直接サブクラスでない場合(§9.1.4)、コンパイル時にエラーが発生します。

InterfaceTypeに型引数がある場合、整形式のパラメータ化された型(§4.5)を示す必要があり、どの型引数もワイルドカード型引数にできないか、コンパイル時にエラーが発生します。

1つのimplements句で同じインタフェースが直接スーパーインタフェース・タイプによって複数回指定されている場合、コンパイル時にエラーが発生します。 これは、インタフェースに異なる方法で名前が付けられている場合でも当てはまります。

class Redundant implements java.lang.Cloneable, Cloneable {
    int x;
}

宣言にimplements句がないクラスには、直接スーパーインタフェース型はありません。ただし、匿名クラスにはスーパーインタフェース型がある場合があります(§15.9.5)。

インタフェースがクラスの直接スーパーインタフェース・タイプの1つによって指定されている場合、インタフェースはクラスの直接スーパーインタフェースです。

インタフェースIは、次のいずれかが当てはまる場合に、クラスCのスーパーインタフェースです。

クラスは、複数の方法でスーパー・インタフェースを持つことができます。

クラスは、その直接スーパーインタフェースを直接実装し、そのすべてのスーパーインタフェースを実装します。

クラスは、その直接スーパーインタフェースの直接サブクラスであり、そのすべてのスーパーインタフェースのサブクラスです。

クラスは、直接スーパークラス型と直接スーパーインタフェース型、または同じ汎用インタフェース(§9.1.2)の異なるパラメータ化であるスーパータイプ(§4.10.2)を持つ2つの直接スーパーインタフェース型を宣言したり、同じ汎用インタフェースである汎用インタフェースとRAW型ネーミングのパラメータ化を宣言することはできません。 このような競合の場合は、コンパイル時にエラーが発生します。

この要件は、型消去による翻訳をサポートするために導入されました(§4.6)。

interface Colorable {
    void setColor(int color);
    int getColor();
}
enum Finish { MATTE, GLOSSY }
interface Paintable extends Colorable {
    void setFinish(Finish finish);
    Finish getFinish();
}

class Point { int x, y; }
class ColoredPoint extends Point implements Colorable {
    int color;
    public void setColor(int color) { this.color = color; }
    public int getColor() { return color; }
}
class PaintedPoint extends ColoredPoint implements Paintable {
    Finish finish;
    public void setFinish(Finish finish) {
        this.finish = finish;
    }
    public Finish getFinish() { return finish; }
}

interface I<T> {}
class B implements I<Integer> {}
class C extends B implements I<String> {}

宣言されているクラスがabstractでないかぎり、各直接スーパーインタフェースのすべてのabstractメンバー・メソッドは、このクラスの宣言、または直接スーパークラスまたは直接スーパーインタフェースから継承された既存のメソッド宣言のいずれかによって実装する必要があります(§8.4.8.1)。これは、abstractでないクラスがabstractメソッドを持つことが許可されないためです(§8.1.1.1)。

クラスのスーパーインタフェースの各デフォルト・メソッド(§9.4.3)は、オプションでクラス内のメソッドによってオーバーライドできます。そうでない場合は、通常、デフォルト・メソッドが継承され、その動作はデフォルト本文で指定されます。

クラス内の単一のメソッド宣言では、複数のスーパー・インタフェースのメソッドを実装できます。

interface Colorable {
    void setColor(int color);
    int getColor();
}
class Point { int x, y; };
class ColoredPoint extends Point implements Colorable {
    int color;
}

interface Fish  { int getNumberOfScales(); }
interface Piano { int getNumberOfScales(); }
class Tuna implements Fish, Piano {
    // You can tune a piano, but can you tuna fish?
    public int getNumberOfScales() { return 91; }
}

interface Fish       { int    getNumberOfScales(); }
interface StringBass { double getNumberOfScales(); }
class Bass implements Fish, StringBass {
    // This declaration cannot be correct,
    // no matter what type is used.
    public ?? getNumberOfScales() { return 91; }
}

通常のクラス宣言のオプションのpermits句では、宣言されるクラスの直接サブクラス(§8.1.1.2)として意図されるすべてのクラスを指定します。

クラス宣言にpermits句があり、sealed修飾子がない場合、コンパイル時にエラーが発生します。

すべてのTypeNameはアクセス可能なクラスに名前を付ける必要があります(§6.6)。そうしないと、コンパイル時にエラーが発生します。

permits句で同じクラスが複数回指定されている場合、コンパイル時にエラーが発生します。 これは、クラスに異なる方法で名前が付けられている場合でも当てはまります。

package p;

sealed class A     permits B, C, p.B {}  // error

non-sealed class B extends A {}
non-sealed class C extends A {}

sealedクラスCが名前付きモジュール(§7.3)に関連付けられている場合、Cの宣言のpermits句で指定されたすべてのクラスをCと同じモジュールに関連付ける必要があります。そうしないと、コンパイル時にエラーが発生します。

sealedクラスCが無名モジュール(§7.7.5)に関連付けられている場合、Cの宣言のpermits句で指定されるすべてのクラスは、Cと同じパッケージに属している必要があります。そうでないと、コンパイル時にエラーが発生します。

sealedクラスとその直接サブクラスは、それぞれpermits句とextends句で、循環方式で相互を参照する必要があります。 したがって、モジュラー・コードベースでは、異なるモジュール内のクラスが相互を循環方式で参照できないため、同じモジュール内に配置する必要があります。 シール済クラス階層は常に単一のメンテナンス・ドメイン内で宣言する必要があり、同じ開発者または開発者のグループが階層の維持を担当するため、いずれの場合もコロケーションが望ましいです。 名前付きモジュールは通常、モジュラーコードベースの保守ドメインを表します。

sealedクラスCの宣言にpermits句がある場合、Cの許可された直接サブクラスは、permits句で指定されたクラスです。

permits句で指定されるすべての許可される直接サブクラスは、C (§8.1.4)の直接サブクラスである必要があります。そうしないと、コンパイル時にエラーが発生します。

sealedクラスCの宣言にpermits句がない場合、Cで許可される直接サブクラスは次のようになります。

クラス本体には、クラスのメンバーの宣言、つまりフィールド(§8.3)、メソッド(§8.4)、クラスおよびインタフェース(§8.5)を含めることができます。

クラス本体には、インスタンス・イニシャライザ(§8.6)、静的イニシャライザ(§8.7)、およびクラスのコンストラクタの宣言(§8.8)を含めることもできます。

クラスCで宣言または継承されたメンバーmの宣言のスコープおよびシャドウ化は、§6.3および§6.4.1で指定されます。

Cがネストされたクラスである場合、包含スコープにmと同じ種類(変数、メソッドまたは型)および名前の定義が存在する可能性があります。 (スコープは、ブロック、クラスまたはパッケージです。) このような場合、Cで宣言または継承されたメンバーmは、同じ種類および名前のその他の定義をシャドウ化します。

すべてのクラスがクラス宣言によって示されるわけではありません。 次の構成要素により、クラスが暗黙的に宣言されます。

どの場合も、暗黙的に宣言されたクラスのメンバー(暗黙的に宣言されたメンバーなど)は、クラス内のメンバー宣言に関する通常のルールの対象になります。

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

コンパクト・コンパイル・ユニットによって暗黙的に宣言されたクラスは、次のプロパティを満たします。

このクラスが少なくとも1つの候補mainメソッド(§12.1.4)を宣言しない場合、コンパイル時にエラーが発生します。

なお、名前のないパッケージには、複数の暗黙的に宣言されたクラスがメンバーとして含まれている場合があります。

フィールド宣言の注釈修飾子に関する規則は、§9.7.4および§9.7.5に記載されています。

同じキーワードがフィールド宣言の修飾子として複数回出現する場合、またはフィールド宣言に複数のアクセス修飾子public、protectedおよびprivate (§6.6)がある場合、コンパイル時にエラーが発生します。

2つ以上の(個別)フィールド修飾子がフィールド宣言に表示される場合、FieldModifierの本番で前述したものと一致する順序で表示されることは、必須ではありませんが慣例です。

class Point {
    int x, y, useCount;
    Point(int x, int y) { this.x = x; this.y = y; }
    static final Point origin = new Point(0, 0);
}
class Test {
    public static void main(String[] args) {
        Point p = new Point(1,1);
        Point q = new Point(2,2);
        p.x = 3;
        p.y = 3;
        p.useCount++;
        p.origin.useCount++;
        System.out.println("(" + q.x + "," + q.y + ")");
        System.out.println(q.useCount);
        System.out.println(q.origin == Point.origin);
        System.out.println(q.origin.useCount);
    }
}

(2,2)
0
true
1

q.origin==Point.origin

p.origin.useCount++;

class Point {
    static int x = 2;
}
class Test extends Point {
    static double x = 4.7;
    public static void main(String[] args) {
        new Test().printX();
    }
    void printX() {
        System.out.println(x + " " + super.x);
    }
}

4.7 2

class Point {
    static int x = 2;
}
class Test extends Point {
    public static void main(String[] args) {
        new Test().printX();
    }
    void printX() {
        System.out.println(x + " " + super.x);
    }
}

2 2

class Point {
    int x = 2;
}
class Test extends Point {
    double x = 4.7;
    void printBoth() {
        System.out.println(x + " " + super.x);
    }
    public static void main(String[] args) {
        Test sample = new Test();
        sample.printBoth();
        System.out.println(sample.x + " " + ((Point)sample).x);
    }
}

4.7 2
4.7 2

class Point {
    static int x = 2;
}
class Test extends Point {
    void printBoth() {
        System.out.println(x + " " + super.x);
    }
    public static void main(String[] args) {
        Test sample = new Test();
        sample.printBoth();
        System.out.println(sample.x + " " + ((Point)sample).x);
    }
}

2 2
2 2

class Point {
    int x, y;
    transient float rho, theta;
}

class Test {
    static int i = 0, j = 0;
    static void one() { i++; j++; }
    static void two() {
        System.out.println("i=" + i + " j=" + j);
    }
}

class Test {
    static int i = 0, j = 0;
    static synchronized void one() { i++; j++; }
    static synchronized void two() {
        System.out.println("i=" + i + " j=" + j);
    }
}

class Test {
    static volatile int i = 0, j = 0;
    static void one() { i++; j++; }
    static void two() {
        System.out.println("i=" + i + " j=" + j);
    }
}

フィールド宣言の宣言子に変数イニシャライザがある場合、宣言子は宣言された変数への代入(§15.26)のセマンティクスを持ちます。

宣言子がクラス変数(つまり、staticフィールド) (§8.3.1.1)用である場合、次のルールがその初期化子に適用されます。

宣言子がインスタンス変数用(つまり、staticではないフィールド)の場合、次のルールがその初期化子に適用されます。

変数イニシャライザからまだ初期化されていないフィールドへの参照は、§8.3.3および§16 (Definite Assignment)で指定されているように制限されています。

フィールド宣言内の変数イニシャライザの例外チェックは、§11.2.3で規定されています。

変数イニシャライザは、ローカル変数宣言文(§14.4)でも使用されます。この文では、イニシャライザが評価され、ローカル変数宣言文が実行されるたびに割当てが実行されます。

class Point {
    int x = 1, y = 5;
}
class Test {
    public static void main(String[] args) {
        Point p = new Point();
        System.out.println(p.x + ", " + p.y);
    }
}

1, 5

class Test {
    float f = j;
    static int j = 1;
}

フィールドへの参照は、そのフィールドを介してスコープ内にある場合でも、制限されることがあります。 次のルールでは、フィールドへの前方参照(フィールド宣言の前にテキストを使用して使用)および自己参照(フィールドが独自のイニシャライザで使用される)を制約します。

クラスまたはインタフェースCで宣言されたクラス変数fへの単純名による参照の場合、次の場合にコンパイル時にエラーが発生します。

クラスCで宣言されたインスタンス変数fへの単純名による参照の場合、次の場合にコンパイル時にエラーが発生します。

class Test1 {
    int i = j;  // compile-time error:
                // incorrect forward reference
    int j = 1;
}

class Test2 {
    Test2() { k = 2; }
    int j = 1;
    int i = j;
    int k;
}

class Z {
    static int i = j + 2;
    static int j = 4;
}

class Z {
    static { i = j + 2; }
    static int i, j;
    static { j = 4; }
}

class Z {
    static int peek() { return j; }
    static int i = peek();
    static int j = 1;
}
class Test {
    public static void main(String[] args) {
        System.out.println(Z.i);
    }
}

0

class UseBeforeDeclaration {
    static {
        x = 100;
          // ok - assignment
        int y = x + 1;
          // error - read before declaration
        int v = x = 3;
          // ok - x at left hand side of assignment
        int z = UseBeforeDeclaration.x * 2;
          // ok - not accessed via simple name

        Object o = new Object() {
            void foo() { x++; }
              // ok - occurs in a different class
            { x++; }
              // ok - occurs in a different class
        };
    }

    {
        j = 200;
          // ok - assignment
        j = j + 1;
          // error - right hand side reads before declaration
        int k = j = j + 1;
          // error - illegal forward reference to j
        int n = j = 300;
          // ok - j at left hand side of assignment
        int h = j++;
          // error - read before declaration
        int l = this.j * 3;
          // ok - not accessed via simple name

        Object o = new Object() {
            void foo(){ j++; }
              // ok - occurs in a different class
            { j = j + 1; }
              // ok - occurs in a different class
        };
    }

    int w = x = 3;
      // ok - x at left hand side of assignment
    int p = x;
      // ok - instance initializers may access static fields

    static int u =
        (new Object() { int bar() { return x; } }).bar();
        // ok - occurs in a different class

    static int x;

    int m = j = 4;
      // ok - j at left hand side of assignment
    int o =
        (new Object() { int bar() { return j; } }).bar();
        // ok - occurs in a different class
    int j;
}

メソッドまたはコンストラクタのフォーマル・パラメータは、カンマ区切りパラメータ指定子のリストで指定されます(ある場合)。 各パラメータ指定子は、型(オプションとしてfinal修飾子または1つ以上の注釈、あるいはその両方)と、パラメータの名前を指定する識別子(オプションとしてカッコが続く)で構成されます。

メソッドまたはコンストラクタに仮パラメータがなく、レシーバ・パラメータもない場合は、メソッドまたはコンストラクタの宣言に空のカッコのペアが表示されます。

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

メソッドまたはコンストラクタの仮パラメータは、型に続く省略記号で示される変数引数パラメータです。 メソッドまたはコンストラクタには、最大1つの可変引数パラメータを指定できます。 可変引数パラメータが最後の位置を除くパラメータ指定子のリストの任意の場所にある場合、コンパイル時エラーになります。

VariableArityParameterの文法では、省略記号(...)はそれ自体に対するトークン(§3.11)であることに注意してください。 これと型の間には空白を入れることができますが、スタイルに関してはお薦めしません。

メソッドの最後の仮パラメータが可変アリティ・パラメータである場合、メソッドは変数アリティ・メソッドです。 それ以外の場合は、固定アリティ・メソッドです。

仮パラメータ宣言およびレシーバ・パラメータの注釈修飾子に関する規則は、§9.7.4および§9.7.5で指定されています。

仮パラメータ宣言の修飾子としてfinalが複数回出現した場合、コンパイル時にエラーが発生します。

仮パラメータの範囲とシャドウ化は、§6.3および §6.4で規定されています。

ネストされたクラスまたはインタフェース、またはラムダ式からの仮パラメータへの参照は、§6.5.6.1で指定されているように制限されます。

メソッドまたはコンストラクタの仮パラメータの宣言にはすべて識別子を含める必要があります。そうしないと、コンパイル時にエラーが発生します。

メソッドまたはコンストラクタが同じ名前で2つの仮パラメータを宣言すると、コンパイル時にエラーが発生します。 (つまり、その宣言には同じ識別子が記述されています。)

finalと宣言された仮パラメータがメソッドまたはコンストラクタの本体内で割り当てられている場合、コンパイル時にエラーが発生します。

仮パラメータの宣言型は、可変引数パラメータであるかどうかによって異なります:

変数Arityパラメータの宣言された型に、変更不可能な要素型(§4.7)がある場合、メソッドに@SafeVarargs (§9.6.4.7)の注釈が付けられているか、@SuppressWarnings (§9.6.4.5)によって警告が抑制されていないかぎり、変数Arityメソッドの宣言に対してコンパイル時の未チェックの警告が発生します。

メソッドまたはコンストラクタが呼び出されると(§15.12)、実際の引数式の値は、メソッドまたはコンストラクタの本体を実行する前に、新しく作成された各パラメータ変数(宣言された型)を初期化します。 FormalParameterに表示される識別子は、仮パラメータを参照するためにメソッドまたはコンストラクタの本体で単純名として使用できます。

可変引数メソッドの呼出しには、仮パラメータよりも多くの実引数式を含めることができます。 変数Arityパラメータの前の仮パラメータに対応しない実際の引数式がすべて評価され、メソッド呼出しに渡される配列に格納される結果(§15.12.4.2)が評価されます。

class Test {
    Test(/* ?? ?? */) {}
      // No receiver parameter is permitted in the constructor of
      // a top level class, as there is no conceivable type or name.

    void m(Test this) {}
      // OK: receiver parameter in an instance method

    static void n(Test this) {}
      // Illegal: receiver parameter in a static method

    class A {
        A(Test Test.this) {}
          // OK: the receiver parameter represents the instance
          // of Test which immediately encloses the instance
          // of A being constructed.

        void m(A this) {}
          // OK: the receiver parameter represents the instance
          // of A for which A.m() is invoked.

        class B {
            B(Test.A A.this) {}
              // OK: the receiver parameter represents the instance
              // of A which immediately encloses the instance of B
              // being constructed.

            void m(Test.A.B this) {}
              // OK: the receiver parameter represents the instance
              // of B for which B.m() is invoked.
        }
    }
}

2つのメソッドまたはコンストラクタMとNは、同じ名前、同じ型パラメータ(存在する場合) (§8.4.4)、およびNの仮パラメータ型をMの型パラメータ(同じ仮パラメータ型)に適応させた後、同じ仮パラメータ型を持つ同じシグネチャを持ちます。

次のいずれかの場合、メソッドm1のシグネチャは、メソッドm2のシグネチャのサブシグネチャです。

m1がm2のサブシグネチャであるか、m2がm1のサブシグネチャである場合、m1およびm2の2つのメソッド・シグネチャはオーバーライド等価です。

クラスでオーバーライド等価のシグネチャを持つ2つのメソッドを宣言すると、コンパイル時にエラーが発生します。

class Point {
    int x, y;
    abstract void move(int dx, int dy);
    void move(int dx, int dy) { x += dx; y += dy; }
}

副署名の概念は、署名が同一ではなく、一方が他方を上書きできる2つの方法間の関係を表現するように設計されています。 具体的には、汎用型を使用しないシグネチャを持つメソッドで、そのメソッドの生成済バージョンをオーバーライドできます。 これは、ライブラリ・デザイナが、ライブラリのサブクラスまたはサブインタフェースを定義するクライアントとは独立してメソッドを自由に生成できるようにするために重要です。

class CollectionConverter {
    List toList(Collection c) {...}
}
class Overrider extends CollectionConverter {
    List toList(Collection c) {...}
}

class CollectionConverter {
    <T> List<T> toList(Collection<T> c) {...}
}

メソッド宣言の注釈修飾子に関する規則は、§9.7.4および§9.7.5に記載されています。

同じキーワードがメソッド宣言の修飾子として複数回出現した場合、またはメソッド宣言に複数のアクセス修飾子public、protectedおよびprivate (§6.6)がある場合、コンパイル時にエラーが発生します。

キーワードabstractを含むメソッド宣言に、キーワードprivate、static、final、native、strictfpまたはsynchronizedのいずれかが含まれている場合、コンパイル時にエラーが発生します。

キーワードnativeを含むメソッド宣言にstrictfpも含まれている場合、コンパイル時にエラーが発生します。

2つ以上の(個別)メソッド修飾子がメソッド宣言に表示される場合、MethodModifierの本番で前述したものと一致する順序で表示されることは、必須ではありませんが慣例です。

class BufferEmpty extends Exception {
    BufferEmpty() { super(); }
    BufferEmpty(String s) { super(s); }
}
class BufferError extends Exception {
    BufferError() { super(); }
    BufferError(String s) { super(s); }
}
interface Buffer {
    char get() throws BufferEmpty, BufferError;
}
abstract class InfiniteBuffer implements Buffer {
    public abstract char get() throws BufferError;
}

abstract class Point {
    int x, y;
    public abstract String toString();
}

class ColoredPoint extends Point {
    int color;
    public String toString() {
        return super.toString() + ": color " + color;  // error
    }
}

abstract class Point {
    int x, y;
    public abstract String toString();
    protected String objString() { return super.toString(); }
}
class ColoredPoint extends Point {
    int color;
    public String toString() {
        return objString() + ": color " + color;  // correct
    }
}

final class Point {
    int x, y;
    void move(int dx, int dy) { x += dx; y += dy; }
}
class Test {
    public static void main(String[] args) {
        Point[] p = new Point[100];
        for (int i = 0; i < p.length; i++) {
            p[i] = new Point();
            p[i].move(i, p.length-1-i);
        }
    }
}

    for (int i = 0; i < p.length; i++) {
        p[i] = new Point();
        Point pi = p[i];
        int j = p.length-1-i;
        pi.x += i;
        pi.y += j;
    }

package java.io;
public class RandomAccessFile
    implements DataOutput, DataInput {
    . . .
    public native void open(String name, boolean writeable)
        throws IOException;
    public native int readBytes(byte[] b, int off, int len)
        throws IOException;
    public native void writeBytes(byte[] b, int off, int len)
        throws IOException;
    public native long getFilePointer() throws IOException;
    public native void seek(long pos) throws IOException;
    public native long length() throws IOException;
    public native void close() throws IOException;
}

class Test {
    int count;
    synchronized void bump() {
        count++;
    }
    static int classCount;
    static synchronized void classBump() {
        classCount++;
    }
}

class BumpTest {
    int count;
    void bump() {
        synchronized (this) { count++; }
    }
    static int classCount;
    static void classBump() {
        try {
            synchronized (Class.forName("BumpTest")) {
                classCount++;
            }
        } catch (ClassNotFoundException e) {}
    }
}

public class Box {
    private Object boxContents;
    public synchronized Object get() {
        Object contents = boxContents;
        boxContents = null;
        return contents;
    }
    public synchronized boolean put(Object contents) {
        if (boxContents != null) return false;
        boxContents = contents;
        return true;
    }
}

メソッドが1つ以上の型変数(§4.4)を宣言している場合、メソッドは汎用です。

これらの型変数は、メソッドの型パラメータと呼ばれます。 汎用メソッドの型パラメータ・セクションの形式は、汎用クラスの型パラメータ・セクション(§8.1.2)と同じです。

汎用メソッド宣言では、型引数による型パラメータ・セクションの呼出しごとに、一連のメソッドを定義します。 型引数は、一般メソッドが呼び出されたときに明示的に指定する必要がない場合があります。これは、一般メソッドが推測されることが多いためです(§18 (Type Inference))。

メソッドの型パラメータのスコープとシャドウは、§6.3および §6.4.1で指定されています。

ネストされたクラスまたはインタフェースからのメソッドの型パラメータへの参照は、§6.5.5.1で指定されているように制限されています。

次の両方に該当する場合は、2つのメソッドまたはコンストラクタMとNに同じ型パラメータがあります。

2つのメソッドまたはコンストラクタMとNが同じ型パラメータを持つ場合、前述のように型にθを適用することで、Nに記載されている型をMの型パラメータに適用できます。

メソッド宣言の結果は、メソッドが返す値の型を宣言するか(戻り型)、キーワードvoidを使用してメソッドが値を返さないことを示します。

結果がvoidでない場合、メソッドの戻り型は、仮パラメータ・リストの後にカッコのペアが存在しない場合はUnannTypeで示され、それ以外の場合は§10.2で指定されます。

戻り型が参照型の場合、戻り型は相互にオーバーライドするメソッド間で異なる場合があります。 return-type-substitutabilityの概念では、共変戻り値(つまり、戻り型をサブタイプに特殊化)がサポートされます。

次のいずれかに該当する場合、戻り型がR₁のメソッド宣言d1は、戻り型がR2の別のメソッドd2の_{return-type-substitutable}です。

非汎用コードから汎用コードへのスムーズな移行を可能にする特別な手当として、未チェックの変換が定義で許可されます。 未チェックの変換を使用して、R₁がR₂の戻り型置換可能であると判断した場合、R₁は必ずしもR₂のサブタイプではなく、オーバーライドするルール(§8.4.8.3、§9.4.1)には、コンパイル時の未チェックの警告が必要です。

throws句は、メソッドまたはコンストラクタ本体の文がスローできるチェックされた例外クラス(§11.1.1)を示すために使用されます(§11.2.2)。

throws句に記述されているExceptionTypeがThrowableのサブタイプ(§4.10)ではない場合、コンパイル時にエラーが発生します。

型変数は、catch句(§14.20)で許可されていない場合でも、throws句で許可されます。

throws句では、未チェックの例外クラス(§11.1.1)を指定することは許可されていますが、必須ではありません。

throws句とメソッドまたはコンストラクタ本体の例外チェックの関係は、§11.2.3に記載されています。

基本的に、メソッドまたはコンストラクタの本体の実行によって生じる可能性のあるチェックされた例外ごとに、その例外タイプまたは例外タイプのスーパータイプがメソッドまたはコンストラクタの宣言のthrows句で指定されていないかぎり、コンパイル時にエラーが発生します。

チェック例外を宣言する要件により、Javaコンパイラは、このようなエラー条件を処理するためのコードが含まれていることを確認できます。 本体でチェックされた例外としてスローされた例外条件を処理できないメソッドまたはコンストラクタは、通常、throws句に適切な例外型がない場合にコンパイル時エラーが発生します。 したがって、Javaプログラミング言語では、この方法で、まれで、そうでなければ真に例外的な条件が文書化されるプログラミング・スタイルが推奨されます。

メソッドのthrows句とオーバーライド・メソッドまたは非表示メソッドのthrows句の関係は、§8.4.8.3で指定します。

import java.io.FileNotFoundException;

interface PrivilegedExceptionAction<E extends Exception> {
    void run() throws E;
}
class AccessController {
    public static <E extends Exception>
    Object doPrivileged(PrivilegedExceptionAction<E> action) throws E {
        action.run();
        return "success";
    }
}
class Test {
    public static void main(String[] args) {
        try {
            AccessController.doPrivileged(
              new PrivilegedExceptionAction<FileNotFoundException>() {
                  public void run() throws FileNotFoundException {
                      // ... delete a file ...
                  }
              });
        } catch (FileNotFoundException f) { /* Do something */ }
    }
}

メソッド本体は、メソッドを実装するコードのブロックか、実装の欠如を示す単なるセミコロンです。

メソッドがabstractまたはnative (§8.4.3.1、§8.4.3.4)の場合、メソッドの本体はセミコロンである必要があります。 より正確には、次のようになります。

voidと宣言されたメソッドに対して実装が提供されるが、実装に実行可能コードが必要ない場合、メソッド本体は文を含まないブロックとして記述する必要があります: "{ }"。

メソッド本体内のreturn文のルールは、§14.17で指定します。

メソッドが戻り型(§8.4.5)を持つように宣言されている場合、メソッドの本文が正常に完了できるとコンパイル時エラーが発生します(§14.1)。

つまり、戻り値の型を持つメソッドは、値の戻り値を提供するreturn文を使用してのみ返す必要があります。このメソッドは、本体の終わりをドロップ・オフすることはできません。 メソッド本体のreturn文に関する正確な規則については、§14.17を参照してください。

class DizzyDean {
    int pitch() { throw new RuntimeException("90 mph?!"); }
}

直接スーパークラス型Dから継承されるクラスCは、次のすべてに当てはまるすべての具象メソッドm (staticとインスタンスの両方)を継承します。

クラスCは、その直接スーパークラス型から継承し、直接スーパーインタフェース型はすべてabstractおよびデフォルト(§9.4)メソッドmで、次のすべてに該当します。

インタフェースの継承は、§9.1.3で定義されています。

クラスは、そのスーパーインタフェース型からprivateまたはstaticメソッドを継承しません。

メソッドは、シグネチャごとにオーバーライドされるか、隠されます。 たとえば、クラスが同じ名前を持つ2つのpublicメソッド(§8.4.9)を宣言し、サブクラスがそのいずれかをオーバーライドした場合でも、サブクラスはもう一方のメソッドを継承します。

interface I1 {
    int foo();
}

interface I2 {
    int foo();
}

abstract class Test implements I1, I2 {}

継承された具象メソッドは、abstractまたはデフォルト・メソッドの継承を防ぐことができます。 (具体的なメソッドは、§8.4.8.1および§9.4.1.1に従って、Cからのabstractまたはデフォルト・メソッドをオーバーライドします。) また、あるスーパータイプ・メソッドが別のスーパータイプ・メソッドの継承を防ぐことができるのは、前のスーパータイプ・メソッドが後者をオーバーライドしている場合です。これは、インタフェース(§9.4.1)のルールと同じであり、複数のデフォルト・メソッドが継承され、一方の実装が他方のスーパータイプ・メソッドより優先される競合を回避するためです。

class Point {
    int x = 0, y = 0;
    void move(int dx, int dy) { x += dx; y += dy; }
}
class SlowPoint extends Point {
    int xLimit, yLimit;
    void move(int dx, int dy) {
        super.move(limit(dx, xLimit), limit(dy, yLimit));
    }
    static int limit(int d, int limit) {
        return d > limit ? limit : d < -limit ? -limit : d;
    }
}

import java.io.IOException;
import java.io.OutputStream;

class BufferOutput {
    private OutputStream o;
    BufferOutput(OutputStream o) { this.o = o; }
    protected byte[] buf = new byte[512];
    protected int pos = 0;
    public void putchar(char c) throws IOException {
        if (pos == buf.length) flush();
        buf[pos++] = (byte)c;
    }
    public void putstr(String s) throws IOException {
        for (int i = 0; i < s.length(); i++)
            putchar(s.charAt(i));
    }
    public void flush() throws IOException {
        o.write(buf, 0, pos);
        pos = 0;
    }
}
class LineBufferOutput extends BufferOutput {
    LineBufferOutput(OutputStream o) { super(o); }
    public void putchar(char c) throws IOException {
        super.putchar(c);
        if (c == '\n') flush();
    }
}
class Test {
    public static void main(String[] args) throws IOException {
        LineBufferOutput lbo = new LineBufferOutput(System.out);
        lbo.putstr("lbo\nlbo");
        System.out.print("print\n");
        lbo.putstr("\n");
    }
}

lbo
print
lbo

class Super {
    static String greeting() { return "Goodnight"; }
    String name() { return "Richard"; }
}
class Sub extends Super {
    static String greeting() { return "Hello"; }
    String name() { return "Dick"; }
}
class Test {
    public static void main(String[] args) {
        Super s = new Sub();
        System.out.println(s.greeting() + ", " + s.name());
    }
}

Goodnight, Dick

class C implements Cloneable {
    C copy() throws CloneNotSupportedException {
        return (C)clone();
    }
}
class D extends C implements Cloneable {
    D copy() throws CloneNotSupportedException {
        return (D)clone();
    }
}

class StringSorter {
    // turns a collection of strings into a sorted list
    List toList(Collection c) {...}
}

class Overrider extends StringSorter {
    List toList(Collection c) {...}
}

class StringSorter {
    // turns a collection of strings into a sorted list
    List<String> toList(Collection<String> c) {...}
}

class BadPointException extends Exception {
    BadPointException() { super(); }
    BadPointException(String s) { super(s); }
}
class Point {
    int x, y;
    void move(int dx, int dy) { x += dx; y += dy; }
}
class CheckedPoint extends Point {
    void move(int dx, int dy) throws BadPointException {
        if ((x + dx) < 0 || (y + dy) < 0)
            throw new BadPointException();
        x += dx; y += dy;
    }
}

class CheckedPoint extends Point {
    void move(int dx, int dy) {
        if ((x + dx) < 0 || (y + dy) < 0)
            throw new BadPointException();
        x += dx; y += dy;
    }
}

class C<T> {
    T id (T x) {...}
}
class D extends C<String> {
    Object id(Object x) {...}
}

class C<T> {
    T id(T x) {...}
}
interface I<T> {
    T id(T x);
}
class D extends C<String> implements I<Integer> {
   public String  id(String x)  {...}
   public Integer id(Integer x) {...}
}

class A<T> {
    void m(String s) {} // 1
    void m(T t) {} // 2
}
class C extends A<String> {}

クラスの2つのメソッド(同じクラスで宣言されたメソッド、またはクラスによって継承されたメソッド、または宣言されたメソッドと継承されたメソッドの両方)が同じ名前で、オーバーライド等価ではないシグネチャを持つ場合、メソッド名はオーバーロードされます。

この事実は難しくなく、それ自体ではコンパイル時にエラーが発生することはありません。 戻り型間、または同じ名前の2つのメソッドのthrows句の間には、シグネチャがオーバーライド等価でないかぎり、必要な関係はありません。

メソッドが呼び出されると(§15.12)、実際の引数の数(および明示的な型引数)、および引数のコンパイル時型がコンパイル時に、呼び出されるメソッドのシグネチャを決定するために使用されます(§15.12.2)。 呼び出されるメソッドがインスタンス・メソッドである場合、呼び出される実際のメソッドは、動的メソッド参照(§15.12.4)を使用して実行時に決定されます。

class Point {
    float x, y;
    void move(int dx, int dy) { x += dx; y += dy; }
    void move(float dx, float dy) { x += dx; y += dy; }
    public String toString() { return "("+x+","+y+")"; }
}

class Point {
    int x = 0, y = 0;
    void move(int dx, int dy) { x += dx; y += dy; }
    int color;
}
class RealPoint extends Point {
    float x = 0.0f, y = 0.0f;
    void move(int dx, int dy) { move((float)dx, (float)dy); }
    void move(float dx, float dy) { x += dx; y += dy; }
}

class Point {
    int x = 0, y = 0, color;
    void move(int dx, int dy) { x += dx; y += dy; }
    int getX() { return x; }
    int getY() { return y; }
}
class RealPoint extends Point {
    float x = 0.0f, y = 0.0f;
    void move(int dx, int dy) { move((float)dx, (float)dy); }
    void move(float dx, float dy) { x += dx; y += dy; }
    float getX() { return x; }
    float getY() { return y; }
}

class Point {
    int x = 0, y = 0;
    void move(int dx, int dy) { x += dx; y += dy; }
    int getX() { return x; }
    int getY() { return y; }
    int color;
}
class RealPoint extends Point {
    float x = 0.0f, y = 0.0f;
    void move(int dx, int dy) { move((float)dx, (float)dy); }
    void move(float dx, float dy) { x += dx; y += dy; }
    int getX() { return (int)Math.floor(x); }
    int getY() { return (int)Math.floor(y); }
}

class Test {
    public static void main(String[] args) {
        RealPoint rp = new RealPoint();
        Point p = rp;
        rp.move(1.71828f, 4.14159f);
        p.move(1, -1);
        show(p.x, p.y);
        show(rp.x, rp.y);
        show(p.getX(), p.getY());
        show(rp.getX(), rp.getY());
    }
    static void show(int x, int y) {
        System.out.println("(" + x + ", " + y + ")");
    }
    static void show(float x, float y) {
        System.out.println("(" + x + ", " + y + ")");
    }
}

(0, 0)
(2.7182798, 3.14159)
(2, 3)
(2, 3)

コンストラクタの仮パラメータは、構文およびセマンティクスにおいてメソッド(§8.4.1)の仮パラメータと同一です。

コンストラクタの最後の仮パラメータが可変引数パラメータの場合、コンストラクタは可変引数コンストラクタです。 それ以外の場合は、固定アリティ・コンストラクタです。

非private内部メンバー・クラスのコンストラクタは、最初の仮パラメータとして、クラスの直近のインスタンスを表す変数を暗黙的に宣言します(§15.9.2、§15.9.3)。

暗黙的に宣言されたコンストラクタ・パラメータを持つのは、この種のクラスのみである理由の根拠です。 次の説明が役立つ場合があります:

非private内部メンバー・クラスには、コンパイルされたものとは異なるコンパイラからアクセスできますが、内部ローカル・クラスまたは匿名クラスは、常に同じコンパイラからアクセスされます。非private内部メンバー・クラスのバイナリ名が予測可能であると定義されているが、内部ローカル・クラスまたは無名クラスのバイナリ名が予測可能ではない理由を説明する(§13.1)。

オーバーライド等価のシグネチャ(§8.4.2)を持つ2つのコンストラクタをクラスで宣言すると、コンパイル時にエラーが発生します。

クラス内で同じ消去(§4.6)を持つ署名を持つ2つのコンストラクタを宣言すると、コンパイル時にエラーが発生します。

コンストラクタ宣言の注釈修飾子に関する規則は、§9.7.4および§9.7.5で指定されています。

コンストラクタ宣言の修飾子として同じキーワードが複数回出現する場合、またはコンストラクタ宣言にアクセス修飾子public、protectedおよびprivate (§6.6)が複数存在する場合、コンパイル時にエラーが発生します。

通常のクラス宣言では、アクセス修飾子のないコンストラクタ宣言はパッケージ・アクセスを持ちます。

2つ以上の(個別)メソッド修飾子がメソッド宣言に表示される場合、MethodModifierの本番で前述したものと一致する順序で表示されることは、必須ではありませんが慣例です。

メソッドとは異なり、コンストラクタはabstract、static、final、native、strictfpまたはsynchronizedにできません。

コンストラクタは、1つ以上の型変数(§4.4)を宣言する場合、汎用です。

これらの型変数は、コンストラクタの型パラメータと呼ばれます。 汎用コンストラクタの型パラメータ・セクションの形式は、汎用クラスの型パラメータ・セクション(§8.1.2)と同じです。

コンストラクタが宣言されているクラス自体がジェネリックであるかどうかに関係なく、コンストラクタをジェネリックにすることができます。

ジェネリック・コンストラクタ宣言は、型引数によって型パラメータ・セクションが呼び出されるたびに、コンストラクタのセットを定義します。 型引数は、一般コンストラクタが呼び出されたときに明示的に指定する必要がない場合があります。これは、推測されることが多いためです(§18 (Type Inference))。

コンストラクタの型パラメータのスコープとシャドウは、§6.3および§6.4.1で指定されています。

コンストラクタの呼出しまたはネストされたクラスまたはインタフェースからのコンストラクタの型パラメータへの参照は、§6.5.5.1で指定されているように制限されます。

コンストラクタのthrows句の構造と動作は、メソッドのthrows句(§8.4.6)と同じです。

コンストラクタの型は、そのシグネチャと、そのthrows句で指定された例外型で構成されます。

コンストラクタ本体は、クラスの新しいインスタンスを作成するプロセスの一部として実行されるコードのブロックです(§12.5)。 コンストラクタ本体には、同じクラスまたは直接スーパークラス(§8.8.7.1)の別のコンストラクタの明示的な呼出しを含めることができます。

コンストラクタ本体に明示的なコンストラクタ呼出しが含まれている場合、コンストラクタ呼出しの前のBlockStatementsは、コンストラクタ本体のprologueと呼ばれます。 コンストラクタ本体のプロローグは空の場合があります。 明示的なコンストラクタ呼出しのないコンストラクタのBlockStatementsと、コンストラクタ本体でのコンストラクタ呼出しに続くBlockStatementsは、epilogueと呼ばれます。 コンストラクタ本体のエピローグも空の場合があります。

コンストラクト(文、ローカル変数宣言文、ローカル・クラス宣言、ローカル・インタフェース宣言または式)Cは、Cのコンストラクタ本体のプロローグに含まれている場合、またはCのコンストラクタ本体のコンストラクタ呼出し(§8.8.7.1)にネストされている場合に、クラスの初期構成コンテキストで発生します。

コンストラクタ本体に明示的なコンストラクタ呼出しが含まれておらず、宣言されているコンストラクタが原始クラスObjectの一部ではない場合、コンストラクタ本体(i)には空のprologueがあり、(ii)暗黙的にスーパークラスで始まりますコンストラクタ呼出し"super();"は、引数をとらない直接スーパークラスのコンストラクタの暗黙的な呼出しであり、(iii)コンストラクタ本体に指定された文(ある場合)は、コンストラクタ本体のエピローグを形成するために取得されます。

明示的または暗黙的なコンストラクタ呼出しの可能性、およびreturn文の禁止(§14.17)を除き、コンストラクタの本体はメソッドの本体と似ています(§8.4.7)。

コンストラクタ本体には、最大1つのコンストラクタ呼出しが含まれていることに注意してください。 文法では、たとえば、コンストラクタ呼出しをif文の異なるブランチに配置することは不可能です。

class Point {
    int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }
}
class ColoredPoint extends Point {
    static final int WHITE = 0, BLACK = 1;
    int color;
    ColoredPoint(int x, int y) {
        this(x, y, WHITE);
    }
    ColoredPoint(int x, int y, int color) {
        super(x, y);
        this.color = color;
    }
}

class Point {
    int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }
}
class ColoredPoint extends Point {
    static final int WHITE = 0, BLACK = 1;
    int color;
    ColoredPoint(int x, int y) {
        this(x, y, color);  // Changed to color from WHITE
    }
    ColoredPoint(int x, int y, int color) {
        super(x, y);
        this.color = color;
    }
}

class Outer {
    class Inner {}
}
class ChildOfInner extends Outer.Inner {
    ChildOfInner() { (new Outer()).super(); }
}

class Outer {
    int secret = 5;
    class Inner {
        int  getSecret()      { return secret; }
        void setSecret(int s) { secret = s; }
    }
}
class ChildOfInner extends Outer.Inner {
    ChildOfInner(Outer x) { x.super(); }
}

public class Test {
    public static void main(String[] args) {
        Outer x = new Outer();
        ChildOfInner a = new ChildOfInner(x);
        ChildOfInner b = new ChildOfInner(x);
        System.out.println(b.getSecret());
        a.setSecret(6);
        System.out.println(b.getSecret());
    }
}

5
6

コンストラクタのオーバーロードは、メソッドのオーバーロードと同じ動作です(§8.4.9)。 オーバーロードは、各クラス・インスタンス作成式(§15.9)によってコンパイル時に解決されます。

クラスにコンストラクタ宣言が含まれていない場合は、デフォルト・コンストラクタが暗黙的に宣言されます。 トップ・レベル・クラス、メンバー・クラスまたはローカル・クラスのデフォルト・コンストラクタの形式は次のとおりです。

匿名クラスのデフォルト・コンストラクタの形式は、§15.9.5.1で指定します。

デフォルト・コンストラクタが暗黙的に宣言されているが、スーパークラスに引数を取らず、throws句を持たないアクセス可能なコンストラクタがない場合、コンパイル時にエラーが発生します。

public class Point {
    int x, y;
}

public class Point {
    int x, y;
    public Point() { super(); }
}

package p1;
public class Outer {
    protected class Inner {}
}
package p2;
class SonOfOuter extends p1.Outer {
    void foo() {
        new Inner();  // compile-time access error
    }
}

クラスは、少なくとも1つのコンストラクタを宣言し、デフォルト・コンストラクタが作成されないようにし、すべてのコンストラクタをprivate (§6.6.1)と宣言することによって、クラス宣言外のコードがクラスのインスタンスを作成できないように設計できます。

同様に、publicクラスでは、少なくとも1つのコンストラクタを宣言し、publicアクセスを持つデフォルト・コンストラクタが作成されないようにし、publicまたはprotected (§6.6.2)のコンストラクタを宣言することによって、パッケージ外でのインスタンスの作成を防止できます。

class ClassOnly {
    private ClassOnly() { }
    static String just = "only the lonely";
}

package just;
public class PackageOnly {
    PackageOnly() { }
    String[] justDesserts = { "cheesecake", "ice cream" };
}

enum宣言の本体には、enum定数を含めることができます。 enum定数はenumクラスのインスタンスを定義します。

便宜上、§15.12の次の本番を示します。

enum定数宣言の注釈修飾子に関する規則は、§9.7.4および§9.7.5で指定されています。

EnumConstantのIdentifierは、enum定数を参照するために使用できるenumクラス(§8.9.3)の暗黙的なフィールドの名前を提供します。

列挙定数の後には引数を指定できます。この引数は、この項の後半で説明するように、クラスの初期化時に定数が作成されるときに列挙のコンストラクタに渡されます。 呼び出されるコンストラクタは、オーバーロード解決の通常のルール(§15.12.2)を使用して選択されます。 引数を省略すると、空の引数リストとみなされます。

enum定数のオプションのクラス本体は、匿名クラス(§15.9.5)を暗黙的に宣言します。i)は、直近のenumクラス(§8.1.4)の直接サブクラスであり、(ii)はfinal(§8.1.1.2)です。 クラス本文は、匿名クラスの通常のルールによって管理されます。特に、コンストラクタを含めることはできません。 これらのクラス本体で宣言されたインスタンス・メソッドは、包含するenumクラス(§8.4.8)内のアクセス可能なメソッドをオーバーライドする場合にのみ、包含するenumクラスの外部で呼び出すことができます。

enum定数のクラス本体がabstractメソッドを宣言する場合、コンパイル時にエラーが発生します。

各enum定数のインスタンスは1つのみであるため、2つのオブジェクト参照を比較する際に、少なくとも1つがenum定数を参照することがわかっている場合は、equalsメソッドのかわりに==演算子を使用することが許可されます。

Enumのequalsメソッドは、単に引数に対してsuper.equalsを呼び出して結果を返すfinalメソッドで、アイデンティティ比較を実行します。

列挙型定数に加えて、列挙型宣言の本文には、コンストラクタとメンバー宣言、およびインスタンスと静的なイニシャライザを含めることができます。

ここでは、便宜上、§8.1.7からの次のプロダクションを示します。

enum宣言の本体内のコンストラクタまたはメンバー宣言は、特に明記されていないかぎり、通常のクラス宣言の本体に存在していたかのようにenumクラスに適用されます。

列挙宣言のコンストラクタ宣言がpublicまたはprotected (§6.6)の場合、コンパイル時にエラーが発生します。

列挙宣言のコンストラクタ宣言にスーパークラス・コンストラクタ呼出し(§8.8.7.1)が含まれている場合、コンパイル時にエラーが発生します。

フィールドが定数変数(§4.12.4)でないかぎり、クラスのenum宣言でコンストラクタ、インスタンス・イニシャライザまたはインスタンス変数イニシャライザからenumクラスのstaticフィールドを参照するのはコンパイル時エラーです。

列挙宣言では、アクセス修飾子のないコンストラクタ宣言はprivateです。

コンストラクタ宣言のない列挙型宣言では、デフォルトのコンストラクタが暗黙的に宣言されます。 デフォルトのコンストラクタはprivateで、仮パラメータがなく、throws句もありません。

実際には、コンパイラは、enumクラスのデフォルト・コンストラクタでStringおよびintパラメータを宣言することで、Enumクラスをミラー化します。 ただし、異なるコンパイラがデフォルト・コンストラクタの形式に同意する必要がないため、これらのパラメータは"暗黙のうちに宣言された"として指定されません。 enum宣言のコンパイラのみがenum定数のインスタンス化方法を認識します。他のコンパイラでは、これらのフィールドの初期化方法に関係なく、暗黙的に宣言されたenumクラス(§8.9.3)のpublic staticフィールドにのみ依存できます。

Eに少なくとも1つのenum定数があり、すべてのEのenum定数にmの具体的な実装を提供するクラス本体がある場合を除き、enum宣言Eにabstractメソッドmがメンバーとして含まれている場合は、コンパイル時にエラーが発生します。

enum宣言でファイナライザ(§12.6)を宣言すると、コンパイル時にエラーが発生します。 enumクラスのインスタンスはファイナライズできません。

enum Coin {
    PENNY(1), NICKEL(5), DIME(10), QUARTER(25);
    Coin(int value) { this.value = value; }

    private final int value;
    public int value() { return value; }
}

import java.util.HashMap;
import java.util.Map;

enum Color {
    RED, GREEN, BLUE;
    Color() { colorMap.put(toString(), this); }

    static final Map<String,Color> colorMap =
        new HashMap<String,Color>();
}

import java.util.HashMap;
import java.util.Map;

enum Color {
    RED, GREEN, BLUE;

    static final Map<String,Color> colorMap =
        new HashMap<String,Color>();
    static {
        for (Color c : Color.values())
            colorMap.put(c.toString(), c);
    }
}

enumクラスEのメンバーは、次のすべてです。

次に、enumクラスEの宣言には、Eのenum定数に対応する暗黙的に宣言されたフィールドと競合するフィールドや、暗黙的に宣言されたメソッドと競合するメソッドや、クラスEnum<E>のfinalメソッドをオーバーライドするフィールドを含めることはできません。

public class Test {
    enum Season { WINTER, SPRING, SUMMER, FALL }

    public static void main(String[] args) {
        for (Season s : Season.values())
            System.out.println(s);
    }
}

WINTER
SPRING
SUMMER
FALL

class Test {
    enum CoinColor { COPPER, NICKEL, SILVER }

    static CoinColor color(Coin c) {
        switch (c) {
            case PENNY:
                return CoinColor.COPPER;
            case NICKEL:
                return CoinColor.NICKEL;
            case DIME: case QUARTER:
                return CoinColor.SILVER;
            default:
                throw new AssertionError("Unknown coin: " + c);
        }
    }

    public static void main(String[] args) {
        for (Coin c : Coin.values())
            System.out.println(c + "\t\t" +
                               c.value() + "\t" + color(c));
    }
}

PENNY           1       COPPER
NICKEL          5       NICKEL
DIME            10      SILVER
QUARTER         25      SILVER

enum Operation {
    PLUS {
        double eval(double x, double y) { return x + y; }
    },
    MINUS {
        double eval(double x, double y) { return x - y; }
    },
    TIMES {
        double eval(double x, double y) { return x * y; }
    },
    DIVIDED_BY {
        double eval(double x, double y) { return x / y; }
    };

    // Each constant supports an arithmetic operation
    abstract double eval(double x, double y);

    public static void main(String[] args) {
        double x = Double.parseDouble(args[0]);
        double y = Double.parseDouble(args[1]);
        for (Operation op : Operation.values())
            System.out.println(x + " " + op + " " + y +
                               " = " + op.eval(x, y));
    }
}

java Operation 2.0 4.0
2.0 PLUS 4.0 = 6.0
2.0 MINUS 4.0 = -2.0
2.0 TIMES 4.0 = 8.0
2.0 DIVIDED_BY 4.0 = 0.5

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

class Card implements Comparable<Card>,
                      java.io.Serializable {
    public enum Rank { DEUCE, THREE, FOUR, FIVE, SIX, SEVEN,
                       EIGHT, NINE, TEN,JACK, QUEEN, KING, ACE }

    public enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES }

    private final Rank rank;
    private final Suit suit;
    public Rank rank() { return rank; }
    public Suit suit() { return suit; }

    private Card(Rank rank, Suit suit) {
        if (rank == null || suit == null)
            throw new NullPointerException(rank + ", " + suit);
        this.rank = rank;
        this.suit = suit;
    }

    public String toString() { return rank + " of " + suit; }

    // Primary sort on suit, secondary sort on rank
    public int compareTo(Card c) {
        int suitCompare = suit.compareTo(c.suit);
        return (suitCompare != 0 ?
                    suitCompare :
                    rank.compareTo(c.rank));
    }

    private static final List<Card> prototypeDeck =
        new ArrayList<Card>(52);

    static {
        for (Suit suit : Suit.values())
            for (Rank rank : Rank.values())
                prototypeDeck.add(new Card(rank, suit));
    }

    // Returns a new deck
    public static List<Card> newDeck() {
        return new ArrayList<Card>(prototypeDeck);
    }
}

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

class Deal {
    public static void main(String[] args) {
        int numHands     = Integer.parseInt(args[0]);
        int cardsPerHand = Integer.parseInt(args[1]);
        List<Card> deck  = Card.newDeck();
        Collections.shuffle(deck);
        for (int i=0; i < numHands; i++)
            System.out.println(dealHand(deck, cardsPerHand));
    }

    /**
     * Returns a new ArrayList consisting of the last n
     * elements of deck, which are removed from deck.
     * The returned list is sorted using the elements'
     * natural ordering.
     */
    public static <E extends Comparable<E>>
    ArrayList<E> dealHand(List<E> deck, int n) {
        int          deckSize = deck.size();
        List<E>      handView = deck.subList(deckSize - n, deckSize);
        ArrayList<E> hand = new ArrayList<E>(handView);
        handView.clear();
        Collections.sort(hand);
        return hand;
    }
}

java Deal 4 3
[DEUCE of CLUBS, SEVEN of CLUBS, QUEEN of DIAMONDS]
[NINE of HEARTS, FIVE of SPADES, ACE of SPADES]
[THREE of HEARTS, SIX of HEARTS, TEN of SPADES]
[TEN of CLUBS, NINE of DIAMONDS, THREE of SPADES]

レコード・クラスのレコード・コンポーネント(存在する場合)は、レコード宣言のヘッダーで指定されます。 各レコード・コンポーネントは、(オプションで、1つ以上の注釈を前に付けます。)型と、レコード・コンポーネントの名前を指定する識別子で構成されます。 レコード・コンポーネントは、暗黙的に宣言されたprivateフィールドと、明示的にまたは暗黙的に宣言されたpublicアクセッサ・メソッド(§8.10.3)の2つのレコード・クラスのメンバーに対応します。

レコード・クラスにレコード・コンポーネントがない場合、レコード宣言のヘッダーに空のカッコのペアが表示されます。

レコード・コンポーネントは、変数アリティ・レコード・コンポーネントであり、タイプに続く省略記号で示されます。 1つのレコード・クラスに対して最大で1つの可変個引数レコード・コンポーネントが許可されています。 可変引数のレコード・コンポーネントが、最後の位置を除くレコード・コンポーネントのリストのどこかに出現した場合、コンパイル時エラーになります。

レコード・コンポーネントの注釈修飾子に関する規則は、§9.7.4および§9.7.5で指定されています。

レコード・コンポーネント上の注釈は、その注釈インタフェースがレコード・コンポーネント・コンテキスト(§9.6.4.1)に適用可能な場合、リフレクションを介して使用できます。 レコード・コンポーネントの注釈は、他のコンテキスト(§8.10.3、§8.10.4)で注釈インタフェースが適用可能な場合、レコード・クラスのメンバーおよびコンストラクタの宣言に個別に伝播されます。

レコード・コンポーネントのすべての宣言に識別子が含まれている必要があります。そうしないと、コンパイル時にエラーが発生します。

clone、finalize、getClass、hashCode、notify、notifyAll、toStringまたはwaitという名前のレコード・コンポーネントを持つレコード宣言では、コンパイル時にエラーが発生します。

これらは、Objectの引数なしのpublicメソッドおよびprotectedメソッドの名前です。 これらをレコード・コンポーネントの名前に禁止すると、様々な形で混乱を回避できます。 まず、すべてのレコード・クラスは、レコード・オブジェクト全体の表現を返すhashCodeおよびtoStringの実装を提供し、hashCodeまたはtoStringと呼ばれるレコード・コンポーネントのアクセッサ・メソッド(§8.10.3)として機能できず、レコード・クラスの外部からそのようなレコード・コンポーネントにアクセスする方法はありません。 同様に、一部のレコード・クラスではcloneおよび(残念ながら)finalizeの実装が提供されるため、cloneまたはfinalizeというレコード・コンポーネントはアクセッサ・メソッドを介してアクセスできませんでした。 最後に、ObjectのgetClass、notify、notifyAllおよびwaitメソッドはfinalであるため、同じ名前のレコード・コンポーネントにアクセッサ・メソッドを使用できませんでした。 (アクセッサ・メソッドは、finalメソッドと同じシグネチャを持つため、オーバーライドは失敗します。)

レコード宣言に同じ名前の2つのレコード・コンポーネントを含めると、コンパイル時にエラーが発生します。

レコード・コンポーネントの宣言された型は、それが可変引数レコード・コンポーネントであるかどうかに応じて異なります:

変数Arityレコード・コンポーネントの宣言された型に、変更不可能な要素型(§4.7)がある場合、正規コンストラクタ(§8.10.4)に@SafeVarargs (§9.6.4.7)の注釈が付けられているか、または@SuppressWarnings (§9.6.4.5)によって警告が抑制されていないかぎり、変数Arityレコード・コンポーネントの宣言に対してコンパイル時の未チェックの警告が発生します。

レコード宣言の本文には、コンストラクタ、メンバー宣言および静的初期化子を含めることができます。

ここでは、便宜上、§8.1.7からの次のプロダクションを示します。

CompactConstructorDeclaration句については、§8.10.4.2で説明します。

レコード宣言の本体にstatic以外のフィールド宣言(§8.3.1.1)を含めると、コンパイル時にエラーが発生します。

レコード宣言の本体に、abstractまたはnative (§8.4.3.1、§8.4.3.4)のメソッド宣言が含まれている場合は、コンパイル時にエラーが発生します。

レコード宣言の本体にインスタンス・イニシャライザ(§8.6)を含めると、コンパイル時にエラーが発生します。

レコード コンポーネントごとに、レコード クラスには、レコード コンポーネントと同じ名前のフィールドがあり、レコード コンポーネントの宣言タイプと同じタイプを持ちます。 このフィールドは暗黙的に宣言され、コンポーネント・フィールドと呼ばれます。

コンポーネント・フィールドは、private、finalおよびstatic以外です。

コンポーネント・フィールドには、対応するレコード・コンポーネントに表示され、その注釈インタフェースがフィールド宣言コンテキストまたはタイプ・コンテキスト(§9.7.4)に適用可能な注釈(ある場合)が付けられます。

さらに、レコード・コンポーネントごとに、レコード・クラスには、レコード・コンポーネントと同じ名前のメソッドと空の仮パラメータ・リストがあります。 このメソッドは、明示的または暗黙的に宣言され、アクセッサ・メソッドと呼ばれます。

レコード・コンポーネントのアクセッサ・メソッドが明示的に宣言されている場合、次のすべてがtrueである必要があり、そうでない場合はコンパイル時にエラーが発生します。

レコード・クラスに、アクセッサ・メソッドが明示的に宣言されていないレコード・コンポーネントがある場合、そのレコード・コンポーネントのアクセッサ・メソッドは、次のプロパティを使用して暗黙的に宣言されます。

レコード・コンポーネント名(§8.10.1)の制限は、暗黙的に宣言されたアクセッサ・メソッドに、クラスObjectのprivate以外のメソッドとオーバーライド等価のシグネチャがないことを意味します。 public void wait() {...}など、制限された名前の1つを取る明示的なメソッド宣言は、waitがレコード・コンポーネント名ではないため、アクセッサ・メソッドではありません。

レコード・コンポーネントに表示される注釈は、そのレコード・コンポーネントに対して明示的に宣言されたアクセッサ・メソッドには伝播されません。 状況によっては、プログラマは明示的に宣言されたアクセッサ・メソッドでレコード・コンポーネントの注釈を複製する必要がある場合がありますが、これは一般的には必要ありません。

暗黙的に宣言されたアクセッサ・メソッドに伝播される注釈は、法的に注釈が付けられたメソッドになる必要があります。 たとえば、次のレコード宣言では、暗黙的に宣言されたアクセッサ・メソッドx()に@SafeVarargsの注釈が付けられますが、このような注釈は固定アリティ・メソッド(§9.6.4.7)では無効です。

record BadRecord(@SafeVarargs int x) {}  // Error

コンポーネント・フィールドとアクセッサ・メソッドのスコープとシャドウは、§6.3および§6.4.1で指定されています。 (対応するレコード・コンポーネントは宣言ではないため、独自のスコープはありません。)

レコード・クラスは、アクセッサ・メソッド以外のインスタンス・メソッドを明示的に宣言できますが、インスタンス変数を明示的に宣言することはできません(§8.10.2)。 クラス・メソッドおよびクラス変数の明示的な宣言が許可されます。

レコード・クラスのすべてのメンバー(暗黙的に宣言されたメンバーを含む)は、クラス内のメンバー宣言の通常のルールに従います(§8.3、§8.4、§8.5)。

通常のクラスに適用される継承に関するすべてのルールは、レコード・クラスに適用されます。 特に、レコード・クラスはスーパーインタフェースからメンバーを継承する場合がありますが、スーパーインタフェース・メソッドはアクセッサ・メソッドとして継承されることはありません。これは、レコード・クラスは、スーパーインタフェース・メソッドをオーバーライドするアクセッサ・メソッドを常に明示的または暗黙的に宣言するためです。

たとえば、レコード・クラスは直接スーパーインタフェースからデフォルト・メソッドを継承できますが、デフォルトのメソッド本体にはレコード・クラスのコンポーネント・フィールドは認識されません。 次のプログラムは、Loggedを出力します。

public class Test {
    interface Logging {
        default void logAction() {
            System.out.println("Logged");
        }
    }

    record Point(int i, int j) implements Logging {}

    public static void main(String[] args) {
        Point p = new Point(10, 20);
        p.logAction();
    }
}

レコード・クラスは、クラスRecordで宣言されたすべてのabstractメソッドの実装を提供します。 次の各メソッドについて、レコード・クラスRが同じ修飾子、名前およびシグネチャを持つメソッドを明示的に宣言しない場合(§8.4.2)、メソッドは次のように暗黙的に宣言されます。

等価、ハッシュ・コード値および文字列表現は、アクセッサ・メソッドを呼び出すのではなく、コンポーネント・フィールドの値を直接調べることによって決定されることに注意してください。

コンポーネントc1、...、cn、およびすべてのコンポーネントに対して暗黙的に宣言されたアクセッサ・メソッド、および暗黙的に宣言されたequalsメソッドを持つレコード・クラスRについて考えてみます。 Rのインスタンスr1が次のようにコピーされた場合:

R r2 = new R(r1.c1(), r1.c2(), ..., r1.cn());

この場合、r1がNULL参照でないと仮定すると、式r1.equals(r2)がtrueと評価されるのは常に同じです。 明示的に宣言されたアクセッサ・メソッドおよびequalsメソッドは、この不変条件を考慮する必要があります。 一般に、明示的に宣言されたメソッドが不変条件を尊重するかどうかをコンパイラでチェックすることはできません。 次のレコード宣言は、そのアクセッサ・メソッドがxおよびyコンポーネントをクリップするため、p3がequalsからp1にならないようにするため、不適切なスタイルです。

record SmallPoint(int x, int y) {
    public int x() { return this.x < 100 ? this.x : 100; }
    public int y() { return this.y < 100 ? this.y : 100; }

    public static void main(String[] args) {
        SmallPoint p1 = new SmallPoint(200,300);
        SmallPoint p2 = new SmallPoint(200,300);
        System.out.println(p1.equals(p2));  // prints true

        SmallPoint p3 = new SmallPoint(p1.x(), p1.y());
        System.out.println(p1.equals(p3));  // prints false
    }
}

レコード・コンポーネントを適切に初期化するために、レコード・クラスはデフォルト・コンストラクタ(§8.8.9)を暗黙的に宣言しません。 かわりに、レコード・クラスには、レコード・クラスのすべてのコンポーネント・フィールドを初期化する正規コンストラクタが明示的にまたは暗黙的に宣言されています。

レコード宣言で標準コンストラクタを明示的に宣言するには、2つの方法があります。1つは、適切なシグネチャ(§8.10.4.1)で標準コンストラクタを宣言するか、またはコンパクト・コンストラクタ(§8.10.4.2)を宣言する方法です。

標準的なコンストラクタのシグネチャと、コンパクト・コンストラクタ用に導出されたシグネチャを考慮すると、コンストラクタ・シグネチャのルール(§8.8.2)は、レコード宣言に正規およびコンパクト・コンストラクタとして修飾される通常のコンストラクタの両方がある場合、コンパイル時エラーであることを意味します。

どちらにしても、明示的に宣言された標準コンストラクタでは、次のように、少なくともレコード・クラスと同じくらいのアクセスを提供する必要があります。

明示的に宣言された正規コンストラクタは、固定アリティ・コンストラクタまたは可変アリティ・コンストラクタ(§8.8.1)です。

レコード・クラスRの宣言で正規コンストラクタが明示的に宣言されていない場合、正規コンストラクタrは、次のプロパティを使用してRで暗黙的に宣言されます。

レコード・クラスの派生仮パラメータ・リストは、次のようにレコード・ヘッダーの各レコード・コンポーネントから仮パラメータを順番に導出することによって形成されます。

レコード宣言には、標準コンストラクタではないコンストラクタの宣言が含まれている場合があります。 レコード宣言内のすべての非正規コンストラクタの本体には、代替コンストラクタ呼出し(§8.8.7.1)が含まれている必要があります。そうでない場合、コンパイル時にエラーが発生します。

import java.lang.annotation.Target;
import java.lang.annotation.ElementType;

@interface Foo {}
@interface Bar {}

record Person(@Foo String name) {
    Person(@Bar String name) {
        this.name = name;
    }
}

record Rational(int num, int denom) {
    private static int gcd(int a, int b) {
        if (b == 0) return Math.abs(a);
        else return gcd(b, a % b);
    }

    Rational {
        int gcd = gcd(num, denom);
        num    /= gcd;
        denom  /= gcd;
    }
}

Rational(int num, int denom) {
    int gcd = gcd(num, denom);
    num    /= gcd;
    denom  /= gcd;
    this.num   = num;
    this.denom = denom;
}