8. クラス

クラス宣言(class declaration)は，新しい参照型を定義し，その実装方法を記述する(8.1)。

入れ子クラス（nested class）は，他のクラス又はインタフェースの本体内で宣言されたクラスとする。最上位クラス（top level class）は，入れ子クラスでないクラスとする。

ここでは，最上位(7.6) ，入れ子(メンバクラス(8.5, 9.5)，局所クラス(14.3) 及び匿名クラス(15.9.5)を含め)すべてのクラスの共通意味論を論じる。特定の種類のクラスに特有の詳細は，それぞれの節で論じる。

名前付きクラスは，abstract宣言(8.1.1.1)してよい。クラスが完全に実装されていない場合は，abstract宣言しなければならない。これらのクラスは，インスタンス化できないが，下位クラスで拡張できる。クラスをfinal宣言 (8.1.1.2)してよい。この場合は，下位クラスをもつことができない。クラスをpublic宣言すれば，そのクラスは，他のパッケージから参照できる。

Object以外の各クラスは，既存のある一つのクラスの拡張（つまり下位クラス(8.1.3)）とし，インタフェース(8.1.4)を実装してよい。

クラスの本体では，メンバ（フィールド，メソッド，入れ子クラス及びインタフェース），静的初期化子及びコンストラクタ(8.1.5)を宣言する。メンバ(8.2)の有効範囲(6.3)は，メンバが属するクラス宣言全体とする。フィールド，メソッド及びコンストラクタの宣言は，アクセス修飾子(6.6)public, protected及びprivateを含むことができる。クラスのメンバは，宣言されたメンバ及び継承されたメンバ(8.2)の両方を含む。新しく宣言したフィールドは，上位クラス又は上位インタフェースで宣言された（同名の）フィールドを隠ぺいできる。新しく宣言したクラスメンバ及びインタフェースメンバは，上位クラス又は上位インタフェースで宣言されたクラスメンバ又はインタフェースメンバを隠ぺいできる。新しく宣言したメソッドは，上位クラス又は上位インタフェースで宣言されたメソッドを隠ぺい，実装又は上書きすることができる。

フィールド宣言(8.3)は，一度だけ具体化されるクラス変数及びクラスのインスタンスごとに新規に具体化されるインスタンス変数を記述する。フィールドは，final宣言(8.3.1.2)してよい。この場合には，そのフィールドは，一度しか値を代入できない。すべてのフィールド宣言は，初期化子を記述してよい。

メンバクラス宣言(8.5)は，取り巻きクラスのメンバである入れ子クラスを記述する。メンバクラスは，取り巻きクラスのインスタンス変数にアクセスしない静的クラスか，又は，内部クラス(8.1.2)とする。

メンバインタフェース宣言(8.5)は，取り巻きクラスのメンバである入れ子インタフェースを記述する。

メソッド宣言(8.4)は，メソッド呼出し式(15.12)によって呼び出されるコードを記述する。クラスメソッドは，クラス型に関して呼び出される。インスタンスメソッドは，クラス型のインスタンスである特定のオブジェクトに関して呼び出される。実装方法が示されていないメソッドは，abstract宣言しなければならない。メソッドを final(8.4.3.3)宣言することもできる。この場合には，そのメソッドを隠ぺい又は上書きできない。メソッドは，プラットフォーム依存のnativeコード(8.4.3.4)で実装してよい。synchronized(8.4.3.6)メソッドは，synchronized文 (14.18)を使用したかのように，その本体を実行する前にオブジェクトを自動的にロックし，制御を戻す際にそのロックを自動的に解除する。このようにして，そのオブジェクトの動作を他のスレッド(17.)の動作と同期させることができる。

メソッド名は，オーバロード(8.4.7)してよい。

インスタンス初期化子(8.6)は，インスタンスが最初に生成される(15.9)ときに，そのインスタンスの初期化を支援するために使用される実行可能コードのブロックとする。

静的初期化子(8.7)は，クラスが最初にロードされるときに，そのクラスの初期化(12.4)を支援するために使用される実行可能コードのブロックとする。

コンストラクタ(8.8)は，メソッドと似ているが，メソッド呼出しで直接呼び出すことはできない。コンストラクタは，新しいクラスインスタンスを初期化するために使用する。メソッドと同様に，コンストラクタは，オーバロード(8.8.6)してよい。

8.1 クラス宣言

ClassDeclaration:
	ClassModifiersopt  class Identifier Superopt Interfacesopt ClassBody

8.1.1 クラス修飾子

ClassModifiers:
	ClassModifier
	ClassModifiers ClassModifier

ClassModifier: one of
	public protected private
	abstract static final strictfp

クラス宣言でクラス修飾子が複数個出現する場合は，必須ではないが，慣習的に，ClassModifierの前述の生成規則内の記述と矛盾しない順序で出現することとする。

8.1.1.1 abstractクラス

• Cが明示的にabstractメソッド(8.4.3)の宣言を含む。
• Cの上位クラスのいずれかがC 又はその上位クラスのいずれかで実装されないabstractメソッド(8.4.6.1)を宣言する。
• Cの直接的上位インタフェース(8.1.4)が（必然的にabstractとなる）メソッドを宣言又は継承しており，Cがそれを実装するメソッドを宣言も継承もしていない。

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() { }
}

クラスインスタンス生成式 (15.9)を使用して，abstractクラスのインスタンスを生成しようとすると，コンパイル時エラーが発生する。

したがって，前述の例に次の文を続けると，コンパイル時エラーとなる。

	Point p = new Point();

	Point p = new SimplePoint();

abstractクラスの下位クラスは，（それ自体がabstract宣言されていなければ）インスタンス化でき，その結果，abstractクラスのコンストラクタが実行され，そのクラスのインスタンス変数のフィールド初期化子が実行される。したがって，上の例では，SimplePointのインスタンス化によってPointのデフォルトコンストラクタ，並びにx及びyのフィールド初期化子が実行される。abstractであって，abstractメソッドをすべて実装する下位クラスを生成できないクラス型を宣言することは，コンパイル時エラーとする。この状況は，メンバとして，メソッドのシグネチャ(8.4.2)は同じだが返却値の型が異なる二つのabstractメソッドをクラスがもつときに発生する。

次の例の宣言は，コンパイル時エラーとなる。

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

クラス型は，実装を完了するためにその下位クラスが生成できるという意図がある場合に限り，abstract宣言しなければならない。 単にクラスのインスタンス化をできなくすることが目的ならば(8.8.8)，これを表現する適切な方法は，実引数なしのコンストラクタを宣言し，それにprivateを指定し，その呼出しを決して行わず，さらに他のコンストラクタを宣言しないこととする。 この形式のクラスは，通常，クラスメソッド及び変数を含む。 インスタンス化できないクラスの例としては，クラスMathがある。この宣言は，次のとおりとする。

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

}

8.1.1.2 finalクラス

finalクラスは，いかなる下位クラスももつことはないので，finalクラスのメソッドは，決して上書き(8.4.6.1)されることはない。

8.1.1.3 strictfpクラス

クラスのすべての変数初期化子，インスタンス初期化子，静的初期化子及びコンストラクタの中でのfloat及びdouble 式も明示的に FP厳密であることに注意。

8.1.2 内部クラス及び取り囲みインスタンス

この規則の説明に次の例を用いる。

class HasStatic{
	static int j = 100;
}
class Outer{
	class Inner extends HasStatic{
		static final x = 3;		// ok - compile-time constant
		static int y = 4; 		// compile-time error, an inner class
	}
	static class NestedButNotInner{
		static int z = 5; 		// ok, not an inner class
	}
	interface NeverInner{}		// interfaces are never inner
}

