https://DevOpsCloud.io -- Cloud Monk Losang Jinpa

Example 5.0-1. Conversions at Compile Time and Run Time

A conversion from type Object to type Thread requires a run-time check to make sure that the run-time value is actually an instance of class Thread or one of its subclasses; if it is not, an exception is thrown.

A conversion from type Thread to type Object requires no run-time action; Thread is a subclass of Object, so any reference produced]] by an expression of type Thread is a valid reference value of type Object.

A conversion from type int to type long requires run-time sign-extension of a 32-bit integer value to the 64-bit long representation. No information is lost.

A conversion from type double to type long requires a non-trivial translation from a 64-bit floating-point value to the 64-bit integer representation. Depending on the actual run-time value, information may be lost.

The conversions possible in the Java programming language are grouped into several broad categories:

Id[[entity conversions

Widening primitive conversions

Narrowing]] primitive conversions

Widening reference conversions

Narrowing]] reference conversions

Boxing conversions

Unboxing conversions

Unchecked conversions

Capture conversions

String conversions

There are six kinds of conversion contexts in which poly expressions may be influenced by context or implicit [[conversions may occur. Each kind of context has different rules for poly expression typing and allows conversions in some of the categories above but not others. The contexts are:

Assignment contexts (§5.2, §15.26), in which an expression's value is bound to a named variable. Primitive and reference types are subject to widening, values

may be boxed or unboxed, and some primitive constant expressions may be subject to narrowing]]. An unchecked conversion may also occur.

108

Strict invocation contexts (§5.3, §15.9, §15.12), in which an argument is bound to a formal parameter of a constructor or method. Widening primitive, widening

reference, and unchecked conversions may occur.

Loose invocation contexts (§5.3, §15.9, §15.12), in which, like strict invocation contexts, an argument is bound to a formal parameter. Method or constructor invocations may provide this context if no applicable declaration can be found

using only strict invocation contexts. In addition to widening and unchecked conversions, this context allows boxing and unboxing conversions to occur.

String contexts (§5.4, §15.18.1), in which a value of any type is convert ed to an object of type String.

Casting contexts (§5.5), in which an expression's value is convert ed to a type explicitly specified by a cast operator (§15.16). Casting contexts are more inclusive than assignment or loose invocation contexts, allowing any specific conversion other than a string conversion, but certain casts to a reference type are checked for correctness at run time.

Numeric contexts (§5.6), in which the operands of a numeric operator or some other expressions that operate on numbers may be widened to a common type.

The term ”conversion“ is also used to describe, without being specific, any conversions allowed in a particular context. For example, we say that an expression that is the initializer of a local variable is subject to ”assignment conversion“, meaning that a specific conversion will be implicitly chosen for that expression according to the rules for the assignment context. As another example, we say that an expression undergoes ”casting conversion“ to mean that the expression's type will be convert ed as permitted in a casting context.

Example 5.0-2. Conversions In Various Contexts

// Casting conversion (5.5) of a float literal to

// type int. Without the cast operator, this would

// be a compile-time error, because this is a

// narrowing]] conversion (5.1.3):

int i = (int)12.5f;

// String conversion (5.4) of i's int value:

System.out]].println(”(int)12.5f==“ + i);

// Assignment conversion (5.2) of i's value to type

// float. This is a widening conversion (5.1.2):

float f = i;

// String conversion of f's float value:

109

5.1

Kinds of Conversion

System.out]].println(“after float widening: ” + f);

// Numeric promotion (5.6) of i's value to type

// float. This is a binary numeric promotion.

// After promotion, the operation is float

float:

System.out]].print(f);

f = f * i;

// Two string conversions of i and f:

System.out]].println(“

” + i + ”==“ + f);

// Invocation conversion (5.3) of f's value

// to type double, needed because the method Math.sin

// accepts only a double argument:

double d = Math.sin(f);

// Two string conversions of f and d:

System.out]].println(”Math.sin(“ + f + ”)==“ + d);

}

This program produces the output:

(int)12.5f==12

after float widening: 12.0

12.0*12==144.0

Math.sin(144.0)==-0.49102159389846934

5.1 Kinds of Conversion

Specific type [[conversions in the Java programming language are divided into 12

kinds.

5.1.1

Id[[entity Conversion

A conversion from a type to that same type is permitted for any type.

This may seem trivial, but it has two practical consequences. First, it is always permitted for an expression to have the desired type to begin with, thus allowing the simply stated rule that every expression is subject to conversion, if only a trivial id[[entity conversion. Second, it implies that it is permitted for a program to include redundant cast operators for the sake of clarity.

110

Widening Primitive Conversion

Kinds of Conversion

5.1

5.1.2

19 specific conversions on primitive types are called the widening primitive conversions:

byte to short, int, long, float, or double

short to int, long, float, or double

char to int, long, float, or double

int to long, float, or double

long to float or double

float to double

A widening primitive conversion does not lose information about the overall magnitude of a numeric value in the following cases, where the numeric value is

preserved exactly:

from an integral type to another integral type

from byte, short, or char to a floating-point type

from int to double

from float to double

A widening primitive conversion from int to float, or from long to float, or

from long to double, may result in loss of precision, that is, the result may lose some of the least significant bits of the value. In this case, the resulting floating-point value will be a correctly rounded version of the integer value, using the round

to nearest rounding]] policy (§15.4).

A widening conversion of a signed integer value to an integral type T simply sign-extends the two's-complement representation of the integer value to fill the wider format.

A widening conversion of a char to an integral type T zero-extends the representation of the char value to fill the wider format.

A widening conversion from int to float, or from long to float, or from int to

double, or from long to double occurs as determined by the rules of IEEE 754 for converting from an integer format to a binary floating-point format.

A widening conversion from float to double occurs as determined by the rules of

IEEE 754 for converting between binary floating-point formats.

111

5.1

Kinds of Conversion

Despite the fact that loss of precision may occur, a widening primitive conversion

never results in a run-time exception (§11.1.1).

Example 5.1.2-1. Widening Primitive Conversion

int big = 1234567890;

float approx = big;

System.out]].println(big - (int)approx);

}

This program prints:

-46

thus indicating that information was lost during the conversion from type int to type float because values of type float are not precise to nine significant digits.

5.1.3

Narrowing]] Primitive Conversion

