Movatterモバイル変換

Chapter 5. Conversions and Contexts

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

• A conversion from typeThread to typeObject requires no run-time action;Thread is a subclass ofObject, so any reference produced by an expression of typeThread is a valid reference value of typeObject.

• A conversion from typeint to typelong requires run-time sign-extension of a 32-bit integer value to the 64-bitlong representation. No information is lost.

• A conversion from typedouble to typelong 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.

• byte toshort,int,long,float, ordouble

• short toint,long,float, ordouble

• char toint,long,float, ordouble

• int tolong,float, ordouble

• long tofloat ordouble

• float todouble

• from an integral type to another integral type

• frombyte,short, orchar to a floating point type

• fromint todouble

• fromfloat todouble in astrictfp expression (§15.4)

Example 5.1.2-1. Widening Primitive Conversion

class Test {    public static void main(String[] args) {        int big = 1234567890;        float approx = big;        System.out.println(big - (int)approx);    }}

-46

• short tobyte orchar

• char tobyte orshort

• int tobyte,short, orchar

• long tobyte,short,char, orint

• float tobyte,short,char,int, orlong

• double tobyte,short,char,int,long, orfloat

1. In the first step, the floating-point number is converted either to along, ifT islong, or to anint, ifT isbyte,short,char, orint, as follows:

   • If the floating-point number is NaN (§4.2.3), the result of the first step of the conversion is anint orlong0.

   • Otherwise, if the floating-point number is not an infinity, the floating-point value is rounded to an integer valueV, rounding toward zero using IEEE 754 round-toward-zero mode (§4.2.3). Then there are two cases:

     1. IfT islong, and this integer value can be represented as along, then the result of the first step is thelong valueV.

     2. Otherwise, if this integer value can be represented as anint, then the result of the first step is theint valueV.

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

     1. 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 typeint orlong.

     2. 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 typeint orlong.

2. In the second step:

   • IfT isint orlong, the result of the conversion is the result of the first step.

   • IfT isbyte,char, orshort, the result of the conversion is the result of a narrowing conversion to typeT (§5.1.3) of the result of the first step.

Example 5.1.3-1. Narrowing Primitive Conversion

class Test {    public static void main(String[] args) {        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);    }}

long: -9223372036854775808..9223372036854775807int: -2147483648..2147483647short: 0..-1char: 0..65535byte: 0..-1

Example 5.1.3-2. Narrowing Primitive Conversions that lose information

class Test {    public static void main(String[] args) {        // A narrowing of int to short loses high bits:        System.out.println("(short)0x12345678==0x" +                           Integer.toHexString((short)0x12345678));        // 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 converted to int yields zero:        System.out.println("(int)NaN==" + (int)Float.NaN);        // A double value too large for float yields infinity:        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);    }}

(short)0x12345678==0x5678(byte)255==-1(int)1e20f==2147483647(int)NaN==0(float)-1e100==-Infinity(float)1e-50==0.0

• byte tochar

• From any reference typeS to any reference typeT, provided thatS is a proper supertype ofT (§4.10).

  An important special case is that there is a narrowing reference conversion from the class typeObject to any other reference type (§4.12.4).

• From any class typeC to any non-parameterized interface typeK, provided thatC is notfinal and does not implementK.

• From any interface typeJ to any non-parameterized class typeC that is notfinal.

• From any interface typeJ to any non-parameterized interface typeK, provided thatJ is not a subinterface ofK.

• From the interface typesCloneable andjava.io.Serializable to any array typeT[].

• From any array typeSC[] to any array typeTC[], provided thatSC andTC are reference types and there is a narrowing reference conversion fromSC toTC.

• From typeboolean to typeBoolean

• From typebyte to typeByte

• From typeshort to typeShort

• From typechar to typeCharacter

• From typeint to typeInteger

• From typelong to typeLong

• From typefloat to typeFloat

• From typedouble to typeDouble

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

• Ifp is a value of typeboolean, then boxing conversion convertsp into a referencer of class and typeBoolean, such thatr.booleanValue() ==p

• Ifp is a value of typebyte, then boxing conversion convertsp into a referencer of class and typeByte, such thatr.byteValue() ==p

• Ifp is a value of typechar, then boxing conversion convertsp into a referencer of class and typeCharacter, such thatr.charValue() ==p

• Ifp is a value of typeshort, then boxing conversion convertsp into a referencer of class and typeShort, such thatr.shortValue() ==p

• Ifp is a value of typeint, then boxing conversion convertsp into a referencer of class and typeInteger, such thatr.intValue() ==p

• Ifp is a value of typelong, then boxing conversion convertsp into a referencer of class and typeLong, such thatr.longValue() ==p

• Ifp is a value of typefloat then:

  • Ifp is not NaN, then boxing conversion convertsp into a referencer of class and typeFloat, such thatr.floatValue() evaluates top

  • Otherwise, boxing conversion convertsp into a referencer of class and typeFloat such thatr.isNaN() evaluates totrue

• Ifp is a value of typedouble, then:

  • Ifp is not NaN, boxing conversion convertsp into a referencer of class and typeDouble, such thatr.doubleValue() evaluates top

  • Otherwise, boxing conversion convertsp into a referencer of class and typeDouble such thatr.isNaN() evaluates totrue

• Ifp is a value of any other type, boxing conversion is equivalent to an identity conversion (§5.1.1).

• From typeBoolean to typeboolean

• From typeByte to typebyte

• From typeShort to typeshort

• From typeCharacter to typechar

• From typeInteger to typeint

• From typeLong to typelong

• From typeFloat to typefloat

• From typeDouble to typedouble

• Ifr is a reference of typeBoolean, then unboxing conversion convertsr intor.booleanValue()

• Ifr is a reference of typeByte, then unboxing conversion convertsr intor.byteValue()

• Ifr is a reference of typeCharacter, then unboxing conversion convertsr intor.charValue()

• Ifr is a reference of typeShort, then unboxing conversion convertsr intor.shortValue()

• Ifr is a reference of typeInteger, then unboxing conversion convertsr intor.intValue()

• Ifr is a reference of typeLong, then unboxing conversion convertsr intor.longValue()

• Ifr is a reference of typeFloat, unboxing conversion convertsr intor.floatValue()

• Ifr is a reference of typeDouble, then unboxing conversion convertsr intor.doubleValue()

• Ifr isnull, unboxing conversion throws aNullPointerException

• IfT_i is a wildcard type argument (§4.5.1) of the form?, thenS_i is a fresh type variable whose upper bound isU_i[A1:=S1,...,An:=Sn] and whose lower bound is the null type (§4.1).

• IfT_i is a wildcard type argument of the form?extendsB_i, thenS_i is a fresh type variable whose upper bound is glb(B_i,U_i[A1:=S1,...,An:=Sn]) and whose lower bound is the null type.

  glb(V₁,...,V_m) is defined asV₁& ...&V_m.