文又は式が静的文脈で出現する（occurs in a static context）必要十分条件は，その文又は式を取り囲む最内のメソッド，コンストラクタ，インスタンス初期化子，静的初期化子，フィールド初期化子，又は明示的コンストラクタ文が，静的メソッド，静的初期化子，静的変数の変数初期化子，又は明示的コンストラクタ呼出し文 (8.8.5)であることとする。

内部クラスC がクラスOの直接内部クラス（direct inner class of a class O）であるのは，O がC を直ちに字句的に取り囲むクラスであり，かつC の宣言が静的文脈に出現しない場合とする。クラスC がクラスO の内部クラス（inner class of class O） であるのは，O の直接内部クラスであるか，それとも，O の内部クラスの内部クラスである場合とする。

クラスO は，それ自身のゼロ番目の字句的取り囲みクラス（zeroth lexically enclosing class of itself）とする。クラスO がクラスCのn番目の字句的取り囲みクラス（nth lexically enclosing class of a class C）であるのは，C の n - 1番目の字句的取り囲みクラスを直ちに取り囲むクラスである場合とする。

クラスO の直接内部クラスC のインスタンスi は，i の直ちに取り囲むインスタンス（immediately enclosing instance）として知られるO のインスタンスと関連する。オブジェクトの直ちに取り囲むインスタンスは，存在するなら，そのオブジェクトが生成された(15.9.2)時に決定される。

オブジェクトo は，それ自身のゼロ番目の字句的取り囲みインスタンス（zeroth lexically enclosing instance of itself）とする。オブジェクトo がインスタンスiのn番目の字句的取り囲みインスタンスであるのは，i のn - 1番目の字句的取り囲みインスタンスを直ちに取り囲むインスタンスである場合とする。

内部クラスが字句的取り囲みクラスのメンバであるインスタンス変数を参照する時には，対応する字句的取り囲みインスタンスの変数が用いられる。字句的取り囲みクラスの未初期化最終 (4.5.4)フィールドは，内部クラスの内部で割り付けられてはならない。

宣言が静的文脈に出現する内部クラスI のインスタンスは，字句的取り囲みインスタンスをもたない。しかし，I が静的メソッド又は静的初期化子内部で直ちに宣言されるならば，I は取り囲みブロックをもつ。これは，I の宣言を字句的に取り囲む最内ブロック文とする。

さらに，それ自体クラスSO の直接内部クラスであるC のすべての上位クラスS については，Sに関してiの直ちに取り囲むインスタンス（the immediately enclosing instance of i with respect to S）として知られるi に関連するSO のインスタンスが存在する。そのクラスの直接的上位クラスに関してオブジェクトの直ちに取り囲むインスタンスは，もし存在するなら，明示的コンストラクタ呼出し文によって上位クラスコンストラクタが呼び出されるときに決定される。

内部クラスで使われるが宣言されていない局所変数，形式メソッド仮引数，又は，例外ハンドラ仮引数は，finalと宣言され，かつ，内部クラスの本体の前に確実に代入(16.)されねばならない。

内部クラスは，局所(14.3)，匿名(15.9.5)及び非静的メンバクラス(8.5)を含む。例を示す。

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;
		}
	}
}

宣言が静的文脈に出現しない内部クラスは，取り囲むクラスのインスタンス変数を自由に参照してよい。インスタンス変数は，常にインスタンスに関して定義される。取り囲むクラスのインスタンス変数の場合は，そのインスタンス変数はそのクラスの取り囲むインスタンスに関して定義されなければならない。例えば，上のクラスLocalは，クラスOuterの取り囲みインスタンスをもつ。さらに例をあげる。

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

8.1.3 上位クラス及び下位クラス

Super:
	extends ClassType

ClassType:
	TypeName

次に例を示す。

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

• クラスPointは，Objectの直接的下位クラスとする。
• クラスObjectは，クラスPointの直接的上位クラスとする。
• クラスColoredPointは，クラスPointの直接的下位クラスとする。
• クラスPointは，クラスColoredPointの直接的上位クラスとする。

下位クラス(subclass)の関係は，直接的下位クラス関係の推移的閉包(transitive closure)とする。 次のいずれかが真ならば，クラスA は，クラスC の下位クラスとする。

• A がC の直接的下位クラス。
• A がB の下位クラス及びB がC の下位クラスとなるクラスB が存在する。 ただし，この定義は，再帰的に適用される。

次に例を示す。

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

• クラスPointは，クラスColoredPointの上位クラスとする。
• クラスPointは，クラスColored3dPointの上位クラスとする。
• クラスColoredPointは，クラスPointの下位クラスとする。
• クラスColoredPointは，クラスColored3dPointの上位クラスとする。
• クラスColored3dPointは，クラスColoredPointの下位クラスとする。
• クラスColored3dPointは，クラスPointの下位クラスとする。

• C が，Tに直接依存する。
• C が，Tに依存する(9.1.2)インタフェースI に直接依存する。
• C が，T に(再帰的に定義を用いて)依存するクラス D に直接依存する。

次の例は，コンパイル時エラーを発生する。

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

クラスをロード(12.2)する際，実行時に循環的に宣言されたクラ スを検出した場合，ClassCircularityErrorが投げられる。

8.1.4 上位インタフェース

Interfaces:
	implements InterfaceTypeList

InterfaceTypeList:
	InterfaceType
	InterfaceTypeList , InterfaceType

InterfaceType:
	TypeName

一つのimplements節の中で同じインタフェースが2回以上指定されている場合，コンパイル時エラーが発生する。

たとえインタフェースが違った形式で名前付けされていても，これが真となる。次に例を示す。

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

次の条件のいずれかが真ならば，インタフェース型I は，クラス型C の上位インタフェース(superinterface)とする。

• I がC の直接的上位インタフェースとなる。
• C が直接的上位インタフェースJ をもち，9.1.2で与えられる"インタフェースの上位インタフェース"の定義を使ってI がその上位インタフェースとなる。
• I がC の直接的上位クラスの上位インタフェースとなる。

例を示す。

public interface Colorable {
	void setColor(int color);
	int getColor();
}
public interface Paintable extends Colorable {
	int MATTE = 0, GLOSSY = 1;
	void setFinish(int finish);
	int 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 
{
	int finish;
	public void setFinish(int finish) {
		this.finish = finish;
	}
	public int getFinish() { return finish; }
}

• インタフェースPaintableは，クラスPaintedPointの上位インタフェースとする。
• インタフェースColorableは，クラスColoredPoint及びクラスPaintedPointの上位インタフェースとする。
• 9.1.2の定義に従って，インタフェース Paintableは，インタフェースColorableの下位インタフェースとし，さらに，Colorableは，Paintableの上位インタフェースとする。

宣言しようとしているクラスがabstractでない場合，各々の直接的上位インタフェースで定義されたメソッドの宣言は，このクラス内での宣言によって実装するか，又は直接的上位クラスから継承された既存のメソッドの宣言によって実装しなければならない。 その理由は，abstractでないクラスは，abstractなメソッド(8.1.1.1)をもつことができないことによる。

そこで，次の例は，コンパイル時エラーを引き起こす。

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?
	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; }
}

8.1.5 クラス本体及びメンバ宣言

ClassBody:
	{ ClassBodyDeclarationsopt }

ClassBodyDeclarations:
	ClassBodyDeclaration
	ClassBodyDeclarations ClassBodyDeclaration

ClassBodyDeclaration:
	ClassMemberDeclaration
	InstanceInitializer
	StaticInitializer
	ConstructorDeclaration

ClassMemberDeclaration:
	FieldDeclaration
	MethodDeclaration
	ClassDeclaration						
	InterfaceDeclaration
	;

C そのものが入れ子クラスなら，取り囲む有効範囲においてmのための同種（変数，メソッド，又は型）の定義がある。 (有効範囲は，ブロック，クラス，又はパッケージでよい。) これらの場合，C で宣言又は継承されたメンバ m は，mのほかの定義をおおい隠す。(6.3.1)