22 specific conversions on primitive types are called the narrowing]] primitive conversions:

short to byte or char

char to byte or short

int to byte, short, or char

long to byte, short, char, or int

float to byte, short, char, int, or long

double to byte, short, char, int, long, or float

A narrowing]] primitive conversion may lose information about the overall magnitude of a numeric value, and may also lose precision and range.

A narrowing]] conversion of a signed integer to an integral type T simply discards all but the n lowest order bits, where n is the number of bits used to represent type T. In addition to a possible loss of information about the magnitude of the numeric value, this may cause the sign of the resulting value to differ from the sign of the input value.

A narrowing]] conversion of a char to an integral type T likewise simply discards all but the n lowest order bits, where n is the number of bits used to represent type T. In addition to a possible loss of information about the magnitude of the numeric 112

Kinds of Conversion

5.1

value, this may cause the resulting value to be a negative number]], even though chars represent 16-bit unsigned integer values.

A narrowing]] conversion of a floating-point number to an integral type T takes two steps:

1. In the first step, the floating-point number is convert ed either to a long, if T is long, or to an int, if T is byte, short, char, or int, as follows:

If the floating-point number is NaN (§4.2.3), the result of the first step of the conversion is an int or long 0.

Otherwise, if the floating-point number is not an infinity, the floating-point value is rounded to an integer value V using the round toward zero rounding]] policy (§4.2.4). Then there are two cases:

a.

If T is long, and this integer value can be represent ed as a long, then the result of the first step is the long value V.

b. Otherwise, if this integer value can be represent ed as an int, then the

result of the first step is the int value V.

Otherwise, one of the following two cases must be true:

a.

The value must be too small (a negative value of large magnitude

or negative infinity), and the result of the first step is the smallest representable value of type int or long.

b. The value must be too large (a positive value of large magnitude

or positive infinity), and the result of the first step is the largest representable value of type int or long.

2. In the second step:

If T is int or long, the result of the conversion is the result of the first step.

If T is byte, char, or short, the result of the conversion is the result of a narrowing]] conversion to type T (§5.1.3) of the result of the first step.

A narrowing]] conversion from double to float occurs as determined by the rules

of IEEE 754 for converting between binary floating-point formats, using the round to nearest rounding]] policy (§15.4). This conversion can lose precision, but also lose range, resulting in a float zero from a nonzero double and a float infinity from a finite double. A double NaN is convert ed to a float NaN and a double infinity

is convert ed to the same-signed float infinity.

Despite the fact that overflow, underflow, or other loss of information may occur, a narrowing]] primitive conversion never results in a run-time exception (§11.1.1).

113

5.1

Kinds of Conversion

Example 5.1.3-1. Narrowing]] Primitive Conversion

float fmin = Float.NEGATIVE_INFINITY;

float fmax = Float.POSITIVE_INFINITY;

System.out]].println(”long: “ + (long)fmin +

”..“ + (long)fmax);

System.out]].println(”int: “ + (int)fmin +

”..“ + (int)fmax);

System.out]].println(”short: “ + (short)fmin +

”..“ + (short)fmax);

System.out]].println(”char: “ + (int)(char)fmin +

”..“ + (int)(char)fmax);

System.out]].println(”byte: “ + (byte)fmin +

”..“ + (byte)fmax);

}

This program produces the output:

long: -9223372036854775808..9223372036854775807

int: -2147483648..2147483647

short: 0..-1

char: 0..65535

byte: 0..-1

The results for char, int, and long are unsurprising, producing the minimum and maximum representable values of the type.

The results for byte and short lose information about the sign and magnitude of the numeric values and also lose precision. The results can be understood by examining the low order bits of the minimum and maximum int. The minimum int is, in hexadecimal, 0x80000000, and the maximum int is 0x7fffffff. This explains the short results, which are the low 16 bits of these values, namely, 0x0000 and 0xffff; it explains the char results, which also are the low 16 bits of these values, namely, '\u0000' and '\uffff'; and it explains the byte results, which are the low 8 bits of these values, namely, 0x00 and 0xff.

Example 5.1.3-2. Narrowing]] Primitive Conversions that lose information

// A narrowing]] of int to short loses high bits:

System.out]].println(”(short)0x12345678==0x“ +

Integer.toHex String¹⁾;

// An int value too big for byte changes sign and magnitude:

System.out]].println(”(byte)255==“ + (byte)255);

// A float value too big to fit gives largest int value:

System.out]].println(”(int)1e20f==“ + (int)1e20f);

// A NaN convert ed to int yields zero:

System.out]].println(”(int)NaN==“ + (int)Float.NaN);

// A double value too large for float yields infinity:

114

Widening Reference Conversion

Kinds of Conversion

5.1

System.out]].println(”(float)-1e100==“ + (float)-1e100);

// A double value too small for float underflows to zero:

System.out]].println(”(float)1e-50==“ + (float)1e-50);

}

This program produces the output:

(short)0x12345678==0x5678

(byte)255==-1

(int)1e20f==2147483647

(int)NaN==0

(float)-1e100==-Infinity

(float)1e-50==0.0

5.1.4

Widening and Narrowing]] Primitive Conversion

The following conversion combines both widening and narrowing]] primitive

conversions:

byte to char

First, the byte is convert ed to an int via widening primitive conversion (§5.1.2), and then the resulting int is convert ed to a char by narrowing]] primitive conversion

(§5.1.3).

5.1.5

A widening reference conversion exists from any reference type S to any reference type T, provided S is a subtype of T (§4.10).

Widening reference conversions never require a special action at run time and therefore never throw an exception at run time. They consist simply in regarding a reference as having some other type in a manner that can be proved correct at

