目次 | | | 索引 Java言語規定
第2版

4. 型,値及び変数
Types, Values, and Variables

Javaプログラム言語は,強く型付けされた(strongly typed)言語とする。それは,個々の変数及び個々の式がコンパイル時に既知の型を持つことを意味する。 型は,変数 (4.5) が保持できるか,又は式が生成できる値を制限し,それらの値に対する演算を制限し,演算の意味を決定する。強い型付けは,コンパイル時にエラーを検出するのに役立つ。

The Java programming language is a strongly typed language, which means that every variable and every expression has a type that is known at compile time. Types limit the values that a variable (4.5) can hold or that an expression can produce, limit the operations supported on those values, and determine the meaning of the operations. Strong typing helps detect errors at compile time.

Javaプログラム言語の型は,二つのカテゴリ,プリミティブ型及び参照型に分かれる。プリミティブ型 (4.2) は boolean 型及び数値型とする。数値型は整数的な型である byteshortintlong,及び char,並びに浮動小数点型である float 及び double とする。参照型 (4.3) はクラス型,インタフェース型,及び配列型とする。特別な空型もある。Javaのオブジェクト (4.3.1) は,動的に生成されたクラス型のインスタンス又は動的に生成された配列とする。参照型の値は,オブジェクトへの参照になる。配列を含むすべてのオブジェクトは,クラス Object (4.3.2) のメソッドを処理できる。 文字列リテラルは,オブジェクト String (4.3.3) によって表す。

The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types (4.2) are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types (4.3) are class types, interface types, and array types. There is also a special null type. An object (4.3.1) is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object (4.3.2). String literals are represented by String objects (4.3.3).

型の名前は,宣言,キャスト,クラスインスタンス生成式,配列生成式,クラスリテラル,及び instanceof 演算式において使用する(4.4)。

Names of types are used (4.4) in declarations, casts, class instance creation expressions, array creation expressions, class literals, and instanceof operator expressions.

変数 (4.5) は,記憶域の位置とする。プリミティブ型の変数は,常にその同じ型の値を保持する。クラス型T の変数は,空参照又はクラス T 若しくは T の下位クラスである任意のクラスのインスタンスへの参照を保持する。インタフェース型の変数は,空参照又はそのインタフェースを実装する任意のクラスの任意のインスタンスへの参照を保持する。T がプリミティブ型ならば,"T の配列" 型の変数は,空参照又は"T の配列" 型の任意の配列への参照を保持する。つまり,T が参照型ならば,"T の配列" 型変数は,空参照又は型T に代入可能な (5.2) 型S の "S の配列" 型の任意の配列への参照を保持する。型Objectの変数は,空参照又はクラスインスタンス若しくは配列の任意のオブジェクトへの参照を保持する。

A variable (4.5) is a storage location. A variable of a primitive type always holds a value of that exact type. A variable of a class type T can hold a null reference or a reference to an instance of class T or of any class that is a subclass of T. A variable of an interface type can hold a null reference or a reference to any instance of any class that implements the interface. If T is a primitive type, then a variable of type "array of T" can hold a null reference or a reference to any array of type "array of T"; if T is a reference type, then a variable of type "array of T" can hold a null reference or a reference to any array of type "array of S" such that type S is assignable (5.2) to type T. A variable of type Object can hold a null reference or a reference to any object, whether class instance or array.

4.1 型及び値の種類
4.1 The Kinds of Types and Values

Javaプログラム言語には,プリミティブ型(4.2)及び参照型(4.3)の2種類のが存在する。それぞれに対応して,演算対象となるプリミティブ型の値(4.2)と参照型の値 (4.3) の2種類のデータ値が存在する。それらは,変数に記憶でき,実引数として渡せ,メソッドによって返すことができる。
There are two kinds of types in the Java programming language: primitive types (4.2) and reference types (4.3). There are, correspondingly, two kinds of data values that can be stored in variables, passed as arguments, returned by methods, and operated on: primitive values (4.2) and reference values (4.3).

nullの型である特別な空型(null type)も存在する。それには名前がない。空型には名前がないので,空型の変数を宣言すること又は空型にキャストすることはできない。空型の式が取りうる唯一の値が空参照となる。空参照は,常に任意の参照型にキャストできる。実用上は,Javaプログラマが,空型を無視し,nullを任意の参照型になれる特別なリテラルと見なしてもよい。
There is also a special null type, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.

4.2 プリミティブ型及び値
4.2 Primitive Types and Values

プリミティブ型(primitive type)は,Javaプログラム言語によってあらかじめ定義されており,予約キーワード (3.9) で名前付ける。
A primitive type is predefined by the Java programming language and named by its reserved keyword (3.9):

プリミティブ値は,他のプリミティブ値と状態を共有しない。プリミティブ型の変数は,常にそれと同じ型のプリミティブ値を保持する。プリミティブ型の変数の値は,その変数に対する代入演算でしか変更できない。
Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

数値型(numeric types)は,整数的な型及び浮動小数点型とする。

The numeric types are the integral types and the floating-point types.

整数的な型(integral types)は,byteshortint,及び long(それぞれ,8ビット,16ビット,32ビット及び64ビットの符号付きの2の補数表現整数),並びに char(Unicode文字を表す16ビット符号無し整数)とする。

The integral types are byte, short, int, and long, whose values are 8-bit, 16-bit, 32-bit and 64-bit signed two's-complement integers, respectively, and char, whose values are 16-bit unsigned integers representing Unicode characters.

浮動小数点型(floating-point types)は,float(32ビットIEEE 754浮動小数点数)及びdouble(64ビットIEEE 754浮動小数点数)とする。

The floating-point types are float, whose values include the 32-bit IEEE 754 floating-point numbers, and double, whose values include the 64-bit IEEE 754 floating-point numbers.

boolean型は二つの値,true(真)又はfalse(偽)だけをとる。

The boolean type has exactly two values: true and false.

4.2.1 整数的な型及び値
4.2.1 Integral Types and Values

整数的な型の値は,次の範囲の整数とする。
The values of the integral types are integers in the following ranges:

4.2.2 整数演算
4.2.2 Integer Operations

Javaプログラム言語は,整数的な値に作用する演算子を多数提供する。 
The Java programming language provides a number of operators that act on integral values:

他の有益なコンストラクタ,メソッド及び定数が,クラス Byte,クラス Short,クラス Integer,クラス Long,及びクラス Characterであらかじめ定義されている。
Other useful constructors, methods, and constants are predefined in the classes Byte, Short, Integer, Long, and Character.

シフト演算子以外の整数演算子が少なくとも一つの型longのオペランドをもてば,演算を64ビット精度で実行し,その結果を型longとする。片方のオペランドがlongでなければ,最初に数値昇格 (5.6) によって型longに拡張する (5.1.4)。そうでなければ,演算は32ビット精度で実行し,その数値演算子の結果は型intとする。どちらかのオペランドがintでなければ,演算に先立って数値昇格によって型intに拡張する。