8.2 クラスのメンバ

• 直接的上位クラス(8.1.3)から継承されたメンバ。 ただし，直接的上位クラスをもたないクラスObjectは除く。
• 任意の直接的上位インタフェース(8.1.4)から継承されたメンバ。
• クラス本体(8.1.5)で宣言されたメンバ。

コンストラクタ，静的初期化子及びインスタンス初期化子は，メンバではないので，継承されない。

例を示す。

class Point {
	int x, y;
	private Point() { reset(); }
	Point(int x, int y) { this.x = x; this.y = y; }
	private void reset() { this.x = 0; this.y = 0; }
}
class ColoredPoint extends Point {
	int color;
	void clear() { reset(); }		// error
}
class Test {
	public static void main(String[] args) {
		ColoredPoint c = new ColoredPoint(0, 0);	// error
		c.reset();			// error
	}
}

• ColoredPointは，main内で要求されている二つの整数仮引数付きで宣言されたコンストラクタをもたないので，エラーが発生する。これは，ColoredPointが，その上位クラスPointのコンストラクタを継承していない事実を示す。
• ColoredPointが，コンストラクタを宣言していないこと，そのためにデフォルトコンストラクタが自動的に生成(8.8.7)されること及びそのデフォルトコンストラクタが

  	ColoredPoint() { super(); }
  

  に等価なことのために，もう一つのエラーが発生する。このとき，このコンストラクタは，クラスColoredPointの直接的上位クラスに対するコンストラクタを実引数なしで呼び出す。 エラーは，実引数を取らないPointのコンストラクタが，private宣言されているために，たとえ上位クラスのコンストラクタ呼出し(8.8.5)であっても，クラスPointの外部からアクセスできないことにある。 クラスPointのメソッドresetが private宣言されているので，クラスColoredPointで継承されないために，さらに二つのエラーが発生する。つまり，クラスColoredPointのメソッドclear及びクラスTestのメソッドmain内でのresetのメソッド呼出しは，正しくない。

8.2.1 継承の例

8.2.1.1 例: デフォルトアクセスを伴った継承

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

package points;
public class Point3d extends Point {
	int z;
	public void move(int dx, int dy, int dz) {
		x += dx; y += dy; z += dz;
	}
}

import points.Point3d;
class Point4d extends Point3d {
	int w;
	public void move(int dx, int dy, int dz, int dw) {
		x += dx; y += dy; z += dz; w += dw; // compile-time errors
	}
}

3番目のコンパイル単位の正しい記述は，次のとおりとする。

import points.Point3d;
class Point4d extends Point3d {
	int w;
	public void move(int dx, int dy, int dz, int dw) {
		super.move(dx, dy, dz); w += dw;
	}
}

8.2.1.2 public及びprotectedを伴った継承

package points;
public class Point {
	public int x, y;
	protected int useCount = 0;
	static protected int totalUseCount = 0;
	public void move(int dx, int dy) {
		x += dx; y += dy; useCount++; totalUseCount++;
	}
}

したがって，他のパッケージ内の次のプログラムは，正常にコンパイルできる。

class Test extends points.Point {
	public void moveBack(int dx, int dy) {
		x -= dx; y -= dy; useCount++; totalUseCount++;
	}
}

8.2.1.3 privateを伴った継承

class Point {
	int x, y;
	void move(int dx, int dy) {
		x += dx; y += dy; totalMoves++;
	}
	private static int totalMoves;
	void printMoves() { System.out.println(totalMoves); }
}
class Point3d extends Point {
	int z;
	void move(int dx, int dy, int dz) {
		super.move(dx, dy); z += dz; totalMoves++;
	}
}

8.2.1.4 アクセス不可能クラスのメンバへのアクセス

次のコンパイル単位を考える。

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

package morePoints;
class Point3d extends points.Point {
	public int z;
	public void move(int dx, int dy, int dz) {
		super.move(dx, dy); z += dz;
	}
	public void move(int dx, int dy) {
		move(dx, dy, 0);
	}
}
public class OnePoint {
	public static points.Point getOne() { 
		return new Point3d(); 
	}
}

クラスPoint3dのフィールドzは， publicなのだが，型Pointの変数pでクラスPoint3dのインスタンスへの参照だけが与えられているために，パッケージmorePointsの外のコードからは，このフィールドにアクセスできない。pは，型Pointをもつこと及びクラスPointが名前zのフィールドをもたないこと，のために，式p.zは正しくない。クラス型Point3dは，パッケージmorePointsの外からは参照できないので，式((Point3d)p).zも正しくない。

しかし，フィールドzのpublic宣言が無意味なわけではない。パッケージmorePointsにクラスPoint3dのpublicな下位クラスPoint4dが存在すれば，クラスPoint4dは，フィールドzを継承する。

package morePoints;
public class Point4d extends Point3d {
	public int w;
	public void move(int dx, int dy, int dz, int dw) {
		super.move(dx, dy, dz); w += dw;
	}
}

8.3 フィールド宣言

FieldDeclaration:
	FieldModifiersopt Type VariableDeclarators ;

VariableDeclarators:
	VariableDeclarator
	VariableDeclarators , VariableDeclarator

VariableDeclarator:
	VariableDeclaratorId
	VariableDeclaratorId = VariableInitializer

VariableDeclaratorId:
	Identifier
	VariableDeclaratorId [ ]

VariableInitializer:
	Expression
	ArrayInitializer
	

一つのクラス宣言の本体に，同じ名前をもつ二つのフィールドの宣言が含まれる場合は，コンパイル時エラーとする。 メソッド，型及びフィールドは，同じ名前をもってよい。 その理由は，それらは，異なった文脈で使用されること及び異なる検索手順によってあいまいさが解消されるからとする(6.5)。

クラスがある特定の名前をもつフィールドを宣言した場合，そのクラスの上位クラス及び上位インタフェースの中の，それと同じ名前をもつありとあらゆるアクセス可能なフィールドの宣言を隠ぺい(hide)すると呼ぶ。フィールド宣言は，また，取り囲むクラス又はインタフェースの任意のアクセス可能フィールド，ならびに，取り囲むブロックの同じ名前をもつ局所変数，形式メソッド仮引数及び例外ハンドラ仮引数の宣言をおおい隠す(6.3.1)。

あるフィールド宣言が他のフィールド宣言を隠ぺいする場合，その二つのフィールドが同じ型をもつ必要はない。

クラスは，その直接的上位クラス及び直接的上位インタフェースから，そのクラス内のコードでアクセス可能であり，そのクラス内の宣言で隠ぺいされていない，上位クラス及び上位インタフェースの中のすべての非privateフィールドを継承する。

上位クラスのprivateフィールドは下位クラスからアクセス可能なことに注意せよ。 (例えば，両方のクラスが同じクラスのメンバである場合。) それにもかかわらず，privateフィールドは，決して下位クラスに継承されない。

クラスは，同じ名前をもつ複数のフィールドを継承できる(8.3.3.3)。 これだけでは，コンパイル時エラーにはならない。 しかしながら，クラス本体内で，それらのフィールドを単純名で参照すると，それらの参照は，あいまいであるために，コンパイル時エラーが発生する。

一つのインタフェースから，同じフィールドの宣言を継承する経路が，複数あってもよい。 この場合は，フィールドは，一度だけ継承されると考えられ，あいまいさを生じることなく単純名によって参照可能とする。

隠ぺいされたフィールドは，限定名（staticならば），又はキーワードsuper若しくは上位クラス型へのキャストを含むフィールドアクセス式(15.11)を使ってアクセス可能とする。 この詳細及び例については，15.11.2を参照のこと。