compile time.

The null type is not a reference type (§4.1), and so a widening reference conversion does not exist from the null type to a reference type. However, many conversion contexts explicitly allow the null type to be convert ed to a reference type.

5.1.6

Narrowing]] Reference Conversion

A narrowing]] reference conversion treats expressions of a reference type S as expressions of a different reference type T, where S is not a subtype of T.

The supported pairs of types are defined in §5.1.6.1. Unlike widening reference conversion, the types need not be directly related. However, there are re[[striction]]s 115

5.1

Kinds of Conversion

that prohibit conversion between certain pairs of types when it can be statically proven that no value can be of both types.

A narrowing]] reference conversion may require a test at run time to validate that a value of type S is a legitimate value of type T. However, due to the lack of parameterized type information at run time, some conversions cannot be

fully validated by a run time test; they are flagged at compile time (§5.1.6.2).

For conversions that can be fully validated by a run time test, and for certain conversions that involve parameterized type information but can still be partially validated at run time, a Class Cast Exception is thrown if the test fails (§5.1.6.3).

5.1.6.1

Allowed Narrowing]] Reference Conversion

A narrowing]] reference conversion exists from reference type S to reference type T

if all of the following are true:

S is not a subtype of T (§4.10)

If there exists a parameterized type X that is a supertype]] of T, and a parameterized type Y that is a supertype]] of S, such that the erasures of X and Y are the same, then X and Y are not provably distinct (§4.5).

Using types from the java.[[util package as an example, no narrowing]] reference conversion exists from Array List<String> to Array List<Object>, or vice versa, because the type arguments String and Object are provably distinct. For the same reason, no narrowing]] reference conversion exists from Array List<String> to List<Object>, or vice versa. The rejection of provably distinct types is a simple static gate to prevent ”stupid“ narrowing]] reference conversions.

116

Kinds of Conversion

5.1

One of the following cases applies:

1. S is a class or interface type, and T is a class or interface type, and S names a class or interface that is not dis joint from the class or interface named by

T. (”dis joint“ is defined below.)

2. S is the class type Object or the interface type java.io.Serializable or Cloneable (the only interfaces implemented by arrays (§10.8)), and T is an array type.

3. S is an array type SC[], that is, an array of components of type SC; T is an array type TC[], that is, an array of components of type TC; and a narrowing]] reference conversion exists from SC to TC.

4. S is a type variable, and a narrowing]] reference conversion exists from the upper bound of S to T.

5. T is a type variable, and either a widening reference conversion or a narrowing]] reference conversion exists from S to the upper bound of T.

6. S is an intersection type S1 & … & Sn, and for all i (1 ≤ i ≤ n), either a widening reference conversion or a narrowing]] reference conversion exists from Si to T.

7. T is an intersection type T1 & … & Tn, and for all i (1 ≤ i ≤ n), either a widening reference conversion or a narrowing]] reference conversion exists from S to Ti.

A class or interface is dis joint from another class or interface if it can be determined statically that they have no instances in common (other than the null value). The rules for dis jointess are as follows:

A class named C is dis joint from an interface named I if (i) it is not the case that C <: I, and (ii) one of the following cases applies:

– C is final.

– C is sealed, and all of the permitted direct subclasses of C are dis joint from I.

– C is freely extensible (§8.1.1.2), and I is sealed, and C is dis joint from all of the permitted direct subclasses and sub interfaces of I.

An interface named I is dis joint from a class named C if C is dis joint from I.

A class named C is dis joint from another class named D if (i) it is not the case that C <: D, and (ii) it is not the case that D <: C.

117

5.1

Kinds of Conversion

An interface named I is dis joint from another interface named J if (i) it is not that case that I <: J, and (ii) it is not the case that J <: I, and (iii) one of the following cases applies:

– I is sealed, and all of the permitted direct subclasses and sub interfaces of I are dis joint from J.

– J is sealed, and I is dis joint from all the permitted direct subclasses and sub interfaces of J.

Whether a class is final has the most bearing on whether the class is dis joint from interfaces. Consider the following declarations:

interface I {}

final class C {}

As class C is final and does not implement I, there can be no instances of C that are also an instance of I, so C and I are dis joint. Therefore, there is no narrowing]] reference conversion from C to I.

In contrast, consider the following declarations:

interface J {}

class D {}

Even though class D does not implement J, it is still possible for an instance of D to be an instance of J, for example, if the following declaration occurs:

class E extends D implements J {}

For this reason, D is not dis joint from J, and there is a narrowing]] reference conversion from D to J.

The final clause above implies that two freely extensible interfaces (§9.1.1.4) are not dis joint.

5.1.6.2

Checked and Unchecked Narrowing]] Reference Conversions

A narrowing]] reference conversion is either checked or unchecked. These terms refer to the ability of the Java Virtual Machine to validate, or not, the type correctness of the conversion.

If a narrowing]] reference conversion is unchecked, then the Java Virtual Machine will not be able to fully validate its type correctness, possibly leading to heap pollution (§4.12.2). To flag this to the programmer, an unchecked narrowing]] reference conversion causes a compile-time unchecked warning, unless suppress ed by @Suppress Warnings (§9.6.4.5). Conversely, if a narrowing]] 118

Kinds of Conversion

5.1

reference conversion is not unchecked, then it is checked; the Java Virtual Machine will be able to fully validate its type correctness, so no warning is given at compile time.

The unchecked narrowing]] reference conversions are as follows:

A narrowing]] reference conversion from a type S to a parameterized class or interface type T is unchecked, unless at least one of the following is true:

– All of the type arguments of T are unbound ed wildcards.

– T <: S, and S has no subtype X other than T where the type arguments of X are not contained in the type arguments of T.

A narrowing]] reference conversion from a type S to a type variable T is unchecked.

A narrowing]] reference conversion from a type S to an intersection type T1 & … & Tn is unchecked if there exists a Ti (1 ≤ i ≤ n) such that S is not a subtype of Ti and a narrowing]] reference conversion from S to Ti is unchecked.