  It is a compile-time error if, for any two classes (not interfaces)V_i andV_j,V_i is not a subclass ofV_j or vice versa.

• IfT_i is a wildcard type argument of the form?superB_i, thenS_i is a fresh type variable whose upper bound isU_i[A1:=S1,...,An:=Sn] and whose lower bound isB_i.

• Otherwise,S_i =T_i.

Capture conversion is designed to make wildcards more useful. To understand the motivation, let's begin by looking at the methodjava.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 typeList<?> as the type of the formal parameter is entirely appropriate.

Now consider how one would implementreverse():

public static void reverse(List<?> list) { rev(list); }private static <T> void rev(List<T> list) {    List<T> tmp = new ArrayList<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 methodrev(). This requires us to pass the incoming argument list, of typeList<?>, as an argument torev(). In general,List<?> is a list of unknown type. It is not a subtype ofList<T>, for any typeT. Allowing such a subtype relation would be unsound. Given the method:

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

the following code would undermine the type system:

List<String> ls = new ArrayList<String>();List<?> l = ls;Collections.fill(l, new Object());  // not legal - but assume it was!String s = ls.get(0); // ClassCastException - ls contains                      // Objects, not Strings.

So, without some special dispensation, we can see that the call fromreverse() torev() would be disallowed. If this were the case, the author ofreverse() 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 fromreverse() torev() is in fact harmless, but it cannot be justified on the basis of a general subtyping relation betweenList<?> andList<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 variableX, we can inferT to beX. 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.

• IfT isboolean, then usenew Boolean(x).

• IfT ischar, then usenew Character(x).

• IfT isbyte,short, orint, then usenew Integer(x).

• IfT islong, then usenew Long(x).

• IfT isfloat, then usenew Float(x).

• IfT isdouble, then usenew Double(x).

• If the reference isnull, it is converted to the string "null" (four ASCII charactersn,u,l,l).

• Otherwise, the conversion is performed as if by an invocation of thetoString method of the referenced object with no arguments; but if the result of invoking thetoString method isnull, then the string "null" is used instead.

  ThetoString method is defined by the primordial classObject (§4.3.2). Many classes override it, notablyBoolean,Character,Integer,Long,Float,Double, andString.

• If the value is an element of the float-extended-exponent value set, then the implementation may, at its option, map the value to the nearest element of the float value set. This conversion may result in overflow (in which case the value is replaced by an infinity of the same sign) or underflow (in which case the value may lose precision because it is replaced by a denormalized number or zero of the same sign).

• If the value is an element of the double-extended-exponent value set, then the implementation may, at its option, map the value to the nearest element of the double value set. This conversion may result in overflow (in which case the value is replaced by an infinity of the same sign) or underflow (in which case the value may lose precision because it is replaced by a denormalized number or zero of the same sign).

• If the value is of typefloat and is not an element of the float value set, then the implementation must map the value to the nearest element of the float value set. This conversion may result in overflow or underflow.

• If the value is of typedouble and is not an element of the double value set, then the implementation must map the value to the nearest element of the double value set. This conversion may result in overflow or underflow.

class Test {    public static void main(String[] args) {        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.toString(l,16));        f = 1.23f;        double d = f;      // widen float to double        System.out.println("d=" + d);    }}

This program produces the output:

f=12.0l=0x123d=1.2300000190734863

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

class Test {    public static void main(String[] args) {        short s = 123;        char c = s;    // error: would require cast        s = c;         // error: would require cast    }}

because not allshort values arechar values, and neither are allchar valuesshort values.

class Point { int x, y; }class Point3D extends Point { int z; }interface Colorable { void setColor(int color); }class ColoredPoint extends Point implements Colorable {    int color;    public void setColor(int color) { this.color = color; }}class Test {    public static void main(String[] args) {        // Assignments to variables of class type:        Point p = new Point();        p = new Point3D();           // OK because Point3D is a subclass of Point        Point3D p3d = p;           // Error: will require a cast because a Point          // might not be a Point3D (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:        ColoredPoint cp = new ColoredPoint();        Colorable c = cp;          // OK: ColoredPoint 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        Point3D[] p3da = new Point3D[3];        Point[] pa = p3da;           // OK: since we can assign a Point3D to a Point        p3da = pa;          // Error: (cast needed) since a Point          // can't be assigned to a Point3D    }}

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 setColor(int color); }class ColoredPoint extends Point implements Colorable {    int color;    public void setColor(int color) { this.color = color; }}class Test {    public static void main(String[] args) {        Point p = new Point();        ColoredPoint cp = new ColoredPoint();        // Okay because ColoredPoint is a subclass of Point:        p = cp;        // Okay because ColoredPoint 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 ColoredPoint                   // nor a subclass of ColoredPoint        c = p;     // p might not implement Colorable    }}

class Point { int x, y; }class ColoredPoint extends Point { int color; }class Test {    public static void main(String[] args) {        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];        ColoredPoint[] cpvec = new ColoredPoint[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:

• IfT is a class type, then either |S|<: |T|, or |T|<: |S|. Otherwise, a compile-time error occurs.

  Furthermore, if there exists a supertypeX ofT, and a supertypeY ofS, such that bothX andY are provably distinct parameterized types (§4.5), and that the erasures ofX andY are the same, a compile-time error occurs.

• IfT is an interface type:

  • IfS is not afinal class (§8.1.1), then, if there exists a supertypeX ofT, and a supertypeY ofS, such that bothX andY are provably distinct parameterized types, and that the erasures ofX andY are the same, a compile-time error occurs.

    Otherwise, the cast is always legal at compile time (because even ifS does not implementT, a subclass ofS might).

  • IfS is afinal class (§8.1.1), thenS must implementT, or a compile-time error occurs.

• IfT is a type variable, then this algorithm is applied recursively, using the upper bound ofT in place ofT.

• IfT is an array type, thenS must be the classObject, or a compile-time error occurs.

• IfT is an intersection type,T₁& ...&T_n, then it is a compile-time error if there exists aT_i (1≤i≤n) such thatS cannot be cast toT_i by this algorithm. That is, the success of the cast is determined by the most restrictive component of the intersection type.

• IfT is an array type, thenS must be the typejava.io.Serializable orCloneable (the only interfaces implemented by arrays), or a compile-time error occurs.

• IfT is a class or interface type that is notfinal (§8.1.1), then if there exists a supertypeX ofT, and a supertypeY ofS, such that bothX andY are provably distinct parameterized types, and that the erasures ofX andY are the same, a compile-time error occurs.

  Otherwise, the cast is always legal at compile time (because even ifT does not implementS, a subclass ofT might).

• IfT is a class type that isfinal, then:

  • IfS is not a parameterized type or a raw type, thenT must implementS, or a compile-time error occurs.

  • Otherwise,S is either a parameterized type that is an invocation of some generic type declarationG, or a raw type corresponding to a generic type declarationG. Then there must exist a supertypeX ofT, such thatX is an invocation ofG, or a compile-time error occurs.

    Furthermore, ifS andX are provably distinct parameterized types then a compile-time error occurs.

• IfT is a type variable, then this algorithm is applied recursively, using the upper bound ofT in place ofT.

• IfT is an intersection type,T₁& ...&T_n, then it is a compile-time error if there exists aT_i (1≤i≤n) such thatS cannot be cast toT_i by this algorithm.

• IfT is a class type, then ifT is notObject, then a compile-time error occurs (becauseObject is the only class type to which arrays can be assigned).

• IfT is an interface type, then a compile-time error occurs unlessT is the typejava.io.Serializable or the typeCloneable (the only interfaces implemented by arrays).

• IfT is a type variable, then this algorithm is applied recursively, using the upper bound ofT in place ofT.

• IfT is an array typeTC[], that is, an array of components of typeTC, then a compile-time error occurs unless one of the following is true:

  • TC andSC are the same primitive type.

  • TC andSC are reference types and typeSC can undergo casting conversion toTC.

• IfT is an intersection type,T₁& ...&T_n, then it is a compile-time error if there exists aT_i (1≤i≤n) such thatS cannot be cast toT_i by this algorithm.

Example 5.5.1-1. Casting Conversion for Reference Types

class Point { int x, y; }interface Colorable { void setColor(int color); }class ColoredPoint extends Point implements Colorable {    int color;    public void setColor(int color) { this.color = color; }}final class EndPoint extends Point {}class Test {    public static void main(String[] args) {        Point p = new Point();        ColoredPoint cp = new ColoredPoint();        Colorable c;        // The following may cause errors at run time because        // we cannot be sure they will succeed; this possibility        // is suggested by the casts:        cp = (ColoredPoint)p;  // p might not reference an                               // object which is a ColoredPoint                               // or a subclass of ColoredPoint        c = (Colorable)p;      // p might not be Colorable        // The following are incorrect at compile time because        // they can never succeed as explained in the text:        Long l = (Long)p;            // compile-time error #1        EndPoint e = new EndPoint();        c = (Colorable)e;            // compile-time error #2    }}

Example 5.5.1-2. Casting Conversion for Array Types

class Point {    int x, y;    Point(int x, int y) { this.x = x; this.y = y; }    public String toString() { return "("+x+","+y+")"; }}interface Colorable { void setColor(int color); }class ColoredPoint extends Point implements Colorable {    int color;    ColoredPoint(int x, int y, int color) {        super(x, y); setColor(color);    }    public void setColor(int color) { this.color = color; }    public String toString() {        return super.toString() + "@" + color;    }}class Test {    public static void main(String[] args) {        Point[] pa = new ColoredPoint[4];        pa[0] = new ColoredPoint(2, 2, 12);        pa[1] = new ColoredPoint(4, 5, 24);        ColoredPoint[] cpa = (ColoredPoint[])pa;        System.out.print("cpa: {");        for (int i = 0; i < cpa.length; i++)            System.out.print((i == 0 ? " " : ", ") + cpa[i]);        System.out.println(" }");    }}

cpa: { (2,2)@12, (4,5)@24, null, null }

• S<:T

• All of the type arguments (§4.5.1) ofT are unbounded wildcards

• T<:S andS has no subtypeX other thanT where the type arguments ofX are not contained in the type arguments ofT.

• The cast is statically known to be correct.

  No run-time action is performed for such a cast.

• The cast is a completely unchecked cast.

  No run-time action is performed for such a cast.

• The cast is a partially unchecked or checked cast to an intersection type.

  Where the intersection type isT₁& ...&T_n, then for alli (1≤i≤n), any run-time check required for a cast fromS toT_i is also required for the cast to the intersection type.

• The cast is a partially unchecked cast to a non-intersection type.

  Such a cast requires a run-time validity check. The check is performed as if the cast had been a checked cast between |S| and |T|, as described below.

• The cast is a checked cast to a non-intersection type.

  Such a cast requires a run-time validity check. If the value at run time isnull, then the cast is allowed. Otherwise, letR be the class of the object referred to by the run-time reference value, and letT be the erasure (§4.6) of the type named in the cast operator. A cast conversion must check, at run time, that the classR is assignment compatible with the typeT, via the algorithm in§5.5.3.

  Note thatR cannot be an interface when these rules are first applied for any given cast, butR 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.

• IfT is a class type, thenR must be either the same class (§4.3.4) asT or a subclass ofT, or a run-time exception is thrown.

• IfT is an interface type, thenR must implement (§8.1.5) interfaceT, or a run-time exception is thrown.

• IfT is an array type, then a run-time exception is thrown.

• IfT is a class type, thenT must beObject (§4.3.2), or a run-time exception is thrown.

• IfT is an interface type, thenR must be either the same interface asT or a subinterface ofT, or a run-time exception is thrown.

• IfT is an array type, then a run-time exception is thrown.

• IfT is a class type, thenT must beObject (§4.3.2), or a run-time exception is thrown.

• IfT is an interface type, then a run-time exception is thrown unlessT is the typejava.io.Serializable or the typeCloneable (the only interfaces implemented by arrays).

  This case could slip past the compile-time checking if, for example, a reference to an array were stored in a variable of typeObject.

• IfT is an array typeTC[], that is, an array of components of typeTC, then a run-time exception is thrown unless one of the following is true:

  • TC andRC are the same primitive type.

  • TC andRC are reference types and typeRC can be cast toTC by a recursive application of these run-time rules for casting.

Example 5.5.3-1. Incompatible Types at Run Time

class Point { int x, y; }interface Colorable { void setColor(int color); }class ColoredPoint extends Point implements Colorable {    int color;    public void setColor(int color) { this.color = color; }}class Test {    public static void main(String[] args) {        Point[] pa = new Point[100];        // The following line will throw a ClassCastException:        ColoredPoint[] cpa = (ColoredPoint[])pa;        System.out.println(cpa[0]);        int[] shortvec = new int[2];        Object o = shortvec;        // The following line will throw a ClassCastException:        Colorable c = (Colorable)o;        c.setColor(0);    }}

• If the operand is of compile-time typeByte,Short,Character, orInteger, it is subjected to unboxing conversion (§5.1.8). The result is then promoted to a value of typeint by a widening primitive conversion (§5.1.2) or an identity conversion (§5.1.1).

• Otherwise, if the operand is of compile-time typeLong,Float, orDouble, it is subjected to unboxing conversion (§5.1.8).

• Otherwise, if the operand is of compile-time typebyte,short, orchar, it is promoted to a value of typeint by a widening primitive conversion (§5.1.2).

• Otherwise, a unary numeric operand remains as is and is not converted.

• Each dimension expression in an array creation expression (§15.10.1)

• The index expression in an array access expression (§15.10.3)

• The operand of a unary plus operator+ (§15.15.3)

• The operand of a unary minus operator- (§15.15.4)

• The operand of a bitwise complement operator~ (§15.15.5)

• Each operand, separately, of a shift operator<<,>>, or>>> (§15.19).

  Along shift distance (right operand) does not promote the value being shifted (left operand) tolong.

Example 5.6.1-1. Unary Numeric Promotion

class Test {    public static void main(String[] args) {        byte b = 2;        int a[] = new int[b];  // dimension expression promotion        char c = '\u0001';        a[c] = 1;              // index expression promotion        a[0] = -c;             // unary - promotion        System.out.println("a: " + a[0] + "," + a[1]);        b = -1;        int i = ~b;            // bitwise complement promotion        System.out.println("~0x" + Integer.toHexString(b)                           + "==0x" + Integer.toHexString(i));        i = b << 4L;           // shift promotion (left operand)        System.out.println("0x" + Integer.toHexString(b)                           + "<<4L==0x" + Integer.toHexString(i));    }}

a: -1,1~0xffffffff==0x00xffffffff<<4L==0xfffffff0

1. If any operand is of a reference type, it is subjected to unboxing conversion (§5.1.8).

2. Widening primitive conversion (§5.1.2) is applied to convert either or both operands as specified by the following rules:

   • If either operand is of typedouble, the other is converted todouble.

   • Otherwise, if either operand is of typefloat, the other is converted tofloat.

   • Otherwise, if either operand is of typelong, the other is converted tolong.

   • Otherwise, both operands are converted to typeint.

• The multiplicative operators*,/, and% (§15.17)

• The addition and subtraction operators for numeric types+ and- (§15.18.2)

• The numerical comparison operators<,<=,>, and>= (§15.20.1)

• The numerical equality operators== and!= (§15.21.1)

• The integer bitwise operators&,^, and| (§15.22.1)

• In certain cases, the conditional operator? : (§15.25)

Example 5.6.2-1. Binary Numeric Promotion

class Test {    public static void main(String[] args) {        int i    = 0;        float f  = 1.0f;        double d = 2.0;        // First int*float is promoted to float*float, then        // float==double is promoted to double==double:        if (i * f == d) System.out.println("oops");        // A char&byte is promoted to int&int:        byte b = 0x1f;        char c = 'G';        int control = c & b;        System.out.println(Integer.toHexString(control));        // Here int:float is promoted to float:float:        f = (b==0) ? i : 4.0f;        System.out.println(1.0/f);    }}

70.25