型floatのフィールドに貯えられた値は，常に単精度数値集合(4.2.3)の要素とする。同様に，型doubleのフィールドに貯えられた値は，常に倍精度数値集合の要素とする。型 floatのフィールドが，単精度数値集合の要素でない単精度指数部拡張数値集合の要素を含むことは許さないし，型doubleのフィールドが，倍精度数値集合の要素でない倍精度指数部拡張数値集合の要素を含むことも許さない。

8.3.1 フィールド修飾子

FieldModifiers:
	FieldModifier
	FieldModifiers FieldModifier

FieldModifier: one of
	public protected private
	static final transient volatile

フィールド宣言内で，複数個の（異なる）フィールド修飾子が出現する場合，必須ではないが，習慣上，前述のFieldModifierの生成規則内の記述の順序と矛盾しないように出現するものとする。

8.3.1.1 staticフィールド

static宣言されていないフィールド（非static フィールドとも呼ぶ）は，インスタンス変数(instance variable) と呼ばれる。クラスのインスタンスが生成されるときは必ず，そのインスタンスに関連する新しい変数が，そのクラス又はそのクラスの上位クラスで宣言されたすべてのインスタンス変数に対して生成される。次のプログラム例は，

class Point {
	int x, y, useCount;
	Point(int x, int y) { this.x = x; this.y = y; }
	final static 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++;

8.3.1.2 finalフィールド

未初期化最終 (4.5.4)クラス変数が，その宣言されたクラスで静的初期化子(8.7)により，確実に代入(16.7)されていなければ，コンパイル時エラーとする。

未初期化最終インスタンス変数は，宣言したクラスでのすべてのコンストラクタ(8.8)の終りで確実に代入(16.8)されなければならない。そうでなければ，コンパイル時エラーとなる。

8.3.1.3 transientフィールド

次に例を示す。

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

8.3.1.4 volatileフィールド

Javaは，ある種の目的に対して，より便利に利用できる第2の機構，volatileフィールドを提供する。

フィールドは，volatile宣言できる。 この場合，スレッドは，変数にアクセスするたびに，フィールドの作業コピーをマスタコピーに一致させなければならない。 さらに，スレッドの動作による， volatile 変数のマスタコピーへの操作は，主メモリによって，スレッドの要求した順序と同じ順序で実行する。

次の例において，あるスレッドがメソッドoneを繰り返し呼び出し (ただし，呼出し回数は，全部を合わせてもInteger.MAX_VALUE回を超えないものとする。)，さらに，もう一つのスレッドが，メソッドtwoを繰り返し呼び出したとする。

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

この無秩序動作を防ぐ一つの方法は，メソッドone及びtwoをsynchronized宣言(8.4.3.6)することとする。

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);
	}
}

もう一つの方法は，i及び jを volatile宣言することとする。

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

final変数を，volatile宣言した場合，コンパイル時エラーが発生する。

8.3.2 フィールドの初期化

• 宣言子がクラス変数（つまりstaticフィールド）に対するものならば，クラスが初期化される(12.4)ときに，変数初期化子が評価され，代入が一度だけ実行される。
• 宣言子がインスタンス変数（つまりstaticではないフィールド）に対するものならば，クラスのインスタンスが生成される(12.5)たびに，変数初期化子が評価され，代入が実行される。

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

変数初期化子は，局所変数宣言文(14.4)でも使用される。 その場合，局所変数宣言文が実行されるたびに，初期化子が評価され，代入が実行される。

名前付きクラス（又はインタフェース）のstaticフィールド又はインスタンス変数用の変数初期化子の評価が，検査例外(11.2)によって中途完了する可能性がある場合，コンパイル時エラーが発生する。

8.3.2.1 クラス変数用の初期化子

キーワードthis (15.8.3)又はsuper (15.11.2, 15.12)がクラス変数に対する初期化式内に出現する場合，コンパイル時エラーが発生する。

ここで，実行時には，final宣言されていてコンパイル時の定数値で初期化されているstatic変数が，最初に初期化されることに注意すること。 これは，インタフェース内の同様のフィールド(9.3.1)にも適用される。 これらの変数は，たとえ悪意のあるプログラムによっても，デフォルト初期値(4.5.5)を決して観察できない"定数"とする。 詳細な規定については，12.4.2及び13.4.8を参照のこと。 宣言がソーステキスト上で使用の後に出現するクラス変数の使用は，たとえ有効範囲にあっても，制限を受ける。クラス変数への前方参照を支配する適切な規則については， 8.3.2.3を参照のこと。

8.3.2.2 インスタンス変数用の初期化子

例を示す。

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

インスタンス変数に対する初期化式は，現在のオブジェクトを参照するためのキーワードthis (15.8.3)及び上位クラスのオブジェクトを参照するためのキーワードsuper (15.11.2, 15.12)を使用してよい。

宣言がソーステキスト上での使用の後に出現するインスタンス変数の使用は，たとえ有効範囲にあっても，制限を受ける。インスタンス変数への前方参照を支配する適切な規則については，8.3.2.3を参照のこと。

8.3.2.3 初期化中のフィールド使用の制限

• C のインスタンス(又はstatic)変数初期化子又はC のインスタンス(又はstatic)初期化子において，使用が出現する。
• 使用は，代入の左辺にない。
• C が使用を取り囲む最内クラス又はインタフェースである。