5.1.6.3

Narrowing]] Reference Conversions at Run Time

All checked narrowing]] reference conversions require a validity check at run time. Primarily, these conversions are to class and interface types that are not parameterized.

Some unchecked narrowing]] reference conversions require a validity check at run time. This depends on whether the unchecked narrowing]] reference conversion is

completely unchecked or partially unchecked. A partially unchecked narrowing]] reference conversion requires a validity check at run time, while a completely unchecked narrowing]] reference conversion does not.

These terms refer to the compatibility of the types involved in the conversion when viewed as raw types. If the conversion is conceptually an “upcast”, then the conversion is completely unchecked; no run time test is needed because the conversion is legal in the non-generic type system of the Java Virtual Machine. Conversely, if the conversion is conceptually a ”down cast“, then the conversion is partially unchecked; even in the non-generic type system of the Java Virtual Machine, a run time check is needed to test the compatibility of the (raw) types involved in the conversion.

Using types from the java.[[util package as an example, a conversion from Array List<String> to Collection<T> is completely unchecked, because the (raw) type Array List is a subtype of the (raw) type Collection in the Java Virtual Machine.

Conversely, a conversion from Collection<T> to Array List<String> is partially unchecked, because the (raw) type Collection is not a subtype of the (raw) type Array List in the Java Virtual Machine.

The categorization of an unchecked narrowing]] reference conversion is as follows: 119

5.1

Kinds of Conversion

An unchecked narrowing]] reference conversion from S to a non-intersection type T is completely unchecked if | S| <: | T|.

Otherwise, it is partially unchecked.

An unchecked narrowing]] reference conversion from S to an intersection type T1

& … & Tn is completely unchecked if, for all i (1 ≤ i ≤ n), either S <: Ti or a narrowing]] reference conversion from S to Ti is completely unchecked.

Otherwise, it is partially unchecked.

The run time validity check for a checked or partially unchecked narrowing]] reference conversion is as follows:

If the value at run time is null, then the conversion is allowed.

120

Kinds of Conversion

5.1

Otherwise, let R be the class of the object referred to by the value, and let T be the erasure (§4.6) of the type being convert ed to. Then:

– If R is an ordinary class (not an array class):

› If T is a class type, then R must be either the same class as T (§4.3.4) or a subclass of T, or a Class Cast Exception is thrown.

› If T is an interface type, then R must implement interface T (§8.1.5), or a Class Cast Exception is thrown.

› If T is an array type, then a Class Cast Exception is thrown.

– If R is an interface:

Note that R cannot be an interface when these rules are first applied for any given conversion, but R may be an interface if the rules are applied recursively because the run-time reference value may refer to an array whose element type is an interface type.

› If T is a class type, then T must be Object (§4.3.2), or a Class Cast Exception is thrown.

› If T is an interface type, then R must be either the same interface as T or a sub interface of T, or a Class Cast Exception is thrown.

› If T is an array type, then a Class Cast Exception is thrown.

– If R is a class representing an array type RC[], that is, an array of components of type RC:

› If T is a class type, then T must be Object (§4.3.2), or a Class Cast Exception is thrown.

› If T is an interface type, then T must be the type java.io.Serializable or Cloneable (the only interfaces implemented by arrays), or a

Class Cast Exception is thrown.

› If T is an array type TC[], that is, an array of components of type TC, then a Class Cast Exception is thrown unless either TC and RC are the same primitive type, or TC and RC are reference types and are allowed by a recursive application of these run-time rules.

If the conversion is to an intersection type T1 & … & Tn, then for all i (1 ≤ i ≤ n), any run-time check required for a conversion from S to Ti is also required for the conversion to the intersection type.

121

5.1

Kinds of Conversion

5.1.7

Boxing Conversion

Boxing conversion treats expressions of a primitive type as expressions of a corresponding reference type. Specifically, the following nine conversions are called the boxing conversions:

From type boolean to type Boolean

From type byte to type Byte

From type short to type Short

From type char to type Character

From type int to type Integer

From type long to type Long

From type float to type Float

From type double to type Double

From the null type to the null type

This rule is necessary because the conditional operator (§15.25) applies boxing conversion to the types of its operands, and uses the result in further calculations.

At run time, boxing conversion proceeds as follows:

If p is a value of type boolean, then boxing conversion converts p into a reference r of class and type Boolean, such that r.booleanValue() == p

If p is a value of type byte, then boxing conversion converts p into a reference r of class and type Byte, such that r.byte Value() == p

If p is a value of type char, then boxing conversion converts p into a reference r of class and type Character, such that r.char Value() == p

If p is a value of type short, then boxing conversion converts p into a reference r of class and type Short, such that r.short Value() == p

If p is a value of type int, then boxing conversion converts p into a reference r of class and type Integer, such that r.int Value() == p

If p is a value of type long, then boxing conversion converts p into a reference r of class and type Long, such that r.long Value() == p

122

Kinds of Conversion

5.1

If p is a value of type float then:

– If p is not NaN, then boxing conversion converts p into a reference r of class and type Float, such that r.float Value() evaluates to p

– Otherwise, boxing conversion converts p into a reference r of class and type Float such that r.isNaN() evaluates to true

If p is a value of type double, then:

– If p is not NaN, boxing conversion converts p into a reference r of class and type Double, such that r.double Value() evaluates to p

– Otherwise, boxing conversion converts p into a reference r of class and type Double such that r.isNaN() evaluates to true