If an integer operator other than a shift operator has at least one operand of type long, then the operation is carried out using 64-bit precision, and the result of the numerical operator is of type long. If the other operand is not long, it is first widened (5.1.4) to type long by numeric promotion (5.6). Otherwise, the operation is carried out using 32-bit precision, and the result of the numerical operator is of type int. If either operand is not an int, it is first widened to type int by numeric promotion.

組み込みの整数演算子は,どのような形でもオーバフロー又はアンダフローを示さない。例外 (11) を投げることができる数値演算子は整数除算演算子/ (15.17.2) 及び整数剰余演算子 % (15.17.3) だけとする。これは,右辺オペランドがゼロならば,ArithmeticExceptionを投げる。

The built-in integer operators do not indicate overflow or underflow in any way. The only numeric operators that can throw an exception (11) are the integer divide operator / (15.17.2) and the integer remainder operator % (15.17.3), which throw an ArithmeticException if the right-hand operand is zero.

次に例を示す。

The example:
class Test {
	public static void main(String[] args) {
		int i = 1000000;
		System.out.println(i * i);
		long l = i;
		System.out.println(l * l);
		System.out.println(20296 / (l - i));
	}
}
この例は,次の出力を生成する。
produces the output:

-727379968
1000000000000
この後は,l - i がゼロなので,l - i による除算でArithmeticExceptionを生じる。最初の乗算は32ビット精度で実行し,2番目の乗算は,long乗算とする。値-727379968は,型intには大き過ぎる値1000000000000の下位32ビットを符号付き10進数値化したものとなる。
and then encounters an ArithmeticException in the division by l - i, because l - i is zero. The first multiplication is performed in 32-bit precision, whereas the second multiplication is a long multiplication. The value -727379968 is the decimal value of the low 32 bits of the mathematical result, 1000000000000, which is a value too large for type int.

任意の整数的な型の任意の値は,任意の数値型からキャストしてもよい。整数的な型と型booleanの間では,キャストはできない。

Any value of any integral type may be cast to or from any numeric type. There are no casts between integral types and the type boolean.

4.2.3 浮動小数点型,フォーマット及び値
4.2.3 Floating-Point Types, Formats, and Values

浮動小数点型はfloat 及び doubleとし,IEEE Standard for Binary Floating-Point Arithmetic,ANSI/IEEE Standard 754-1985 (IEEE,New York)で規定する,単精度32ビット及び倍精度64ビット形式のIEEE 754 の値及び演算を表現する。
The floating-point types are float and double, which are conceptually associated with the single-precision 32-bit and double-precision 64-bit format IEEE 754 values and operations as specified in IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Standard 754-1985 (IEEE, New York).

IEEE 754 規格は,正負の符号及び大きさからなる数だけではなく,正及び負のゼロ,正及び負の無限大(infinities),並びに特別なNot-a-Number値(以後NaNと略す)を含む。NaN値は,ゼロをゼロで割るなどの特別な演算の結果を表すために使用する。float及びdouble型のNaN定数はFloat.NaN及びDouble.NaNとしてあらかじめ定義されている。

The IEEE 754 standard includes not only positive and negative numbers that consist of a sign and magnitude, but also positive and negative zeros, positive and negative infinities, and special Not-a-Number values (hereafter abbreviated NaN). A NaN value is used to represent the result of certain invalid operations such as dividing zero by zero. NaN constants of both float and double type are predefined as Float.NaN and Double.NaN.

あらゆるJavaプログラム言語の実装は,単精度数値集合(float value set)及び倍精度数値集合(double value set)という二つの浮動小数点値の規定をサポートしなければならない。加えて,実装によっては単精度指数部拡張数値集合(float-extended-exponent value set)及び倍精度指数部拡張数値集合(double-extended-exponent value set)と呼ばれる二つの指数部拡張浮動少数点値集合のうちのどちらか又は両方をサポートしてもよい。場合によっては,これらの指数部拡張数値集合を型float又はdouble (5.1.815.4) の式の値を表現する標準数値集合の代わりに使用してもよい。

Every implementation of the Java programming language is required to support two standard sets of floating-point values, called the float value set and the double value set. In addition, an implementation of the Java programming language may support either or both of two extended-exponent floating-point value sets, called the float-extended-exponent value set and the double-extended-exponent value set. These extended-exponent value sets may, under certain circumstances, be used instead of the standard value sets to represent the values of expressions of type float or double (5.1.8, 15.4).

任意の浮動小数点数値集合の有限非ゼロ値はすべて形式で表現される。ここで,sは+1又は-1とし,mより小さい正の整数とし,eからまでの整数とする。さらにN及びKは浮動小数点数値集合に依存するパラメタとする。値によっては複数の表現形式が存在する。例えば,数値集合の中の値vについてsm,及び eのためにある値を使用してこの形式で表現され,またmは偶数でeより小さいならば,mの半分にして,一つだけeを増加させ,同じ値vに対する二つ目の表現を生成することができる。この形式の表現は,であるならば正規化表現(normalized)と呼ばれ,そうでなければ非正規化表現(denormalized)と呼ばれる。数値集合の中の値がと表現できない場合,値は正規化表現がないため非正規化値(denormalized value)と呼ばれる。

The finite nonzero values of any floating-point value set can all be expressed in the form , where s is +1 or -1, m is a positive integer less than , and e is an integer between and , inclusive, and where N and K are parameters that depend on the value set. Some values can be represented in this form in more than one way; for example, supposing that a value v in a value set might be represented in this form using certain values for s, m, and e, then if it happened that m were even and e were less than , one could halve m and increase e by 1 to produce a second representation for the same value v. A representation in this form is called normalized if ; otherwise the representation is said to be denormalized. If a value in a value set cannot be represented in such a way that , then the value is said to be a denormalized value, because it has no normalized representation.

パラメタN及びKに対する制約(さらに派生したパラメタEmin及びEmaxに対する)のために2つの必須(floatとdouble)及び2つのオプションの浮動小数点値集合を表 4.1に要約する。

The constraints on the parameters N and K (and on the derived parameters Emin and Emax) for the two required and two optional floating-point value sets are summarized in Table 4.1.

表4.1 浮動小数点値集合パラメタ
Floating-point value set parameters
パラメタ
Parameter
単精度
float
単精度指数部拡張
float-extended-exponent
倍精度
double
倍精度指数部拡張
double-extended-exponent
N

24

24

53

53

K

8

11

11

15

Emax

+127

+1023

+1023

+16383

Emin

-126

-1022

-1022

-16382

指数部拡張数値集合をサポートする実装では,その指数部拡張数値集合に,実装に依存する定数Kがあり,その値は表 4.1で制約される。さらに,Kの値によりEmin及びEmaxの値が決まる。

Where one or both extended-exponent value sets are supported by an implementation, then for each supported extended-exponent value set there is a specific implementation-dependent constant K, whose value is constrained by Table 4.1; this value K in turn dictates the values for Emin and Emax.

表の四つの数値集合は,表に示された範囲の有限非ゼロ値以外に,NaN値,及び,正のゼロ,負のゼロ,正の無限大,並びに負の無限大の四つの値を含む。

Each of the four value sets includes not only the finite nonzero values that are ascribed to it above, but also NaN values and the four values positive zero, negative zero, positive infinity, and negative infinity.