したがって，次のプログラムはコンパイル時エラーとなる。

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

	class Test {
		Test() { 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; 
		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;
}

8.3.3 フィールド宣言の例

8.3.3.1 例: クラス変数の隠ぺい

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

8.3.3.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

フィールドxにアクセスするためにフィールドアクセス式を使用するコードは，その参照式の型によって示されるクラス内の名前xのフィールドにアクセスする。 したがって，式 sample.xは， float値，つまりクラスTest内で宣言されたインスタンス変数 にアクセスする。その理由は，変数sampleの型は，Testだからである。 しかし，式((Point)sample).xは，型Pointにキャストしているために，int値，つまりクラスPointで宣言されたインスタンス変数にアクセスする。

xの宣言をクラスTestから削除すれば，プログラムは，次のとおりとなる。

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

8.3.3.3 例: 多重に継承されたフィールド

interface Frob { float v = 2.0f; }
class SuperTest { int v = 3; }
class Test extends SuperTest implements Frob {
	public static void main(String[] args) {
		new Test().printV();
	}
	void printV() { System.out.println(v); }
}

これを書き換えた次のコードは，フィールドアクセス式super.vを使用して，クラスSuperTestで宣言されている名前vのフィールドを参照し，さらに，限定名Frob.vを使用して，インタフェースFrobで宣言されている名前vのフィールドを参照している。

interface Frob { float v = 2.0f; }
class SuperTest { int v = 3; }
class Test extends SuperTest implements Frob {
	public static void main(String[] args) {
		new Test().printV();
	}
	void printV() {
		System.out.println((super.v + Frob.v)/2);
	}
}

2.5

interface Color { int RED=0, GREEN=1, BLUE=2; }
interface TrafficLight { int RED=0, YELLOW=1, GREEN=2; }
class Test implements Color, TrafficLight {
	public static void main(String[] args) {
		System.out.println(GREEN);	// compile-time error
		System.out.println(RED);		// compile-time error
	}
}

8.3.3.4 例: フィールドの再継承

public interface Colorable {
	int RED = 0xff0000, GREEN = 0x00ff00, BLUE = 0x0000ff;
}
public interface Paintable extends Colorable {
	int MATTE = 0, GLOSSY = 1;
}
class Point { int x, y; }
class ColoredPoint extends Point implements Colorable {
	. . .
}
class PaintedPoint extends ColoredPoint implements Paintable 
{
	. . .       RED       . . .
}

8.4 メソッド宣言

MethodDeclaration:
	MethodHeader MethodBody

MethodHeader:
	MethodModifiersopt ResultType MethodDeclarator Throwsopt

ResultType:
	Type
	void

MethodDeclarator:
	Identifer ( FormalParameterListopt )

MethodDeclarator 内のIdentifier は，そのメソッドを参照する名前として使用する。クラスは，そのクラス又はそのクラスのフ ィールド，メンバクラス，又はメンバインタフェースと同じ名前のメソッドを宣言できる。

Javaプラットフォームの旧版との互換性のために，配列を返すメソッドの宣言形式では，仮引数並びの後ろに，配列型の宣言を構成する空の角括弧対をおいてもよい。これは，次の過去の処理系の構文規則に対応する。

MethodDeclarator:
	MethodDeclarator [ ]

クラスの本体が同じシグネチャ(8.4.2)（名前，仮引数の個数及びすべての仮引数の型）をもつ二つのメソッドを，メンバとして 定義することは，コンパイル時エラーとする。メソッド及びフィールドは，異なった文脈で使用されること及び異なる検索手続きによってあいまい性が解消される(6.5)ので，同じ名前をもってよい。

8.4.1 形式仮引数

FormalParameterList:
	FormalParameter
	FormalParameterList , FormalParameter

FormalParameter:
	finalopt Type VariableDeclaratorId

VariableDeclaratorId:
	Identifier
	VariableDeclaratorId [ ]

同じメソッド又はコンストラクタの二つの形式仮引数が同じ名前をもつように宣言された（つまり，それらの宣言に同じIdentifierを指定した）場合，コンパイル時エラーが発生する。

finalと宣言されたメソッド又はコンストラクタ仮引数がメソッド又はコンストラクタの本体内部で代入されると，コンパイル時エラーが発生する。

メソッド又はコンストラクタが呼び出された(15.12)とき，メソッド又はコンストラクタ本体の実行前に，宣言されたTypeで新しく生成された仮引数変数を，実引数の式の値で初期化する。DeclaratorIdに出現するIdentifierは，その形式仮引数を参照するために，メソッド又はコンストラクタ本体内で，単純名として使用してよい。

メソッド(8.4.1)又はコンストラクタ(8.8.1)の形式仮引数名の有効範囲は，メソッド又はコンストラクタの本体全体とする。

これらの仮引数名は，メソッドの局所変数，もしくは，メソッド 又はコンストラクタのtry文内のcatch節の例外仮引数として再宣言してはならない。しかし，メソッド又はコンストラクタの仮引数は，そのメソッド又はコンストラクタ内部の入れ子になったクラス宣言内でおおい隠される。このような入れ子クラス宣言では，局所クラス(14.3)又は匿名クラス(15.9)を宣言してもよい。

形式仮引数は，単純名でだけ参照され，限定名(6.6)で参照されることは決してない。

型floatのメソッド又はコンストラクタ仮引数は，常に単精度数値集合(4.2.3)の要素を含む。同様に，型doubleのメソッド又はコンストラクタ仮引数は，常に倍精度数値集合の要素を含む。型floatのメソッド又はコンストラクタ仮引数が，単精度数値集合の要素でない単精度指数部拡張数値集合の要素を含むことは許さないし，型doubleのメソッド仮引数が，倍精度数値集合の要素でない倍精度指数部拡張数値集合の要素を含むことも許さない。

仮引数変数に対応する実引数式がFP厳密 (15.4)でない時は，その実引数式の評価において適当な拡張指数値集合から引き出された中間値の使用を許す。仮引数変数に貯えられる前に，そのような式の結果は，メソッド呼出し変換(5.3)により，対応する標準値集合における一番近い値に対応付けられる。

8.4.2 メソッドのシグネチャ

次に例を示す。

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

8.4.3 メソッド修飾子

MethodModifiers:
	MethodModifier
	MethodModifiers MethodModifier

MethodModifier: one of
	public protected private abstract static
	final synchronized native strictfp

メソッド宣言で複数のメソッド修飾子を指定するときは，習慣上，必須ではないが，MethodModifier に関する，前述の生成規則内の順序と矛盾しない順序で指定する。

8.4.3.1 abstractメソッド

privateメソッドをabstract宣言することは，コンパイル時エラーとする。

privateメソッドは，下位クラスから参照できないので，下位クラスは，private abstract宣言されたメソッドを実装できない。したがって，このようなメソッドは，決して使用できない。

staticメソッドをabstract宣言することは，コンパイル時エラーとする。

finalメソッドをabstract宣言することは，コンパイル時エラーとする。

abstractクラスは，他のabstractメソッドの宣言を提供することによって，abstractメソッドを上書きできる。

これによって，文書化用注釈を記述する場所，又は下位クラスで実装されるときに，そのメソッドによって投げられる可能性がある検査例外(11.2)の集合を宣言する場所をより限定することができる。例えば，次のコードを考える。

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

例えば，それらの下位クラスが，完全化され，インスタンス化可能なクラスであれば，その下位クラスがtoStringの実装を要求しているabstractクラスPointを宣言できる。

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
	}
}

8.4.3.2 staticメソッド

static宣言されていないメソッドを，インスタンスメソッド(instance method)と呼ぶ。これは，非staticメソッドと呼ぶこともある。インスタンスメソッドは，常にあるオブジェクトに関して呼び出され，そのオブジェクトが，メソッド本体の実行中にキーワードthis及びキーワードsuperで参照される，現在のオブジェクトとなる。

8.4.3.3 finalメソッド

privateメソッド及びfinalクラス(8.1.1.2)の中で宣言されたすべ てのメソッドは，上書きできないため，暗黙的にfinalとする。 それらのメソッド宣言に，冗長なキーワードfinalを含めることは，許されているが，必須ではない。

finalメソッドを，abstract宣言することは，コンパイル時エラーとする。

実行時に，機械語生成器又は最適化器は，容易及び安全にfinalメソッドの本体を"インライン化"できる。つまり，メソッド呼出しを，その本体内のコードで置き換えることができる。インライン化プロセスは，メソッド呼出しの意味論を保存せねばならない。特に，インスタンスメソッド呼出しの目標がnullであるなら，たとえメソッドがインライン化されても，NullPointerExceptionを投げねばならない。コンパイラは，メソッドへの実引数はメソッド呼出しより前に正しい順序で評価されるように正しい時点で例外を投げるよう保証せねばならない。

次に例を示す。

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;
		}

これらのインライン化は，Test及びPointが，常に一緒にコンパイルされる保証がないならば，コンパイル時に行うことはできない。 これは，Point，特にそのメソッドmove，が変更されるたびに，Test.mainのコードも更新されるようにするためである。

8.4.3.4 nativeメソッド

nativeメソッドをabstract宣言すると，コンパイル時エラーが発生する。

例えば，標準パッケージjava.ioのクラスRandomAccessFileは，次のnativeメソッドを宣言していてよい。

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;
}

8.4.3.5 strictfp メソッド

8.4.3.6 synchronizedメソッド

これらのロックは，synchronized文(14.18)で使用できるものと 同じロックとする。したがって，次のコードを考える。

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;
	}
}

put及びgetが，synchronized宣言されていないとき，二つのスレッドが同時にBoxの同じインスタンスに対するメソッドを実行すれば，そのコードは，不当な動作を行う可能性がある。たとえば，putに対する二つの呼出しが同時に発生したために，オブジェクトの軌跡を失うかもしれない。

スレッド及びロックの詳細な規定については，17.を参照のこと。

8.4.4 メソッドthrows

Throws:
	throws ClassTypeList

ClassTypeList:
	ClassType
	ClassTypeList , ClassType

メソッド又はコンストラクタ本体の実行の結果生じる可能性のある検査例外に対して，その例外の型又はその例外の型の上位クラスが，メソッド又はコンストラクタの宣言内のthrows節に指定されていなければ，コンパイル時エラーが発生する。

