.JAVA File Format – Conversions and contexts

Kinds of conversion

Anything else is forbidden (5.1.12): for example there is no conversion between boolean and any other primitive type, and none between unrelated final classes such as String and Integer, even with a cast.

Widening primitive conversions

There are 19 widening primitive conversions. They never throw and never lose the magnitude of a value:

Three of them may lose precision, rounding to the nearest value: int to float, long to float and long to double. So (float) 16_777_217 is 16,777,216. Widening a signed integer extends the sign; widening a char fills with zeros.

Narrowing primitive conversions

There are 22 narrowing primitive conversions, and they also never throw:

• Between integral types, the high bits are discarded: (byte) 200 is −56, and (int) 3_000_000_000L is −1,294,967,296.
• From float or double to int or long, the value is rounded towards zero; NaN becomes 0, and values too large or too small become the type’s largest or smallest value: (int) 1e20 is 2,147,483,647.
• To byte, short or char, a floating-point value is first converted to int as above and then narrowed, so (byte) 1e20 is −1.
• double to float rounds to nearest, and may give zero or infinity.

Reference conversions

A widening reference conversion goes from a type to any of its supertypes and needs no check at run time: ArrayList<String> to List<String>, String[] to Object[], any reference type to Object, and the null type to any reference type.

A narrowing reference conversion goes the other way, or between types that could have a common subtype (such as a non-final class and an interface). It needs a cast, and is checked at run time: if the object is not an instance of the target, a ClassCastException is thrown. When the target is a parameterised type the check is only partial, because type arguments are erased, and the compiler gives an unchecked warning:

Object o = "text";
String s = (String) o;                 // checked: succeeds
Integer i = (Integer) o;               // compiles, throws ClassCastException
List<?> any = List.of(1, 2);
List<String> strs = (List<String>) any;   // unchecked warning: not checked at run time

Boxing and unboxing

Boxing (Java 5) converts a primitive to its wrapper, and unboxing the other way:

Boxing is done by the wrapper’s valueOf method. JLS 5.1.7 requires that boxing a constant true or false, a char up to \u007f or an integer from −128 to 127 always gives the same object, so Integer a = 127, b = 127; gives a == b true, while for 128 the result is not defined. Compare wrappers with equals. Unboxing null throws NullPointerException:

Map<String, Integer> counts = new HashMap<>();
int n = counts.get("missing");   // NullPointerException: get returned null

Unchecked, capture and string conversion

• Unchecked conversion turns a raw type into any parameterised type of the same class: List to List<String>. It is allowed for compatibility with code written before generics, with a warning unless every type argument is an unbounded wildcard.
• Capture conversion replaces each wildcard in a type with a fresh type variable, so that the compiler can reason about an expression of type List<?>. These variables appear in error messages as CAP#1. See Generics.
• String conversion turns any value into a String: null becomes "null", a primitive is formatted as by String.valueOf, and any other object by calling its toString() (or "null" if that returns null).

Contexts

byte b = 42;            // fine: 42 fits in a byte
char c = 65;            // fine: 'A'
byte big = 200;         // error: 200 does not fit
int i = 42;
byte b2 = i;            // error: i is not a constant
final int K = 42;
byte b3 = K;            // fine: K is a constant variable
Long boxed = 42;        // error: int cannot be boxed to Long

static void f(long x)     { System.out.println("long"); }
static void f(Integer x)  { System.out.println("Integer"); }
static void f(int... x)   { System.out.println("varargs"); }

f(1);    // prints "long": widening is found in phase 1, before boxing