表 4.1の中の制約は,単精度数値集合のすべての要素が必然的に単精度指数部拡張数値集合,倍精度数値集合,及び倍精度指数部拡張数値集合の要素となるように設計されていることに注意。同様に倍精度数値集合のすべての要素も必然的に倍精度指数部拡張数値集合の要素となる。指数部拡張数値集合は対応する標準数値集合よりも大きい指数の幅をもつが,精度が上がるわけではない。

Note that the constraints in Table 4.1 are designed so that every element of the float value set is necessarily also an element of the float-extended-exponent value set, the double value set, and the double-extended-exponent value set. Likewise, each element of the double value set is necessarily also an element of the double-extended-exponent value set. Each extended-exponent value set has a larger range of exponent values than the corresponding standard value set, but does not have more precision.

単精度数値集合の要素はIEEE 754標準の中で定義されている単精度浮動小数点形式を使用して表現できる値と同じものとする。倍精度数値集合の要素はIEEE 754標準の中で定義されている倍精度浮動小数点形式を使用して表現できる値と同じとする。しかし,ここで定義されている単精度指数部拡張及び倍精度指数部拡張数値集合の要素はIEEE 754単精度拡張及び倍精度拡張形式を使用して表現できる値に対応しないので注意すること。

The elements of the float value set are exactly the values that can be represented using the single floating-point format defined in the IEEE 754 standard. The elements of the double value set are exactly the values that can be represented using the double floating-point format defined in the IEEE 754 standard. Note, however, that the elements of the float-extended-exponent and double-extended-exponent value sets defined here do not correspond to the values that can be represented using IEEE 754 single extended and double extended formats, respectively.

単精度,単精度指数部拡張,倍精度,及び倍精度指数部拡張数値集合は型ではない。Javaプログラム言語の実装で型floatの値を表現するために単精度数値集合の要素を使用するのは常に正しい。しかし,実装によっては,コードの一部の領域で単精度指数部拡張数値集合の要素を代わりに使用するのが許される。同様に実装の時に型doubleの値を表現するために倍精度数値集合を使用するのも常に正しい。しかし,実装によっては,コードの一部の領域で倍精度指数部拡張数値集合の要素を代わりに使用するのが許される場合もある。

The float, float-extended-exponent, double, and double-extended-exponent value sets are not types. It is always correct for an implementation of the Java programming language to use an element of the float value set to represent a value of type float; however, it may be permissible in certain regions of code for an implementation to use an element of the float-extended-exponent value set instead. Similarly, it is always correct for an implementation to use an element of the double value set to represent a value of type double; however, it may be permissible in certain regions of code for an implementation to use an element of the double-extended-exponent value set instead.

NaNを除いて,浮動小数点値は最小値から最大値に向かって,負の無限大,負の有限非ゼロ値,負のゼロ,正のゼロ,正の有限非ゼロ値,及び正の無限大の順に 順序付けられている(ordered)とする。

Except for NaN, floating-point values are ordered; arranged from smallest to largest, they are negative infinity, negative finite nonzero values, positive and negative zero, positive finite nonzero values, and positive infinity.

IEEE 754では,個々の単精度及び倍精度浮動小数点形式のために複数の異なったNaN値が許されている。新しいNaNが生成される場合,個々のハードウェアアーキテクチャは,NaNのために特定のビットパターンを返却する。プログラマは,例えば,遡及的診断情報を符号化したような,異なるビットパターンを持つNaNも生成できる。

IEEE 754 allows multiple distinct NaN values for each of its single and double floating-point formats. While each hardware architecture returns a particular bit pattern for NaN when a new NaN is generated, a programmer can also create NaNs with different bit patterns to encode, for example, retrospective diagnostic information.

多くの場合,Javaプラットフォームは与えられた型のNaN値を単一の正準値であるかのように扱う(それゆえこの規定は通常,任意のNaNを正準値として参照する)。しかし,1.3版のJavaプラットフォームではプログラマがNaN値の違いを見分けることを可能にするFloat.floatToRawIntBits及びDouble.doubleToRawLongBitsメソッドを導入した。興味を持った読者は,さらに多くの情報を得るためにFloat 及び Double クラスのための規定を参照せよ。

For the most part, the Java platform treats NaN values of a given type as though collapsed into a single canonical value (and hence this specification normally refers to an arbitrary NaN as though to a canonical value). However, version 1.3 the Java platform introduced methods enabling the programmer to distinguish between NaN values: the Float.floatToRawIntBits and Double.doubleToRawLongBits methods. The interested reader is referred to the specifications for the Float and Double classes for more information.

正のゼロと負のゼロの比較結果は,等しいとする。したがって,式0.0==-0.0の結果はtrueに,0.0>-0.0の結果はfalseになる。しかし,その他の演算は,正及び負のゼロを区別する。例えば,1.0/0.0 は正の無限大の値を持つ。一方,1.0/-0.0の値は負の無限大とする。

Positive zero and negative zero compare equal; thus the result of the expression 0.0==-0.0 is true and the result of 0.0>-0.0 is false. But other operations can distinguish positive and negative zero; for example, 1.0/0.0 has the value positive infinity, while the value of 1.0/-0.0 is negative infinity.

NaNは,順序付けしない(unordered)。したがって,数値比較演算子<<=>,及び >= は,オペランドのいずれか又は両方がNaN (15.20.1) のとき false を返す。どちらかのオペランドがNaN (15.21.1) ならば,等価演算子 ==false を返し,不等演算子 !=trueを返す。特に,x が NaN の場合に限って,x!=xtrueを,x 又は y がNaNならば,(x<y) == !(x>=y)falseを返す。

NaN is unordered, so the numerical comparison operators <, <=, >, and >= return false if either or both operands are NaN (15.20.1). The equality operator == returns false if either operand is NaN, and the inequality operator != returns true if either operand is NaN (15.21.1). In particular, x!=x is true if and only if x is NaN, and (x<y) == !(x>=y) will be false if x or y is NaN.

浮動小数点型の任意の値は,任意の数値型へキャストしてよい。又は任意の数値型からキャストされてもよい。浮動小数点型と型booleanとの間では,キャストできない。

Any value of a floating-point type may be cast to or from any numeric type. There are no casts between floating-point types and the type boolean.

4.2.4 浮動小数点演算
4.2.4 Floating-Point Operations

Javaプログラム言語は,浮動小数点値に作用する演算子を多数提供する。
The Java programming language provides a number of operators that act on floating-point values:

他にも有用なコンストラクタ,メソッド及び定数が,クラスFloatDouble 及び Mathの中であらかじめ定義されている。
Other useful constructors, methods, and constants are predefined in the classes Float, Double, and Math.

二項演算子に対するオペランドのうち少なくとも一つが,浮動小数点型ならば,他方が整数的であっても,演算は,浮動小数点演算とする。

If at least one of the operands to a binary operator is of floating-point type, then the operation is a floating-point operation, even if the other is integral.