検査例外の宣言は，必須なので，そのようなエラー条件を処理するコードが含まれているかどうかをコンパイラで確認できる。 検査例外として投げられる例外条件の処理に失敗するメソッド又はコンストラクタは，throws節に適当な例外型を指定していないことによって，通常は，コンパイル時エラーを生じる。 Javaでは，このように，あるプログラミングスタイルを奨励している，そこでは，発生頻度は少ないが本当に例外的な条件は，この方法によって文書化されている。

この方法で検査されない定義済みの例外とは，可能な発生をすべて宣言することが不便で現実的でないものとする。

• クラスErrorの下位クラスによって表現されている例外，例えばOutOfMemoryErrorは，仮想計算機に関係する失敗によって投げられることがある。 これらのエラーの多くは，リンク失敗の結果で，Javaプログラム実行中の予想できない点で発生する可能性がある。 ただし，洗練されたプログラムは，これらの条件の一部を検出し回復を試みるかもしれない。
• クラスRuntimeExceptionの下位クラスで表現されている例外，例えばNullPointerExceptionは，実行時の保全性検査の結果生じ，直接Javaプログラムから又はライブラリルーチンの中で投げられる。このような例外が発生しないと証明できる箇所を，管理可能な数にまで減らすために，プログラム内に十分な情報を取り込むことは，Java言語及びおそらくは，現在の最新の技術の範囲を超えている。

より正確に規定する。Bをクラス又はインタフェース，AをBの上位クラス又はインタフェースとし，Bの中のメソッド宣言nが，Aの中のメソッド宣言mを上書き又は隠ぺいするとする。nが検査例外の型を指定するthrows節をもつ場合，mは，throws節をもたなければならず，nのthrows節に上げられているすべての検査例外の型に対して，同じ例外クラス又はその上位クラスの一つがmのthrows節内に出現しなければならない。そうでなければ，コンパイル時エラーが発生する。

例外に関するより多くの情報及び豊富な例については，11.を参照のこと。

8.4.5 メソッド本体

MethodBody:
	Block 
	;

実装は，メソッドに対して提供されるべきだが，その実装の中に実行可能コードを必要としなければ，メソッド本体は，文を含まないブロック，つまり，"{ }"として記述しなければならない。

メソッドがvoid宣言されていれば，その本体は，式(Expression)をもつreturn文(14.16)を含んではならない。

メソッドが返却値型をもつと宣言されていれば，その本体内のすべてのreturn文(14.16)は，式(Expression)をもたなければならない。 メソッド本体が正常完了(14.1)できるならば，コンパイル時エラーが発生する。

つまり，返却値型をもつメソッドは，返却値を返すreturn文を使ってだけ制御を戻さねばならない。 "末尾返却"(return文を省略して，すべての文の正常完了によってメソッドの終わりとすること)は，許されない。

メソッドが宣言された返却値の型をもつがreturn文を含まないことがあることに注意すること。次に例を示す。

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

8.4.6 継承，上書き及び隠ぺい

8.4.6.1 （インスタンスメソッドによる）上書き

1. C はA の下位クラスとする。
2. 次のどちらかが成り立つ。
   • m2 は，非privateかつC からアクセス可能とする。
   • m1 はメソッド m3を上書きし，m3 はm1 と異なり，m3 はm2 と異なり，m3 はm2 を上書きする。

インスタンスメソッドがstaticメソッドを上書きすると，コンパイル時エラーが発生する。

この点で，メソッドの上書きは，フィールドの隠ぺい(8.3)とは異なる。その理由は，インスタンス変数が，static変数を隠ぺいすることは，許されることによる。

上書きされたメソッドは，キーワードsuperを含むメソッド呼出し式(15.12)を使用して，アクセス可能とする。 限定名又は上位クラスへのキャストで，上書きされたメソッドにアクセスしようとすることは無効とすることに注意せよ。 この点で，メソッドの上書きは，フィールドの隠ぺいとは異なる。この点の規定及び例については，15.12.4.9を参照のこと。

strictfp修飾子の存在又は欠如は，メソッドの上書き及びabstract メソッドの実装の規則に何らの影響も絶対もたない。例えば， FP厳密でないメソッドがFP厳密メソッドを上書きすること，ならびに，FP厳密でないメソッドを上書きすることは，許される。

8.4.6.2 （クラスメソッドによる）隠ぺい

この点で，メソッドの隠ぺいは，フィールドの隠ぺい(8.3)とは異なる。 すなわち，static変数が，インスタンス変数を隠ぺいすることは，許されている。隠ぺいは，おおい隠し(6.3.1)ならびに不明瞭化(6.3.2)とも異なる。

隠ぺいされたメソッドは，限定名，又はキーワードsuper若しくは上位クラス型へのキャストを含むメソッド呼出し式(15.12)を使用して，アクセス可能とする。 この点で，メソッドの隠ぺいは，フィールドの隠ぺいと似ている。

8.4.6.3 上書き及び隠ぺいの要件

この点で，メソッドの上書きは，フィールド(8.3)の隠ぺいとは異なる。 すなわち，フィールドが他の型のフィールドを隠ぺいすることは，許されている。

メソッドを上書き又は隠ぺいするアクセス修飾子(6.6)は，少なくとも上書き又は隠ぺいされるメソッドと同じアクセスを提供しなければならない。そうでなければ，コンパイル時エラーが発生する。詳細は，次のとおりとする。

• 上書き又は隠ぺいされるメソッドがpublicならば，上書き又は隠ぺいするメソッドは，publicでなければならない。 そうでなければ，コンパイル時エラーが発生する。
• 上書き又は隠ぺいされるメソッドがprotectedならば，上書き又は隠ぺいするメソッドは，protected又はpublicでなければならない。 そうでなければ，コンパイル時エラーが発生する。
• 上書き又は隠ぺいされるメソッドがデフォルト(パッケージ)アクセスをもつならば，上書き又は隠ぺいするメソッドをprivateにしてはならない。 そうでなければ，コンパイル時エラーが発生する。

8.4.6.4 同じシグネチャをもつメソッドの継承

• 継承されたメソッドの一つがabstractでなければ，さらに二つの場合が存在する。
  • abstractではないメソッドがstaticであるならば，コンパイル時エラーが発生する。
  • そうでなければ，それを継承するクラスのために，abstractではないメソッドが他のすべてのメソッドを上書きして，それ故，実装すると見なす。 abstractではないメソッドを，継承された他の各メソッドと比較し，その対に関して返却値の型が異なる，又は一方が返却値の型をもち他方がvoidならば，コンパイル時エラーが発生する。さらに，abstractではない継承されたメソッドが，他の継承されたメソッドのthrows節と衝突(8.4.4)するthrows節をもつならば，コンパイル時エラーが発生する。
• 継承されたメソッドのすべてがabstractであるならば，そのクラスは，必然的にabstractクラスとなり，すべてのabstractメソッドを継承すると見なされる。 二つの継承されたメソッドに対して，異なる返却値の型をもっているか，又は一方は，返却値の型をもっており他方は，voidならば，コンパイル時エラーが発生する。(この場合，throws節の衝突は，エラーを引き起こさない。）

インタフェースの同じメソッド宣言が複数の経路で継承される場合がある。 これで特に問題が生じることも，これが原因でコンパイル時エラーが発生することもない。

8.4.7 オーバロード

メソッドは，シグネチャ単位で上書きされる。

たとえば，クラスが同じ名前をもつ二つのpublicメソッドを宣言し，下位クラスがそのうちの一つを上書きする場合，その下位クラスは，他方のメソッドを継承する。この点で，Java は， C++ とは異なる。

メソッドが呼び出される(15.12)とき，呼び出されるメソッドのシグネチャを決定(15.12.2)するために，コンパイル時に，実引数の数及び実引数のコンパイル時の型が使用される。 呼び出すべきメソッドがインスタンスメソッドであれば，呼び出される実際のメソッドは，動的メソッド検索を使用して実行時に決定(15.12.4)される。

8.4.8 メソッド宣言の例

8.4.8.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;
	}
}