If p is a value of any other type, boxing conversion is equivalent to an id[[entity

conversion (§5.1.1).

If the value p being boxed is the result of evaluating a constant expression (§15.29)

of type boolean, byte, char, short, int, or long, and the result is true, false, a character in the range '\u0000' to '\u007f' inclusive, or an integer in the range

-128 to 127 inclusive, then let a and b be the results of any two boxing conversions of p. It is always the case that a == b.

Ideally, boxing a primitive value would always yield an identical reference. In practice, this may not be feasible using existing implementation techniques. The rule above is a pragmatic compromise, requiring that certain common values always be boxed into indistinguishable objects. The implementation may cache these, lazily or eagerly. For other values, the rule disallows any assumptions about the id[[entity of the boxed values on the programmer's part.

This allows (but does not require) sharing of some or all of these references.

This ensures that in most common cases, the behavior will be the desired one, without imposing an undue performance penalty, especially on small devices. Less memory-limited implementations might, for example, cache all char and short values, as well as int and long values in the range of -32K to +32K.

A boxing conversion may result in an OutOfMemory Error if a new instance of one

of the wrapper classes (Boolean, Byte, Character, Short, Integer, Long, Float,

or Double) needs to be allocated and insufficient storage is available.

5.1.8

Unboxing Conversion

Unboxing conversion treats expressions of a reference type as expressions of a corresponding primitive type. Specifically, the following eight conversions are called the unboxing conversions:

123

5.1

Kinds of Conversion

From type Boolean to type boolean

From type Byte to type byte

From type Short to type short

From type Character to type char

From type Integer to type int

From type Long to type long

From type Float to type float

From type Double to type double

At run time, unboxing conversion proceeds as follows:

If r is a reference of type Boolean, then unboxing conversion converts r into r.booleanValue()

If r is a reference of type Byte, then unboxing conversion converts r into r.byte Value()

If r is a reference of type Character, then unboxing conversion converts r into r.char Value()

If r is a reference of type Short, then unboxing conversion converts r into r.short Value()

If r is a reference of type Integer, then unboxing conversion converts r into r.int Value()

If r is a reference of type Long, then unboxing conversion converts r into r.long Value()

If r is a reference of type Float, unboxing conversion converts r into r.float Value()

If r is a reference of type Double, then unboxing conversion converts r into r.double Value()

If r is null, unboxing conversion throws a NullPointer Exception

A type is said to be convertible to a numeric type if it is a numeric type (§4.2), or it is a reference type that may be convert ed to a numeric type by unboxing conversion.

A type is said to be convertible to an integral type if it is an integral type, or it is a reference type that may be convert ed to an integral type by unboxing conversion.

124

Kinds of Conversion

5.1

5.1.9

Unchecked Conversion

Let G name a generic type declaration with n type parameters.

There is an unchecked conversion from the raw class or interface type (§4.8) G to any parameterized type of the form G< T1,…, Tn>.

There is an unchecked conversion from the raw array type

k

G[] to any array type of

the form

k

G< T1,…, Tn>[] . (The notation [] indicates an array type of k dimensions.) Use of an unchecked conversion causes a compile-time unchecked warning unless all type arguments Ti (1 ≤ i ≤ n) are unbound ed wildcards (§4.5.1), or the warning is suppress ed by @Suppress Warnings (§9.6.4.5).

Unchecked conversion is used to enable a smooth interoperation of legacy code, written before the introduction of generic types, with libraries that have undergone a conversion to use genericity (a process we call generification). In such circumstances (most notably, clients of the Collections Framework in java.[[util), legacy code uses raw types (e.g.

Collection instead of Collection<String>). Expressions of raw types are passed as arguments to library methods that use parameterized versions of those same types as the types of their corresponding formal parameters.

Such calls cannot be shown to be statically safe under the type system using generics.

Rejecting such calls would invalidate large bodies of existing code, and prevent them from using newer versions of the libraries. This in turn, would discourage library vendors from taking advantage of genericity. To prevent such an unwelcome turn of events, a raw type may be convert ed to an arbitrary invocation of the generic type declaration to which the raw type refers. While the conversion is unsound, it is tolerated as a concession to practicality.

An unchecked warning is issued in such cases.

5.1.10

Capture Conversion

Let G name a generic type declaration (§8.1.2, §9.1.2) with n type parameters A1,…, An with corresponding bounds U1,…, Un.

There exists a capture conversion from a parameterized type G< T1,…, Tn> (§4.5) to a parameterized type G< S1,…, Sn>, where, for 1 ≤ i ≤ n :

If Ti is a wildcard type argument (§4.5.1) of the form ?, then Si is a fresh type variable whose upper bound is Ui[ A1:= S1,…, An:= Sn] and whose lower bound

is the null type (§4.1).

125

5.1

Kinds of Conversion

If Ti is a wildcard type argument of the form ? extends Bi, then Si is a fresh type variable whose upper bound is glb( Bi, Ui[ A1:= S1,…, An:= Sn]) and whose lower bound is the null type.

glb( V1,…, Vm) is defined as V1 & … & Vm.

It is a compile-time error if, for any two classes (not interfaces) Vi and Vj, Vi is not a subclass of Vj or vice versa.

If Ti is a wildcard type argument of the form ? super Bi, then Si is a fresh type variable whose upper bound is Ui[ A1:= S1,…, An:= Sn] and whose lower bound is Bi.

Otherwise, Si = Ti.

Capture conversion on any type other than a parameterized type (§4.5) acts as an id[[entity conversion (§5.1.1).

Capture conversion is not applied recursively.

Capture conversion never requires a special action at run time and therefore never throws an exception at run time.

Capture conversion is designed to make wildcards more useful. To understand the motivation, let's begin by looking at the method java.[[util.Collections.reverse(): public static void reverse(List<?> list);

The method reverses the list provided as a parameter. It works for any type of list, and so the use of the wildcard type List<?> as the type of the formal parameter is entirely appropriate.

Now consider how one would implement reverse():

public static void reverse(List<?> list) { rev(list); }

private static <T> void rev(List<T> list) {

List<T> tmp = new Array List<T>(list);

for (int i = 0; i < list.size(); i++) {

list.set(i, tmp.get(list.size() - i - 1));

}

The implementation needs to copy the list, extract elements from the copy, and insert them into the original. To do this in a type-safe manner, we need to give a name, T, to the element type of the incoming list. We do this in the private service method rev(). This requires us to pass the incoming argument [[list, of type List<?>, as an argument to rev(). In general, List<?> is a list of unknown type. It is not a subtype of List<T>, for any type T. Allowing such a subtype relation would be unsound. Given the method:

public static <T> void fill(List<T> l, T obj)

126

Kinds of Conversion

5.1

the following code would undermine the type system:

List<String> ls = new Array List<String>();

List<?> l = ls;

Collections.fill(l, new Object()); // not legal - but assume it was!

String s = ls.get(0); // Class Cast Exception - ls contains

// Objects, not Strings.

So, without some special dispensation, we can see that the call from reverse() to rev() would be disallow ed. If this were the case, the author of reverse() would be forced]] to write its signature as:

public static <T> void reverse(List<T> list)

This is undesirable, as it exposes implementation information to the caller. Worse, the designer of an API might reason that the signature using a wildcard is what the callers of the API require, and only later realize that a type safe implementation was precluded.

The call from reverse() to rev() is in fact harmless, but it cannot be justified on the basis of a general subtyping relation between List<?> and List<T>. The call is harmless, because the incoming argument is doubtless a list of some type (albeit an unknown one). If we can capture this unknown type in a type variable X, we can infer T to be X. That is the essence of capture conversion. The specification of course must cope with complications, like non-trivial (and possibly recursively defined) upper or lower bounds, the presence of multiple arguments etc.

Mathematically sophisticated readers will want to relate capture conversion to established type theory. Readers unfamiliar with type theory can skip this discussion - or else study a suitable text, such as Types and Programming Languages by Benjamin Pierce, and then re visit this section.

Here then is a brief summary of the relationship of capture conversion to established type theoretical notions. Wildcard types are a re[[stricted]] form of existential types. Capture conversion corresponds loosely to an opening of a value of existential type. A capture conversion of an expression e can be thought of as an open of e in a scoped that comprises the top level expression that encloses e.

The classical open operation on existentials requires that the captured type variable must not escape the opened expression. The open that corresponds to capture conversion is always on a scoped sufficiently large that the captured type variable can never be visible outside that scoped. The advantage of this scheme is that there is no need for a close operation, as defined in the paper On Varian ce-Based Subtyping for Parametric Types by Atsushi Igarashi and Mirko Viroli, in the proceedings of the 16th European]] Conference on Object-Oriented Programming]] (ECOOP 2002). For a formal account of wildcards, see Wild FJ by Mads Torgersen, Erik Ernst and Christian Plesner Hansen, in the 12th workshop on Foundations of Object-Oriented Programming]] (FOOL 2005).

5.1.11

String Conversion

Any type may be convert ed to type String by string conversion.

127

5.2

A value x of primitive type T is first convert ed to a reference value as if by giving

it as an argument to an appropriate class instance creation expression (§15.9):

If T is boolean, then use new Boolean( x).

If T is char, then use new Character( x).

If T is byte, short, or int, then use new Integer( x).

If T is long, then use new Long( x).

If T is float, then use new Float( x).

If T is double, then use new Double( x).

This reference value is then convert ed to type String by string conversion.

Now only reference values need to be considered:

If the reference is null, it is convert ed to the string ”null“ (four ASCII characters n, u, l, l).

Otherwise, the conversion is performed as if by an invocation of the to[[String

method of the referenced object with no arguments; but if the result of invoking the to[[String method is null, then the string ”null“ is used instead.

The to[[String method is defined by the primordial class Object (§4.3.2). Many classes override it, notably Boolean, Character, Integer, Long, Float, Double, and String.

5.1.12

Forbidden Conversions

Any conversion that is not explicitly allowed is forbidden.

5.2 Assignment Contexts

Assignment contexts allow the value of an expression to be assigned (§15.26) to a variable; the type of the expression must be convert ed to the type of the variable.

Assignment contexts allow the use of one of the following:

an id[[entity conversion (§5.1.1)

a widening primitive conversion (§5.1.2)

a widening reference conversion (§5.1.5)

a widening reference conversion followed by an unboxing conversion

128

5.2

a widening reference conversion followed by an unboxing conversion, then followed by a widening primitive conversion

a boxing conversion (§5.1.7)

a boxing conversion followed by a widening reference conversion

an unboxing conversion (§5.1.8)

an unboxing conversion followed by a widening primitive conversion

If, after the conversions listed above have been applied, the resulting type is a raw

type (§4.8), an unchecked conversion (§5.1.9) may then be applied.

In addition, if the expression is a constant expression (§15.29) of type byte, short, char, or int:

A narrowing]] primitive conversion may be used if the variable is of type byte,

short, or char, and the value of the constant expression is representable in the type of the variable.

A narrowing]] primitive conversion followed by a boxing conversion may be used

if the variable is of type Byte, Short, or Character, and the value of the constant expression is representable in the type byte, short, or char respectively.

The compile-time narrowing]] of constant expressions means that code such as:

byte theAnswer = 42;

is allowed. Without the narrowing]], the fact that the integer literal 42 has type int would mean that a cast to byte would be required:

byte theAnswer = (byte)42; // cast is permitted but not required

Finally, a value of the null type (the null reference is the only such value) may be assigned to any reference type, resulting in a null reference of that type.

It is a compile-time error if the chain of conversions contains two parameterized

types that are not in the subtype relation (§4.10).

An example of such an illegal chain would be:

Integer, Comparable<Integer>, Comparable, Comparable<String>

The first three elements of the chain are related by widening reference conversion, while the last entry is derived from its predecessor by unchecked conversion. However, this is not a valid assignment conversion, because the chain contains two parameterized types, Comparable<Integer> and Comparable<String>, that are not subtypes.

129

5.2

If the type of an expression can be convert ed to the type of a variable by assignment conversion, we say the expression (or its value) is assignable to the variable or, equivalently, that the type of the expression is assignment compatible with the type of the variable.

The only exceptions that may arise from conversions in an assignment context are:

A Class Cast Exception if, after the conversions above have been applied, the

resulting value is an object which is not an instance of a subclass or sub interface

of the erasure (§4.6) of the type of the variable.

This circumstance can only arise as a result of heap pollution (§4.12.2). In practice, implementations need only perform casts when accessing a field or method of an object of parameterized type when the erased type of the field, or the erased return type of the method, differ from its unerased type.

An OutOfMemory Error as a result of a boxing conversion.

A NullPointer Exception as a result of an unboxing conversion on a null reference.

An Array Store Exception in special cases involving array elements or field access (§10.5, §15.26.1).

Example 5.2-1. Assignment for Primitive Types

short s = 12; // narrow 12 to short

float f = s; // widen short to float

System.out]].println(“f=” + f);

char c = '\u0123';

long l = c; // widen char to long

System.out]].println(“l=0x” + Long.to[[String(l,16));

f = 1.23f;

double d = f; // widen float to double

System.out]].println(“d=” + d);

}