数値演算子のオペランドのうち少なくとも一つが,型doubleならば,演算を64ビット精度浮動小数点計算によって実行し,その数値演算子の結果を,型 doubleの値にする。(他方のオペランドがdoubleでなければ,演算に先立って,数値昇格 (5.6) によって型doubleに拡張する。)そうでなければ,演算は32ビット精度浮動小数点計算によって実行し,その数値演算子の結果は,型floatの値とする。他方のオペランドがfloatでなければ,演算に先立って,数値昇格によって型floatに拡張する。

If at least one of the operands to a numerical operator is of type double, then the operation is carried out using 64-bit floating-point arithmetic, and the result of the numerical operator is a value of type double. (If the other operand is not a double, it is first widened to type double by numeric promotion (5.6).) Otherwise, the operation is carried out using 32-bit floating-point arithmetic, and the result of the numerical operator is a value of type float. If the other operand is not a float, it is first widened to type float by numeric promotion.

浮動小数点数に対する演算は,(剰余演算子を除いて (15.17.3)),正確にIEEE 754で規定したとおりに振る舞うものとする。特に,Javaプログラム言語は,IEEE 754 の非正規化(denormalized) 浮動小数点数及び 緩やかなアンダフロー(gradual underflow)を扱う必要がある。これらは,数値アルゴリズムの望ましい特性の証明を容易にする。 浮動小数点演算は,計算結果が非正規化数ならば,"ゼロにフラッシュする"ことはない。

Operators on floating-point numbers behave as specified by IEEE 754 (with the exception of the remainder operator (15.17.3)). In particular, the Java programming language requires support of IEEE 754 denormalized floating-point numbers and gradual underflow, which make it easier to prove desirable properties of particular numerical algorithms. Floating-point operations do not "flush to zero" if the calculated result is a denormalized number.

Javaプログラム言語は,すべての浮動小数点演算子が,その浮動小数点の結果を,結果精度に丸めたかのように振る舞う計算を必要とする。不正確(inexact)な結果は,正確な結果に限りなく最も近い表現可能値に丸めなければならない。二つの同程度に近い代表値があるときは,もっとも重みのないビット(Least Significant Bit,LSB)がゼロのものが選ばれる。これが,直近への丸め (round to nearest) として知られている,IEEE 754規格のデフォルト丸めモードである。

The Java programming language requires that floating-point arithmetic behave as if every floating-point operator rounded its floating-point result to the result precision. Inexact results must be rounded to the representable value nearest to the infinitely precise result; if the two nearest representable values are equally near, the one with its least significant bit zero is chosen. This is the IEEE 754 standard's default rounding mode known as round to nearest.

Javaは,浮動小数点値を整数 (5.1.3) に変換するときに, ゼロに向かう丸め(round toward zero) を適用する。この場合には,仮数ビットを切り捨てるように動作する。ゼロに向かう丸めでは,その形式の値が,大きさに関して正確な値に限りなく最も近くて,しかも大きくない結果を選ぶ。

The language uses round toward zero when converting a floating value to an integer (5.1.3), which acts, in this case, as though the number were truncated, discarding the mantissa bits. Rounding toward zero chooses at its result the format's value closest to and no greater in magnitude than the infinitely precise result.

Javaの浮動小数点演算子は,例外 (11.) を引き起こさない。オーバフローを生じる演算は,符号付き無限大を返し,アンダフローを引き起こす演算は,符号付きゼロを返し,数学的に確定した結果をもたない演算は,NaNを返す。オペランドとしてNaNをもつすべての数値演算は,結果としてNaNを返す。既に述べたとおり,NaNは順序付けしない。したがって,一つ又は二つのNaNを含む数値比較演算はfalse を返し,NaNを含む != 比較は true を返す。これは,x がNaNであるときのx!=x を含む。

Floating-point operators produce no exceptions (11). An operation that overflows produces a signed infinity, an operation that underflows produces a denormalized value or a signed zero, and an operation that has no mathematically definite result produces NaN. All numeric operations with NaN as an operand produce NaN as a result. As has already been described, NaN is unordered, so a numeric comparison operation involving one or two NaNs returns false and any != comparison involving NaN returns true, including x!=x when x is NaN.

次に例を示す。

The example program:
class Test {
	public static void main(String[] args) {
		// An example of overflow:
		double d = 1e308;
		System.out.print("overflow produces infinity: ");
		System.out.println(d + "*10==" + d*10);
		// An example of gradual underflow:
		d = 1e-305 * Math.PI;
		System.out.print("gradual underflow: " + d + "\n    ");
		for (int i = 0; i < 4; i++)
			System.out.print(" " + (d /= 100000));
		System.out.println();
		// An example of NaN:
		System.out.print("0.0/0.0 is Not-a-Number: ");
		d = 0.0/0.0;
		System.out.println(d);
		// An example of inexact results and rounding:
		System.out.print("inexact results with float:");
		for (int i = 0; i < 100; i++) {
			float z = 1.0f / i;
			if (z * i != 1.0f)
				System.out.print(" " + i);
		}
		System.out.println();
		// Another example of inexact results and rounding:
		System.out.print("inexact results with double:");
		for (int i = 0; i < 100; i++) {
			double z = 1.0 / i;
			if (z * i != 1.0)
				System.out.print(" " + i);
		}
		System.out.println();
		// An example of cast to integer rounding:
		System.out.print("cast to int rounds toward 0: ");
		d = 12345.6;
		System.out.println((int)d + " " + (int)(-d));
	}
}
この例は,次の出力を生成する。
produces the output:

overflow produces infinity: 1.0e+308*10==Infinity
gradual underflow: 3.141592653589793E-305
	3.1415926535898E-310 3.141592653E-315 3.142E-320 0.0
0.0/0.0 is Not-a-Number: NaN
inexact results with float: 0 41 47 55 61 82 83 94 97
inexact results with double: 0 49 98
cast to int rounds toward 0: 12345 -12345
この例は,緩やかなアンダフローが緩やかな精度の損失を生じる可能性があることを示す。
This example demonstrates, among other things, that gradual underflow can result in a gradual loss of precision.
i0 のときの不正確な結果は,ゼロによる除算を含む。そこで, z は正の無限大となり,z * 0はNaNとなる。1.0に等しくはならない。
The results when i is 0 involve division by zero, so that z becomes positive infinity, and z * 0 is NaN, which is not equal to 1.0.

4.2.5 boolean型 及び boolean
4.2.5 The boolean Type and boolean Values

booleanは,リテラル true 及び false (3.10.3) で示す二つの可能な値をもつ論理的な量を表す。論理演算子には,次の種類がある。
The boolean type represents a logical quantity with two possible values, indicated by the literals true and false (3.10.3). The boolean operators are:

論理式は,幾つかの種類の文において制御フローを決定する。
Boolean expressions determine the control flow in several kinds of statements:

boolean 式はまた,条件演算子 ? : (15.25) において,どの副式を評価するかを決定する。
A boolean expression also determines which subexpression is evaluated in the conditional ? : operator (15.25).