8.4.8.2 例: オーバロード，上書き及び隠ぺい

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; }
}

この例では，クラスRealPointのメンバは，クラスPointから継承されたインスタンス変数color，RealPointで宣言された型floatのインスタンス変数x及びy，並びにRealPointで宣言された二つのメソッドmoveを含んでいる。

クラスRealPointのオーバロードされたメソッドmoveのうちいずれを特定のメソッド呼出しに対して選択するかは，15.12で規定されるオーバロード解決手順によってコンパイル時に決定する。

8.4.8.3 例: 不当な上書き

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; }
}

8.4.8.4 例: 上書き及び隠ぺい

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)

出力の2行目は，フィールドアクセスrp.xが，クラスRealPointで宣言されたフィールドxを参照していることを示す。このフィールドは，型floatで，この2行目は，浮動小数点値を表示する。ちなみに，これは，名前showのメソッドがオーバロードされていることも示す。メソッド呼出しにおける実引数の型は，二つの定義のどちらが呼び出されるかを示す。

最後の2行は，p.getX()及びrp.getX()のメソッド呼出しが，それぞれクラスRealPointで宣言されたメソッドgetXを呼び出すことを示す。実際，クラスRealPointのインスタンスのためにRealPoint本体外からクラスPointのメソッドgetXを呼び出す方法は，そのオブジェクトへの参照を保持するためにどのような変数の型を使用しようとも，存在しない。したがって，フィールドとメソッドでは，動作が異なることがわかる。つまり，隠ぺいは，上書きと異なる。

8.4.8.5 例: 隠ぺいされたクラスメソッドの呼出し

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

8.4.8.6 上書きの大きな例

import java.io.OutputStream;
import java.io.IOException;
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

オブジェクトLineBufferOutputのメソッドputcharでは，文字実引数が改行ならば，メソッドflushを呼び出す。この例で，上書きに関して重要なことは，クラスBufferOutputで宣言されているメソッドputstrは，現在のオブジェクトthisで定義されているメソッドputcharを呼び出すことである。このメソッドputcharは，必ずしもクラスBufferOutputで宣言されているメソッドputcharではない。

したがって，main内で型LineBufferOutputのオブジェクトlboを使ってputstrが呼び出されるとき，メソッドputstr本体内のputcharの呼出しは，オブジェクトlboの putcharの呼出し，つまり，改行を検査するputcharで上書き宣言したものとなる。これにより，BufferOutputの下位クラスは，再定義することなしに，メソッドputstrの振舞いを変更できる。

拡張するように設計されているBufferOutputのようなクラスの文書は，クラス及びその下位クラス間の約束事，又は下位クラスがこのようにメソッドputcharを上書きできることを明確に示すことが望ましい。したがって，クラス BufferOutputを実装する開発者は，BufferOutputの今後の実装で，メソッドputcharを使用しないようにputstrの実装を変更することはしたくないであろう。そのような変更は，下位クラスとの間の既存の約束を破ることになるからである。13.特に13.2のバイナリ互換性の詳細な規定を参照すること。

8.4.8.7 例: 例外投げ(throw)がひき起こす不正な上書き

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;
	}
}

throws節を削除しても効果はない。

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

メソッドmoveの本体は，moveに対するthrows節に出現しない検査例外，つまりBadPointExceptionを投げることができないために，別のコンパイル時エラーが発生する。

8.5 メンバ型宣言

そのクラスが名前をつけたメンバ型を宣言するならば，その型の宣言は，そのクラスの上位クラス及び上位インタフェースで同じ名前をもつすべてのアクセス可能宣言を隠ぺいする（hide）と言う。

クラスC 内部での名前n のメンバ型の宣言d は，d が出現する点での有効範囲における名前n の他の型の宣言をおおい隠す。

単純名C で宣言されたメンバクラス又はインタフェースが完全限定名 Nのクラスの宣言内部で直接取り囲まれるならば，そのメンバクラス又はインタフェースは完全限定名N.Cをもつ。

クラスは，同じ名前の複数の型宣言を，二つのインタフェース，若しくは，その上位クラス及びインタフェースから継承してよい。あいまいな継承クラス又はインタフェースをその単純名で参照しようとすれば，コンパイル時エラーとなる。

複数経路で一つのインタフェースから同じ型宣言が継承されるならば，そのクラス又はインタフェースは，1度だけ継承されると考えられる。それは，あいまいさなくその単純名で参照される。

8.5.1 アクセス修飾子

8.5.2 staticメンバ型宣言

staticクラスが,取り囲むクラスの非staticメンバの使用を含むならば，コンパイル時エラーが発生する。

メンバインタフェースは，常に暗黙に staticとする。メンバインタフェースの宣言は，static 修飾子を明示的に並べてよいが，必要ではない。

8.6 インスタンス初期化子

InstanceInitializer:
	Block

上の規則は，名前付き及び匿名クラスでのインスタンス初期化子を区別する。この相違は，意図的である。 与えられた匿名クラスは，プログラムの単一点で初期化されるだけとする。したがって，匿名クラスのインスタンス初期化子によって，取り囲む式へどのような例外が起きるかについての情報を直接伝播することが可能となる。一方，名前のあるクラスは，多くの場所で初期化できる。 したがって，名前のあるクラスによって，取り囲む式へどのような例外が起きるかについての情報を伝播する唯一の方法は，そのコンストラクタのthrows節による。したがって，匿名クラスの場合では，より自由な規則を用いてよい。同様のことが，インスタンス変数初期化子にも適用される。

インスタンス初期化子が正常完了(14.20)できないならば，コンパイル時エラーとなる。return 文 (14.16)がインスタンス初期化子の内部に出現するならば，コンパイル時エラーとなる。

宣言が構文的に使用の後に出現するインスタンス変数の使用は，そのインスタンス変数が有効範囲にあったとしても，制限を受けることがある。インスタンス変数に対する前方参照の規則については，8.3.2.3を参照。

インスタンス初期化子は，現オブジェクト this (15.8.3)を参照し，キーワード super (15.11.2, 15.12)を使用することが許される。

8.7 静的初期化子

StaticInitializer:
	static Block

静的初期化子及びクラス変数初期化子は，ソーステキストで出現した順に実行される。

ソーステキストの後方に宣言が出現するクラスで宣言されるクラス変数は，それが有効範囲内にあるとしても，その使用に制限を受けることがある。クラス変数に対する前方参照の規則については，8.3.2.3を参照。

静的初期化子内の任意の場所でreturn文(14.16)が出現すれば，コンパイル時エラーが発生する。

キーワードthis (§15.8.3)又はキーワードsuper (15.11, 15.12)が静的初期化子内の任意の場所で出現すれば，コンパイル時エラーが発生する。

8.8 コンストラクタの宣言

ConstructorDeclaration:
	ConstructorModifiersopt ConstructorDeclarator
		Throwsopt ConstructorBody

ConstructorDeclarator:
	SimpleTypeName ( FormalParameterListopt )

次に簡単な例を示す。

class Point {
	int x, y;
	Point(int x, int y) { this.x = x; this.y = y; }
}

コンストラクタへのアクセスは，アクセス修飾子(6.6)によって支配される。

これは，たとえば，アクセス不可能なコンストラクタを宣言することによってインスタンス化を防ぐ場合(8.8.8)に有用とする。 コンストラクタ宣言は，決して継承されず，したがって，隠ぺい又は上書きの対象にはならない。

8.8.1 形式仮引数

8.8.2 コンストラクタのシグネチャ

8.8.3 コンストラクタ修飾子

ConstructorModifiers:
	ConstructorModifier
	ConstructorModifiers ConstructorModifier

ConstructorModifier: one of
	public protected private