This program produces the output:

f=12.0

l=0x123

d=1.2300000190734863

The following program, however, produces compile-time errors:

130

5.2

short s = 123;

char c = s; // error: would require cast

s = c; // error: would require cast

}

because not all short values are char values, and neither are all char values short values.

Example 5.2-2. Assignment for Reference Types

class Point { int x, y; }

class Point 3D extends Point { int z; }

interface Colorable { void set Color(int color); }

class Color ed Point extends Point implements Colorable {

int color;

public void set Color(int color) { this.color = color; }

}

// Assignments to variables of class type:

Point p = new Point();

p = new Point 3D();

// OK because Point 3D is a subclass of Point

Point 3D p3d = p;

// Error: will require a cast because a Point

// might not be a Point 3D (even though it is,

// dynamically, in this example.)

// Assignments to variables of type Object:

Object o = p; // OK: any object to Object

int[] a = new int[3];

Object o2 = a; // OK: an array to Object

// Assignments to variables of interface type:

Color ed Point cp = new Color ed Point();

Colorable c = cp;

// OK: Color ed Point implements Colorable

// Assignments to variables of array type:

byte[] b = new byte[4];

a = b;

// Error: these are not arrays of the same primitive type

Point 3D[] p3da = new Point 3D[3];

Point[] pa = p3da;