boolean 式だけが,条件演算子 ? : の最初のオペランドとして,及び,制御フロー文内で使用できる。任意の非ゼロ値が true となるC言語の慣習に従うには,整数 x を,式 x!=0 によって boolean に変換する。null でない任意の参照が true となるC言語の慣習に従うには,オブジェクト参照 obj を,式 obj!=null によって boolean に変換する。

Only boolean expressions can be used in control flow statements and as the first operand of the conditional operator ? :. An integer x can be converted to a boolean, following the C language convention that any nonzero value is true, by the expression x!=0. An object reference obj can be converted to a boolean, following the C language convention that any reference other than null is true, by the expression obj!=null.

boolean 値の型 boolean へのキャストは許される (5.1.1)。型 boolean に関する他のキャストは許されない。boolean 値は,文字列変換 (5.4) によって文字列に変換できる。

A cast of a boolean value to type boolean is allowed (5.1.1); no other casts on type boolean are allowed. A boolean can be converted to a string by string conversion (5.4).

4.3 参照型及び値
4.3 Reference Types and Values

参照型(reference types)には,クラス型 (8),インタフェース型 (9) 及び配列型 (10) の3種類の型が存在する。
There are three kinds of reference types: class types (8), interface types (9), and array types (10).

名前は,6で規定する。型名は,6.5,特に6.5.5で規定する。
Names are described in 6; type names in 6.5 and, specifically, 6.5.5.

次に例を示す。

The sample code:
class Point { int[] metrics; }
interface Move { void move(int deltax, int deltay); }
この例は,クラス型 Point 及びインタフェース型 Move を宣言し,クラス Point のフィールド metrics を宣言するために,配列型 int[]int の配列)を使用する。
declares a class type Point, an interface type Move, and uses an array type int[] (an array of int) to declare the field metrics of the class Point.

4.3.1 オブジェクト
4.3.1 Objects

オブジェクト(object)は,クラス インスタンス(class instance) 又は配列に分かれる。
An object is a class instance or an array.

参照値(しばしば単に 参照(references) と呼ぶ)は,オブジェクトへの ポインタ(pointers) もしくは,いかなるオブジェクトも参照しない特別な空参照となる。

The reference values (often just references) are pointers to these objects, and a special null reference, which refers to no object.

クラスインスタンスは,クラスインスタンス生成式 (15.9) によって明示的に生成される。配列は,配列生成式 (15.9) によって明示的に生成される。

A class instance is explicitly created by a class instance creation expression (15.9). An array is explicitly created by an array creation expression (15.9).

式において文字列連結演算子 + (15.18.1) を使用するときは,新しいクラスインスタンスが暗黙のうちに生成され,結果として型 String (4.3.3) の新しいオブジェクトとなる。新しい配列オブジェクトは,配列初期化式 (10.6) を評価するときに,暗黙のうちに生成される。これは,クラス又はインタフェースを初期化する (12.4) とき,クラスの新しいインスタンスを生成する (15.9) とき,又は局所変数宣言文を実行する (14.4) ときに発生する。

A new class instance is implicitly created when the string concatenation operator + (15.18.1) is used in an expression, resulting in a new object of type String (4.3.3). A new array object is implicitly created when an array initializer expression (10.6) is evaluated; this can occur when a class or interface is initialized (12.4), when a new instance of a class is created (15.9), or when a local variable declaration statement is executed (14.4).

これらの場合を次の例で示す。

Many of these cases are illustrated in the following example:
class Point {
	int x, y;
	Point() { System.out.println("default"); }
	Point(int x, int y) { this.x = x; this.y = y; }
	// A Point instance is explicitly created at class initialization time:
	static Point origin = new Point(0,0);
	// A String can be implicitly created by a + operator:
	public String toString() {
		return "(" + x + "," + y + ")";
	}
}
class Test {
	public static void main(String[] args) {
		// A Point is explicitly created using newInstance:
		Point p = null;
		try {
			p = (Point)Class.forName("Point").newInstance();
		} catch (Exception e) {
			System.out.println(e);
		}
		// An array is implicitly created by an array constructor:
		Point a[] = { new Point(0,0), new Point(1,1) };
		// Strings are implicitly created by + operators:
		System.out.println("p: " + p);
		System.out.println("a: { " + a[0] + ", " + a[1] + " }");
		// An array is explicitly created by an array creation expression:
		String sa[] = new String[2];
		sa[0] = "he"; sa[1] = "llo";
		System.out.println(sa[0] + sa[1]);
	}
}
この例は,次の出力を生成する。
which produces the output:

default
p: (0,0)
a: { (0,0), (1,1) }
hello
オブジェクトへの参照に対する演算子には,次の種類がある。
The operators on references to objects are:

同じオブジェクトへの参照は,複数存在してもよい。ほとんどのオブジェクトは,クラスのインスタンスであるオブジェクトのフィールド又は配列オブジェクトの構成要素である変数に,状態を記憶する。二つの変数があり,同じオブジェクトへの参照を保持していれば,オブジェクトの状態は,一方の変数の参照を使って変更できる。その変更した状態を,もう一方の変数の参照により観察できる。
There may be many references to the same object. Most objects have state, stored in the fields of objects that are instances of classes or in the variables that are the components of an array object. If two variables contain references to the same object, the state of the object can be modified using one variable's reference to the object, and then the altered state can be observed through the reference in the other variable.

次に例を示す。

The example program:
class Value { int val; }
class Test {
	public static void main(String[] args) {
		int i1 = 3;
		int i2 = i1;
		i2 = 4;
		System.out.print("i1==" + i1);
		System.out.println(" but i2==" + i2);
		Value v1 = new Value();
		v1.val = 5;
		Value v2 = v1;
		v2.val = 6;
		System.out.print("v1.val==" + v1.val);
		System.out.println(" and v2.val==" + v2.val);
	}
}
この例は,次を出力する。
produces the output:

i1==3 but i2==4
v1.val==6 and v2.val==6
これは,v1.val 及び v2.valnew 式だけによって生成された一つのオブジェクト Value 内で同じインスタンス変数 (4.5.3) を参照していることによる。一方,i1 及び i2 は,別々の変数である。
because v1.val and v2.val reference the same instance variable (4.5.3) in the one Value object created by the only new expression, while i1 and i2 are different variables.

配列の生成及び使用の例は,10 及び 15.10 を参照すること。

See 10 and 15.10 for examples of the creation and use of arrays.
個々のオブジェクトは,対応したロック (17.13) をもつ。これは,多重スレッド (17.12) による状態への同時アクセスを制御するために,synchronizedメソッド (8.4.3) 及びsynchronized文 (14.18) で使用する。
Each object has an associated lock (17.13), which is used by synchronized methods (8.4.3) and the synchronized statement (14.18) to provide control over concurrent access to state by multiple threads (17.12).

4.3.2 クラス Object
4.3.2 The Class Object

クラス Objectは,すべての他のクラスの上位クラス (8.1) となる。型 Object の変数は,それがクラスのインスタンスか,配列 (10) のインスタンスかにかかわらず,任意のオブジェクトへの参照をもつことができる。すべてのクラス及び配列型は,クラス Object のメソッドを継承する。そのメソッドについて,ここでまとめる。
The class Object is a superclass (8.1) of all other classes. A variable of type Object can hold a reference to any object, whether it is an instance of a class or an array (10). All class and array types inherit the methods of class Object, which are summarized here:

package java.lang;

public class Object {
	public final Class getClass() { . . . }
	public String toString() { . . . }
	public boolean equals(Object obj) { . . . }
	public int hashCode() { . . . }
	protected Object clone()
		throws CloneNotSupportedException { . . . }
	public final void wait()
		throws IllegalMonitorStateException,
			InterruptedException { . . . }
	public final void wait(long millis)
		throws IllegalMonitorStateException,
			InterruptedException { . . . }
	public final void wait(long millis, int nanos) { . . . }
		throws IllegalMonitorStateException,
			InterruptedException { . . . }
	public final void notify() { . . . }
		throws IllegalMonitorStateException
	public final void notifyAll() { . . . }
		throws IllegalMonitorStateException
	protected void finalize()
		throws Throwable { . . . }
}
Object のメンバには,次のものがある。
The members of Object are as follows:

4.3.3 クラス String
4.3.3 The Class String

クラス String のインスタンスは,Unicode 文字の並びを表す。オブジェクト String は,定数(変更されない)値をもつ。文字列リテラル (3.10.5) は,クラス String のインスタンスを参照する。
Instances of class String represent sequences of Unicode characters. A String object has a constant (unchanging) value. String literals (3.10.5) are references to instances of class String.

文字列連結演算子 + (15.18.1) は,新しいオブジェクト String を暗黙のうちに生成する。

The string concatenation operator + (15.18.1) implicitly creates a new String object.

4.3.4 参照型の同一条件
4.3.4 When Reference Types Are the Same

2つの参照型が同一バイナリ名 (13.1) を持つ場合,2つの参照型は同一コンパイル時型(same compile-time type)とする。この場合を 同一クラス(same class) 又は 同一インタフェース(same interface) と呼ぶこともある。
Two reference types are the same compile-time type if they have the same binary name (13.1), in which case they are sometimes said to be the same class or the same interface.

実行時に,同一バイナリ名をもつ幾つかの参照型は,異なるクラスローダによって同時にロードされるかもしれない。これらの型は同一型宣言を表現するかもしれないし,しないかもしれない。2つの型が同一型宣言を表現していたとしても,それらは異なるものと考えられる。

At run time, several reference types with the same binary name may be loaded simultaneously by different class loaders. These types may or may not represent the same type declaration. Even if two such types do represent the same type declaration, they are considered distinct.

次の条件を満たすとき,二つの参照型を同一実行時型(same run-time type) とする。

Two reference types are the same run-time type if:

4.4 型の使用場所
4.4 Where Types Are Used

型は,宣言又は一部の式で使用する。
Types are used when they appear in declarations or in certain expressions.

型の複数の使用例を次のコード断片で示す。

The following code fragment contains one or more instances of most kinds of usage of a type:
import java.util.Random;
class MiscMath {
	int divisor;
	MiscMath(int divisor) {
		this.divisor = divisor;
	}
	float ratio(long l) {
		try {
			l /= divisor;
		} catch (Exception e) {
			if (e instanceof ArithmeticException)
				l = Long.MAX_VALUE;
			else
				l = 0;
		}
		return (float)l;
	}
	double gausser() {
		Random r = new Random();
		double[] val = new double[2];
		val[0] = r.nextGaussian();
		val[1] = r.nextGaussian();
		return (val[0] + val[1]) / 2;
	}
}
この例では,次の宣言で型が使用される。
In this example, types are used in declarations of the following:

さらに次の種類の式で型が使用される。
and in expressions of the following kinds:

4.5 変数
4.5 Variables

変数は,記憶域の位置を示し,プリミティブ型 (4.2) 又は参照型 (4.3) のコンパイル時の型(compile-time type) とも呼ばれる型をもつ。変数は,常に,その型と代入互換 (5.2) な値を含む。変数の値は,代入 (15.26) 又は接頭若しくは接尾の ++(増分)若しくは--(減分)演算子 (15.14.115.14.215.15.115.15.2) によって変更される。
A variable is a storage location and has an associated type, sometimes called its compile-time type, that is either a primitive type (4.2) or a reference type (4.3). A variable always contains a value that is assignment compatible (5.2) with its type. A variable's value is changed by an assignment (15.26) or by a prefix or postfix ++ (increment) or -- (decrement) operator (15.14.1, 15.14.2, 15.15.1, 15.15.2).

変数の値とその型との互換性は,Java言語設計が保証する。デフォルト値は互換的 (4.5.5) であって,変数へのすべての代入は,代入互換性 (5.2) を,通常はコンパイル時に検査される。ただし,配列が関係する場合に限り,実行時検査を実行する (10.10)。

Compatibility of the value of a variable with its type is guaranteed by the design of the Java programming language. Default values are compatible (4.5.5) and all assignments to a variable are checked for assignment compatibility (5.2), usually at compile time, but, in a single case involving arrays, a run-time check is made (10.10).

4.5.1 プリミティブ型の変数
4.5.1 Variables of Primitive Type

プリミティブ型の変数は,常にそのプリミティブ型の値を保持する。
A variable of a primitive type always holds a value of that exact primitive type.

4.5.2 参照型の変数
4.5.2 Variables of Reference Type

参照型の変数は,次のいずれかを保持できる。
A variable of reference type can hold either of the following:

4.5.3 変数の種類
4.5.3 Kinds of Variables