メソッドとは異なり，コンストラクタは，abstract, static, final, native, strictfp又はsynchronized宣言できない。コンストラクタは，継承されないので，final宣言する必要はなく，abstractコンストラクタ宣言は，決して実装できない。コンストラクタは，常にオブジェクトに関して呼び出されるので，コンストラクタをstatic宣言することは，意味がない。コンストラクタをsynchronized宣言する必要性も実際にはない。そのオブジェクトに対するすべてのコンストラクタが処理を完了するまで，他のスレッドに対して使用可能とはならず，生成中のオブジェクトは，必然的にロック設定されるからとする。native宣言ができないのは，オブジェクト生成中に，上位クラスのコンストラクタが常に適切に呼び出されることを，Java仮想計算機の実装が簡単に検証できるようにするための言語設計の任意な選択とする。

ConstructorModifierはstrictfpと宣言できないことに注意。ConstructorModifierとMethodModifier (8.4.3)との定義における相違は，意図的な言語設計上の選択とする。これは，コンストラクタがFP厳密(15.4)である必要十分条件がそのクラスがFP厳密となることを実効的に保証する。

8.8.4 コンストラクタのthrows節

8.8.5 コンストラクタ本体

ConstructorBody:
	{ ExplicitConstructorInvocationopt BlockStatementsopt }

コンストラクタ本体が明示的コンストラクタ呼出しで開始されず，宣言しているコンストラクタが根源的クラスであるクラスObjectの一部でなければ，コンストラクタ本体は，コンパイラにより暗黙に，上位クラスのコンストラクタ呼出し"super();"で開始すると仮定される。すなわち，その直接的上位クラスに存在する実引数を取らないコンストラクタ呼出しとする。

明示的なコンストラクタ呼出しの可能性以外は，コンストラクタ本体は，メソッド本体(8.4.5)と類似する。return文(14.16)が式を含まなければ，return文は，コンストラクタ本体で使用できる。

次に例を示す。

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;
	}
}

12.5及び15.9は，新しいクラスインスタンスの生成及び初期化を記述する。

8.8.5.1 明示的コンストラクタ呼出し

ExplicitConstructorInvocation:
	this ( ArgumentListopt ) ;
	super ( ArgumentListopt ) ;
	Primary.super ( ArgumentListopt ) ; 

明示的コンストラクタ呼出し文は，次の2種類とする。

• 代替コンストラクタ呼出し（Alternate constructor invocations）は，キーワード thisで始まる。同じクラスの代替コンストラクタの呼出しに使われる。
• 上位クラスコンストラクタ呼出し（Superclass constructor invocation）は，キーワード super又はPrimary式で始まる。直接的上位クラスのコンストラクタ呼出しに使われる。上位クラスコンストラクタ呼出しは，次に分類される。
  • 非限定上位クラスコンストラクタ呼出し（Unqualified superclass constructor invocations）は，キーワード superで始まる。
  • 限定上位クラスコンストラクタ呼出し（Qualified superclass constructor invocations）は，基本（Primary）式で始まる。これは，下位クラスコンストラクタが直接的上位クラス(8.1.2)に関して新しく作られたオブジェクトの直ちに取り囲むインスタンスを明示的に規定することを許す。上位クラスが内部クラスである時にこれが必要となる。 次に，限定上位クラスコンストラクタ呼出しの例を示す。

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

たとえば，前述の例のColoredPointの最初のコンストラクタを次のように変更したとする。

ColoredPoint(int x, int y) {
	this(x, y, color);
}

匿名クラスインスタンス生成式が，明示的コンストラクタ呼出し文の内部で出現するならば，その匿名クラスは，そのコンストラクタが呼び出されているクラスの取り囲みインスタンスを参照してはならない。

例を次に示す。

class Top {
	int x;
	class Dummy {
		Dummy(Object o) {}
	}
	class Inside extends Dummy {
		Inside() {
			super(new Object() { int r = x; }); // error
		}
		Inside(final int y) {
			super(new Object() { int r = y; }); // correct
		}
	}
}

• 最初に，コンストラクタ呼出し文が上位クラスコンストラクタ呼出しならば，S に関するi の直ちに取り囲むインスタンスは，(もしあれば)決定されねばならない。i がS に関する直ちに取り囲むインスタンスをもつかどうかは，次のとおりに上位クラスコンストラクタによって決定される。
  • S が内部クラスでないか，又は，S の宣言が静的文脈に出現すれば，S に関するi の直ちに取り囲むインスタンスは，存在しない。その上位クラスコンストラクタ呼出しが限定上位クラスコンストラクタ呼出しならば，コンパイル時エラーとなる。
  • そうでなければ
    • 上位クラスコンストラクタ呼出しが限定的ならば，".super"にすぐ先行する基本(Primary）式p が評価される。その基本式の評価がnullならば，NullPointerExceptionが起され，上位クラスコンストラクタ呼出しが中途完了する。 そうでなければ，この評価の結果は，S に関するi の直ちに取り囲むインスタンスとなる。O をS の直ちに字句的に取り囲むインスタンスとする。p の型がO 又はO の下位クラスでなければ，コンパイル時エラーとなる。
    • そうでなければ
      • S が局所クラス(14.3)ならば，S は，クラスO を字句的に取り囲むクラスにおいて宣言されたメソッドで宣言されねばならない。nをO がC をn番目に字句的に取り囲むクラスとなる整数とする。S に関するi の直ちに取り囲むインスタンスは，このn番目に字句的に取り囲むインスタンスとなる。
      • そうでなければS は内部メンバクラス(8.5)とする。S が字句的に取り囲むクラスのメンバでなければ，コンパイル時エラーとなる。O を，S がそのメンバとなる，最内字句的に取り囲むクラスとする。さらに，nをO がC をn番目に字句的に取り囲むクラスとなる整数とする。S に関するi の直ちに取り囲むインスタンスは，このn番目に字句的に取り囲むインスタンスとなる。
• 第二に，コンストラクタへの実引数が，通常のメソッド呼出し同様に，左から右へと評価される。
• 次に，コンストラクタが呼び出される。
• 最後に，コンストラクタ呼出し文が上位クラスコンストラクタ呼出しであり，かつそのコンストラクタ呼出し文が正常完了するならば，C のすべてのインスタンス変数初期化子及びC のすべてのインスタンス初期化子が実行される。インスタンス初期化子又はインスタンス変数初期化子I が，他のインスタンス初期化子又はインスタンス変数初期化子Jに構文的に先行するならば，I はJ より前に実行される。この動作は，上位クラスコンストラクタ呼出しが実際に明示的コンストラクタ呼出し文として出現しようと，あるいは，自動的に行なわれようと遂行される。代替コンストラクタ呼出しは，この追加的暗黙動作を遂行しない。

8.8.6 コンストラクタのオーバロード

8.8.7 デフォルトコンストラクタ

• 宣言しているクラスが，ルートクラスであるクラスObjectならば，デフォルトコンストラクタは，空の本体をもつ。
• そうでなければ，デフォルトコンストラクタは，実引数を取らず，実引数をもたない上位クラスのコンストラクタを単に呼び出す。

デフォルトコンストラクタは，throws節をもたない。

したがって，上位クラスの空次数コンストラクタがthrows節をもつなら，コンパイル時エラーが発生する。

クラスが public 宣言されていれば，デフォルトコンストラクタは，暗黙にアクセス修飾子public(6.6)を与えられる。クラスが protected宣言されていれば，デフォルトコンストラクタは，暗黙にアクセス修飾子protected (6.6)を与えられる。クラスが private宣言されていれば，デフォルトコンストラクタは，暗黙にアクセス修飾子private (6.6)を与えられる。そうでなければ，デフォルトコンストラクタは，アクセス修飾子が示されないデフォルトアクセスをもつ。

次に例を示す。

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
	}
}

8.8.8 クラスのインスタンス化の抑制

次に例を示す。

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

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

目次 | 前 | 次 | 索引

Java言語規定 第2版