// OK: since we can assign a Point 3D to a Point

p3da = pa;

// Error: (cast needed) since a Point

// can't be assigned to a Point 3D

}

131

5.2

The following test program illustrates assignment conversions on reference values, but fails to compile, as described in its comments. This example should be compared to the preceding one.

class Point { int x, y; }

interface Colorable { void set Color(int color); }

class Color ed Point extends Point implements Colorable {

int color;

public void set Color(int color) { this.color = color; }

}

Point p = new Point();

Color ed Point cp = new Color ed Point();

// Okay because Color ed Point is a subclass of Point:

p = cp;

// Okay because Color ed Point implements Colorable:

Colorable c = cp;

// The following cause compile-time errors because

// we cannot be sure they will succeed, depending on

// the run-time type of p; a run-time check will be

// necessary for the needed narrowing]] conversion and

// must be indicated by including a cast:

cp = p; // p might be neither a Color ed Point

// nor a subclass of Color ed Point

c = p; // p might not implement Colorable

}

Example 5.2-3. Assignment for Array Types

class Point { int x, y; }

class Color ed Point extends Point { int color; }

long[] veclong = new long[100];

Object o = veclong; // okay

Long l = veclong; // compile-time error

short[] vecshort = veclong; // compile-time error

Point[] pvec = new Point[100];

Color ed Point[] cpvec = new Color ed Point[100];

pvec = cpvec; // okay

pvec[0] = new Point(); // okay at compile time,

// but would throw an

// exception at run time

cpvec = pvec; // compile-time error

}

In this example:

132

Invocation Contexts

5.3

The value of veclong cannot be assigned to a Long variable, because Long is a class type other than Object. An array can be assigned only to a variable of a compatible array type, or to a variable of type Object, Cloneable or java.io.Serializable.

The value of veclong cannot be assigned to vecshort, because they are arrays of primitive type, and short and long are not the same primitive type.

The value of cpvec can be assigned to pvec, because any reference that could be the value of an expression of type Color ed Point can be the value of a variable of type Point. The subsequent assignment of the new Point to a component of pvec then would throw an Array Store Exception (if the program were otherwise correct ed so

that it could be compiled), because a Color ed Point array cannot have an instance of Point as the value of a component.

The value of pvec cannot be assigned to cpvec, because not every reference that could be the value of an expression of type Point can correctly be the value of a variable of type Color ed Point. If the value of pvec at run time were a reference to an instance of Point[], and the assignment to cpvec were allowed, a simple reference to a component of cpvec, say, cpvec[0], could return a Point, and a Point is not a Color ed Point.

Thus to allow such an assignment would allow a violation of the type system. A cast

may be used (§5.5, §15.16) to ensure that pvec references a Color ed Point[]: cpvec = (Color ed Point[])pvec; // OK, but may throw an

// exception at run time

5.3 Invocation Contexts

Invocation contexts allow an argument value in a method or constructor invocation

(§8.8.7.1, §15.9, §15.12) to be assigned to a corresponding formal parameter.

Strict invocation contexts allow the use of one of the following:

an id[[entity conversion (§5.1.1)

a widening primitive conversion (§5.1.2)

a widening reference conversion (§5.1.5)

Loose invocation contexts allow a more permissive set of conversions, because they are only used for a particular invocation if no applicable declaration can be found using strict invocation contexts. Loose invocation contexts allow the use of one of the following:

an id[[entity conversion (§5.1.1)

a widening primitive conversion (§5.1.2)

a widening reference conversion (§5.1.5)

a widening reference conversion followed by an unboxing conversion

133

5.3

Invocation Contexts

a widening reference conversion followed by an unboxing conversion, then followed by a widening primitive conversion

a boxing conversion (§5.1.7)

a boxing conversion followed by widening reference conversion

an unboxing conversion (§5.1.8)

an unboxing conversion followed by a widening primitive conversion

If, after the conversions listed for an invocation context have been applied, the resulting type is a raw type (§4.8), an unchecked conversion (§5.1.9) may then be applied.

A value of the null type (the null reference is the only such value) may be assigned to any reference type.

It is a compile-time error if the chain of conversions contains two parameterized

types that are not in the subtype relation (§4.10).

The only exceptions that may arise in an invocation context are:

A Class Cast Exception if, after the type [[conversions above have been applied,

the resulting value is an object which is not an instance of a subclass or

sub interface of the erasure (§4.6) of the corresponding formal parameter type.

An OutOfMemory Error as a result of a boxing conversion.

A NullPointer Exception as a result of an unboxing conversion on a null reference.

Neither strict nor loose invocation contexts include the implicit narrowing]] of integer constant expressions which is allowed in assignment contexts. The designers of the Java programming language felt that including these implicit narrowing]] conversions would add additional complexity to the rules of overload [[resolution (§15.12.2).

Thus, the program:

static int byte a, int b) { return a+b; }

static int short a, short b) { return a-b; }

System.out]].println(m(12, 2)); // compile-time error

}

causes a compile-time error because the integer literals 12 and 2 have type int, so neither method m matches under the rules of overload [[resolution. A language that included implicit narrowing]] of integer constant expressions would need additional rules to resolve cases like this example.

134

String Contexts

5.4

5.4 String Contexts

String contexts apply only to an operand of the binary + operator which is not a String when the other operand is a String.

The target type in these contexts is always String, and a string conversion

(§5.1.11) of the non-String operand always occurs. Evaluation of the + operator then proceeds as specified in §15.18.1.

5.5 Casting Contexts

Casting contexts allow the operand of a cast expression (§15.16) to be convert ed to the type explicitly named by the cast operator. Compared to assignment contexts

and invocation contexts, casting contexts allow the use of more of the conversions defined in §5.1, and allow more combinations of those conversions.

If the expression is of a primitive type, then a casting context allows the use of one of the following:

an id[[entity conversion (§5.1.1)

a widening primitive conversion (§5.1.2)

a narrowing]] primitive conversion (§5.1.3)

a widening and narrowing]] primitive conversion (§5.1.4)

a boxing conversion (§5.1.7)

a boxing conversion followed by a widening reference conversion (§5.1.5) If the expression is of a reference type, then a casting context allows the use of one of the following:

an id[[entity conversion (§5.1.1)

a widening reference conversion (§5.1.5)

a widening reference conversion followed by an unboxing conversion

a widening reference conversion followed by an unboxing conversion, then followed by a widening primitive conversion

a narrowing]] reference conversion (§5.1.6)

a narrowing]] reference conversion followed by an unboxing conversion

135

5.5

an unboxing conversion (§5.1.8)

an unboxing conversion followed by a widening primitive conversion

If the expression has the null type, then the expression may be cast to any reference type.

If a casting context makes use of a narrowing]] reference conversion that is checked or partially unchecked (§5.1.6.2, §5.1.6.3), then a run time check will be performed on the class of the expression's value, possibly causing a Class Cast Exception.

Otherwise, no run time check is performed.

If an expression can be convert ed to a reference type by a casting conversion other than a narrowing]] reference conversion which is unchecked, we say the expression (or its value) is down cast compatible with the reference type.

The following tables enumerate which conversions are used in certain casting contexts. Each conversion is signified by a symbol:

- signifies no conversion allowed

≈ signifies id[[entity conversion (§5.1.1)

ω signifies widening primitive conversion (§5.1.2)

η signifies narrowing]] primitive conversion (§5.1.3)

ωη signifies widening and narrowing]] primitive conversion (§5.1.4)

⇑ signifies widening reference conversion (§5.1.5)

⇓ signifies narrowing]] reference conversion (§5.1.6)

⊕ signifies boxing conversion (§5.1.7)

⊗ signifies unboxing conversion (§5.1.8)

In the tables, a comma between symbols indicates that a casting context uses one conversion followed by another. The type Object means any reference type other

than the eight wrapper classes Boolean, Byte, Short, Character, Integer, Long,

Float, Double.

136

5.5

Table 5.5-A. Casting to primitive types

To →

From ↓

≈

ω

ωη

ω

-

short

η

≈

η

ω

-

char

η

≈

ω

-

int

η

≈

ω

-

long

η

≈

ω

-

float

η

≈

ω

-

double

η

≈

-

boolean

-

≈

Byte

⊗

⊗,ω

-

⊗,ω

-

Short

-

⊗

-

⊗,ω

-

Character

-

⊗

⊗,ω

-

Integer

-

⊗

⊗,ω

-

Long

-

⊗

⊗,ω

-

Float

-

⊗

⊗,ω

-

Double

-

⊗

-

Boolean

-

⊗

Object

⇓,⊗

137

5.5

Table 5.5-B. Casting to reference types

To →

Byte Short Character Integer Long Float Double Boolean Object

From ↓

byte

⊕

-

⊕,⇑

short

-

⊕

-

⊕,⇑

char

-

⊕

-

⊕,⇑

int

-

⊕

-

⊕,⇑

long

-

⊕

-

⊕,⇑

float

-

⊕

-

⊕,⇑

double

-

⊕

-

⊕,⇑

boolean

-

⊕

⊕,⇑

Byte

≈

-

⇑

Short

-

≈

-

⇑

Character -

-

≈

-

⇑

Integer

-

≈

-

⇑

Long

-

≈

-

⇑

Float

-

≈

-

⇑

Double

-

≈

-

⇑

Boolean

-

≈

⇑

Object

⇓

≈

138

5.5

Example 5.5-1. Casting for Reference Types

class Point { int x, y; }

interface Colorable { void set Color(int color); }

class Color ed Point extends Point implements Colorable {

int color;

public void set Color(int color) { this.color = color; }

}

final class EndPoint extends Point {}