変数には,次の7種類が存在する。
There are seven kinds of variables:

  1. クラス変数 (class variable) は,クラス宣言 (8.3.1.1) の中にキーワードstaticを使用して宣言したフィールド,又はインタフェース宣言 (9.3) の中でキーワードstaticを使用若しくは使用しないで宣言したフィールドを言う。クラス変数は,そのクラス又はインタフェースを,ロードした (12.3.2) ときに生成され,デフォルト値 (4.5.5) に初期化される。クラス変数は,そのクラス又はインタフェースをアンロードした (12.7) とき,実質的にその存在を終了する。
    A class variable is a field declared using the keyword static within a class declaration (8.3.1.1), or with or without the keyword static within an interface declaration (9.3). A class variable is created when its class or interface is prepared (12.3.2) and is initialized to a default value (4.5.5). The class variable effectively ceases to exist when its class or interface is unloaded (12.7).
  2. インスタンス変数(instance variable) は,クラス宣言の中に,キーワードstatic (8.3.1.1) を使用しないで宣言したフィールドを言う。クラスT がインスタンス変数フィールドa をもてば,T 又はT (8.1.3) の下位クラスのオブジェクトを新しく生成したとすると,新たなインスタンス変数a がオブジェクトの一部として生成され,デフォルト値 (4.5.5) が,初期値として設定される。インスタンス変数は,それがフィールドとなっているオブジェクトが参照されなくなったとき,そのオブジェクト (12.6) のすべての必要な終了処理を完了した後に,実質的にその存在を終了する。
    An instance variable is a field declared within a class declaration without using the keyword static (8.3.1.1). If a class T has a field a that is an instance variable, then a new instance variable a is created and initialized to a default value (4.5.5) as part of each newly created object of class T or of any class that is a subclass of T (8.1.3). The instance variable effectively ceases to exist when the object of which it is a field is no longer referenced, after any necessary finalization of the object (12.6) has been completed.
  3. 配列構成要素(array components) は,新しい配列オブジェクトが生成される (15.10) ときに常に生成される名前なし変数で,デフォルト値 (4.5.5) に初期化される。配列構成要素は,その配列を参照しなくなったときに,実質的にその存在を終了する。配列の規定については,10.を参照すること。
    Array components are unnamed variables that are created and initialized to default values (4.5.5) whenever a new object that is an array is created (15.10). The array components effectively cease to exist when the array is no longer referenced. See 10 for a description of arrays.
  4. メソッドパラメタ(method parameters) (8.4.1) は,メソッドに渡す実引数の値を保持する。メソッドを呼び出す (15.12) たびに,そのメソッド宣言に宣言した個々のパラメタ用に,新しいパラメタ変数が生成される。この新しい変数は,メソッド呼出しの対応する実引数の値を初期値とする。メソッドパラメタは,そのメソッドの本体の実行が完了したときに,実質的にその存在を終了する。
    Method parameters (8.4.1) name argument values passed to a method. For every parameter declared in a method declaration, a new parameter variable is created each time that method is invoked (15.12). The new variable is initialized with the corresponding argument value from the method invocation. The method parameter effectively ceases to exist when the execution of the body of the method is complete.
  5. コンストラクタパラメタ(constructor parameters) (8.8.1) は,コンストラクタに渡す実引数の値を保持する。クラスインスタンス生成式 (15.9) 又は明示的なコンストラクタ呼出し (8.8.5) が,コンストラクタを呼び出すたびに,そのコンストラクタ宣言で宣言した個々のパラメタ用に,新しいパラメタ変数が生成される。この新しい変数は,生成式又はコンストラクタ呼出しの対応する実引数の値に初期化される。コンストラクタパラメタは,そのコンストラクタの本体の実行が完了したときに,実質的にその存在を終了する。
    Constructor parameters (8.8.1) name argument values passed to a constructor. For every parameter declared in a constructor declaration, a new parameter variable is created each time a class instance creation expression (15.9) or explicit constructor invocation (8.8.5) invokes that constructor. The new variable is initialized with the corresponding argument value from the creation expression or constructor invocation. The constructor parameter effectively ceases to exist when the execution of the body of the constructor is complete.
  6. 例外ハンドラパラメタ(exception-handler parameter) は,try文 (14.19) の catch 節によって例外が捕捉されるたびに生成される。この新しい変数は,その例外 (11.314.17) に対応した実際のオブジェクトを初期値とする。例外ハンドラパラメタは,catch 節によるブロックの実行が完了したときに,実質的にその存在を終了する。
    An exception-handler parameter is created each time an exception is caught by a catch clause of a try statement (14.19). The new variable is initialized with the actual object associated with the exception (11.3, 14.17). The exception-handler parameter effectively ceases to exist when execution of the block associated with the catch clause is complete.
  7. 局所変数(local variables)は,局所変数宣言文 (14.4) で宣言する。制御の流れがブロック (14.2) 又はfor文 (14.13) に入ったときにいつでも,そのブロック又はfor文内に直接含まれている局所変数宣言文で宣言した個々の局所変数用に,新しい変数が生成される。局所変数宣言文は,その変数を初期設定する式を含んでもよい。しかしながら,初期化式をもつ局所変数は,それを宣言している局所変数宣言文が実行されるまで,初期化されない。(確実な代入の規則 (16.) は,局所変数の値が,それが初期化されるか又は別途値が代入される以前に使用されることを防止する。) 局所変数は,ブロック又はfor文の実行が完了したときに,実質的にその存在を終了する。
    Local variables are declared by local variable declaration statements (14.4). Whenever the flow of control enters a block (14.2) or for statement (14.13), a new variable is created for each local variable declared in a local variable declaration statement immediately contained within that block or for statement. A local variable declaration statement may contain an expression which initializes the variable. The local variable with an initializing expression is not initialized, however, until the local variable declaration statement that declares it is executed. (The rules of definite assignment (16) prevent the value of a local variable from being used before it has been initialized or otherwise assigned a value.) The local variable effectively ceases to exist when the execution of the block or for statement is complete.
一つの例外的な状況を除いて,局所変数は,常にその局所変数宣言文を実行したときに生成されたとみなせる。その例外的な状況とは,switch文 (14.10) に関係する。そこでは,制御が,局所変数宣言文の実行を迂回してブロックに入ることができる。しかしながら,確実な代入 (16.) の規則による制限のために,この迂回した局所変数宣言文で宣言した局所変数は,代入式 (15.26) によって,値を確実に代入されるまでは,使用できない。
Were it not for one exceptional situation, a local variable could always be regarded as being created when its local variable declaration statement is executed. The exceptional situation involves the switch statement (14.10), where it is possible for control to enter a block but bypass execution of a local variable declaration statement. Because of the restrictions imposed by the rules of definite assignment (16), however, the local variable declared by such a bypassed local variable declaration statement cannot be used before it has been definitely assigned a value by an assignment expression (15.26).
次の例は,幾つかの違った種類の変数を含む。
The following example contains several different kinds of variables:
class Point {
	static int numPoints;		// numPoints is a class variable
	int x, y;			// x and y are instance variables
	int[] w = new int[10];		// w[0] is an array component
	int setX(int x) {		// x is a method parameter
		int oldx = this.x;	// oldx is a local variable
		this.x = x;
		return oldx;
	}
}

4.5.4 最終変数
4.5.4 final Variables

変数はfinalと宣言できる。最終変数は一回しか代入できない。代入の直前に確実に未代入ではない限り (16.),最終変数への代入は,コンパイル時エラーとなる。
A variable can be declared final. A final variable may only be assigned to once. It is a compile time error if a final variable is assigned to unless it is definitely unassigned (16) immediately prior to the assignment.

未初期化最終(blank final) は,宣言で初期化子を欠いている最終変数とする。

A blank final is a final variable whose declaration lacks an initializer.

final 変数は,一度代入されると常に同じ値をもつ。final 変数がオブジェクトへの参照を保持する場合,オブジェクトの状態はオブジェクトの演算によって変わるかもしれないが,変数は常に同じオブジェクトを参照する。配列はオブジェクトなので,これは配列にも適用される。final 変数が配列への参照を保持する場合,配列の構成要素は配列の演算によって変わるかもしれないが,変数は常に同じ配列を参照する。

Once a final variable has been assigned, it always contains the same value. If a final variable holds a reference to an object, then the state of the object may be changed by operations on the object, but the variable will always refer to the same object. This applies also to arrays, because arrays are objects; if a final variable holds a reference to an array, then the components of the array may be changed by operations on the array, but the variable will always refer to the same array.

変数をfinalと宣言することは,値が変わらないということを表す有益な情報となるので,プログラムエラーの回避を助けるものとなる。

