### 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 a value of type`double`

, then - 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.