### Boxing Conversion

Boxing conversion converts values of primitive type to corresponding values of reference type. Specifically, the following 8 conversion are called the boxing conversions:

• From type `boolean` to type `Boolean`
• From type `byte` to type `Byte`
• From type `char` to type `Character`
• From type `short` to type `Short`
• From type `int` to type `Integer`
• From type `long` to type `Long`
• From type `float` to type `Float`
• From type `double` to type `Double`

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.`byteValue()` == 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.`charValue()` == 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.`shortValue()` == 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.`intValue()` == 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.`longValue()` == p
• 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.`floatValue()` 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.`doubleValue()` 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 identity conversion (5.1.1).

If the value p being boxed is `true`, `false`, a `byte`, a `char` in the range \u0000 to \u007f, or an `int` or `short` number between -128 and 127, then let r1 and r2 be the results of any two boxing conversions of p. It is always the case that r1 == r2.

### Unboxing Conversion

Unboxing conversion converts values of reference type to corresponding values of primitive type. Specifically, the following 8 conversion are called the unboxing conversions:

• From type `Boolean` to type `boolean`
• From type `Byte` to type `byte`
• From type `Character` to type `char`
• From type `Short` to type `short`
• 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.`byteValue()`
• If r is a reference of type `Character`, then unboxing conversion converts r into r.`charValue()`
• If r is a reference of type `Short`, then unboxing conversion converts r into r.`shortValue()`
• If r is a reference of type `Integer`, then unboxing conversion converts r into r.`intValue()`
• If r is a reference of type `Long`, then unboxing conversion converts r into r.`longValue()`
• If r is a reference of type `Float`, unboxing conversion converts r into r.`floatValue()`
• If r is a reference of type `Double`, then unboxing conversion converts r into r.`doubleValue()`
• If r is `null`, unboxing conversion throws a `NullPointerException`

A type is said to be convertible to a numeric type if it is a numeric type, or it is a reference type that may be converted 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 converted to an integral type by unboxing conversion.