Declaring a variable final can serve as useful documentation that its value will not change and can help avoid programming errors.

次に例を示す。

In the example:
class Point {
	int x, y;
	int useCount;
	Point(int x, int y) { this.x = x; this.y = y; }
	final static Point origin = new Point(0, 0);
}
クラス Pointfinal クラス変数 origin を宣言する。origin 変数は,座標が (0, 0) のクラスのインスタンスPointとなるオブジェクトへの参照を保持する。変数 Point.origin の値は絶対に変わらず,初期化子によって生成される同じ Point オブジェクトへいつも参照する。しかし,この Point オブジェクトの演算はその状態を変えるかもしれない。例えば,useCount を変更したり,間違ってx又は y座標を変更してしまうことがあるかもしれない。
the class Point declares a final class variable origin. The origin variable holds a reference to an object that is an instance of class Point whose coordinates are (0, 0). The value of the variable Point.origin can never change, so it always refers to the same Point object, the one created by its initializer. However, an operation on this Point object might change its state-for example, modifying its useCount or even, misleadingly, its x or y coordinate.

4.5.5 変数の初期値
4.5.5 Initial Values of Variables

Javaプログラムのすべての変数は,その値が使用される前に,値をもっていなければならない。
Every variable in a program must have a value before its value is used:

次に例を示す。
The example program:

class Point {
	static int npoints;
	int x, y;
	Point root;
}
class Test {
	public static void main(String[] args) {
		System.out.println("npoints=" + Point.npoints);
		Point p = new Point();
		System.out.println("p.x=" + p.x + ", p.y=" + p.y);
		System.out.println("p.root=" + p.root);
	}
}
この例は,次を出力する。
prints:

npoints=0
p.x=0, p.y=0
p.root=null
これは,クラス Point を準備するとき (12.3.2) に発生する npoints のデフォルト初期化,並びに新しい Point をインスタンス化するときに発生する xy 及び root のデフォルト初期化を示している。クラス及びインタフェースのロード,リンク及び初期化に関するあらゆる面の詳細な規定,並びに新しいクラスインスタンスを生成するためのクラスのインスタンス化の規定については,12を参照のこと。
illustrating the default initialization of npoints, which occurs when the class Point is prepared (12.3.2), and the default initialization of x, y, and root, which occurs when a new Point is instantiated. See 12 for a full description of all aspects of loading, linking, and initialization of classes and interfaces, plus a description of the instantiation of classes to make new class instances.

4.5.6 型,クラス,及びインタフェース
4.5.6 Types, Classes, and Interfaces

Javaプログラム言語において,すべての変数及びすべての式はコンパイル時に決定される型を持っている。その型はプリミティブ型又は参照型となる。参照型はクラス型及びインタフェース型を含む。参照型はクラス宣言 (8.1) 及びインタフェース宣言 (9.1) を含む型宣言によって導入された。クラス又はインタフェースに言及するときにという用語をしばしば用いる。
In the Java programming language, every variable and every expression has a type that can be determined at compile time. The type may be a primitive type or a reference type. Reference types include class types and interface types. Reference types are introduced by type declarations, which include class declarations (8.1) and interface declarations (9.1). We often use the term type to refer to either a class or an interface.

すべてのオブジェクトは,次に示すどれかのクラスに属する。つまり,そのオブジェクトを生成した生成式で言及したクラス,オブジェクトを生成するための自己反映的メソッドを呼び出すために Class オブジェクトが使用されたクラス,又は文字列連結演算子 + (15.18.1) によって暗黙に生成されたオブジェクト用の String クラス,のどれかに属する。このクラスを,そのオブジェクトのクラス(class of the object) と呼ぶ。(この節の最後で規定するとおり,配列もまたクラスを持つ。) オブジェクトは,そのクラス及びそのクラスのすべての上位クラスのインスタンスであるという。

Every object belongs to some particular class: the class that was mentioned in the creation expression that produced the object, the class whose Class object was used to invoke a reflective method to produce the object, or the String class for objects implicitly created by the string concatenation operator + (15.18.1). This class is called the class of the object. (Arrays also have a class, as described at the end of this section.) An object is said to be an instance of its class and of all superclasses of its class.

変数又は式が"実行時型"を持つということがある。これは実行時における変数又は式の値がnullでないと仮定して,その値によって参照されるオブジェクトのクラスを言及する。

Sometimes a variable or expression is said to have a "run-time type". This refers to the class of the object referred to by the value of the variable or expression at run time, assuming that the value is not null.

変数のコンパイル時の型は常に宣言されており,式のコンパイル時の型はコンパイル時に推論できる。コンパイル時の型は,その変数が持つことのできる値,又は実行時に式が生成することのできる値を制限する。変数の実行時の値が null 以外の参照ならば,それは,クラスをもつオブジェクト又は配列を参照する。そのクラスは,必然的にコンパイル時の型と互換となる。

The compile time type of a variable is always declared, and the compile time type of an expression can be deduced at compile time. The compile time type limits the possible values that the variable can hold or the expression can produce at run time. If a run-time value is a reference that is not null, it refers to an object or array that has a class, and that class will necessarily be compatible with the compile-time type.

変数又は式が,インタフェース型のコンパイル時型をもったとしても,インタフェースのインスタンスそのものは存在しない。インタフェース型の変数又は式は,そのインタフェースを実装した (8.1.4) クラスの任意のオブジェクトを参照できる。

Even though a variable or expression may have a compile-time type that is an interface type, there are no instances of interfaces. A variable or expression whose type is an interface type can reference any object whose class implements (8.1.4) that interface.

次に,新しいオブジェクトを生成し,変数の型とオブジェクトのクラスとの違いを示す例を与える。

Here is an example of creating new objects and of the distinction between the type of a variable and the class of an object:
public interface Colorable {
	void setColor(byte r, byte g, byte b);
}
class Point { int x, y; }
class ColoredPoint extends Point implements Colorable {
	byte r, g, b;
	public void setColor(byte rv, byte gv, byte bv) {
		r = rv; g = gv; b = bv;
	}
}
class Test {
	public static void main(String[] args) {
		Point p = new Point();
		ColoredPoint cp = new ColoredPoint();
		p = cp;
		Colorable c = cp;
	}
}
次に例を示す。
In this example:

すべての配列も又クラスを持つ。メソッド getClass は,配列オブジェクトに対して呼び出した時は,配列のクラスを表す(クラス Class の) クラスオブジェクトを返す。
Every array also has a class; the method getClass, when invoked for an array object, will return a class object (of class Class) that represents the class of the array.

配列用のクラスは,識別子としては正当でない奇妙な名前を持つ。例えば 構成要素が int の配列のクラスは,"[I" という名前をもつ。したがって,式

The classes for arrays have strange names that are not valid identifiers; for example, the class for an array of int components has the name "[I" and so the value of the expression:
new int[10].getClass().getName()
の値は,文字列 "[I" となる。詳細は,Class.getNameの規定を参照すること。
is the string "[I"; see the specification of Class.getName for details.

目次 | | | 索引 Java言語規定
第2版

Please send any comments or corrections to jls@java.sun.com