Преобразование типа в тот же тип разрешено для любого типа.

Это может показаться тривиальным, но у этого есть два практических последствия. Во-первых, всегда разрешается, чтобы выражение имело нужный тип с самого начала, что позволяет просто утверждать, что каждое выражение подвержено преобразованию, если только не требуется тривиальное преобразование тождества. Во-вторых, это подразумевает, что программа может содержать избыточные операторы приведения для большей ясности.

19 конкретных преобразований примитивных типов называются расширяющими преобразованиями примитивных типов:

Расширяющее преобразование примитивных типов не теряет информацию о величине числового значения в следующих случаях, где числовое значение сохраняется точно:

Расширяющее преобразование примитивного типа от float к double, которое не является strictfp, может потерять информацию о величине преобразованного значения.

Расширяющее преобразование примитивного типа от int к float или от long к float или от long к double может привести к потере точности — то есть результат может потерять некоторые из наименее значимых битов значения. В этом случае полученное значение с плавающей точкой будет правильно округленной версией целочисленного значения с использованием режима округления IEEE 754 до ближайшего значения (§4.2.4).

Расширяющее преобразование знака целочисленного значения в целочисленный тип T просто расширяет представление значения в дополнительном коде до двух разрядов для заполнения более широкого формата.

Расширяющее преобразование char в целочисленный тип T расширяет представление значения char до нуля, чтобы заполнить более широкий формат.

Несмотря на то, что потеря точности может произойти, расширяющее преобразование примитивного типа никогда не приводит к исключению во время выполнения (§11.1.1).

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

-46

22 конкретных преобразования примитивных типов называются преобразованиями примитивных типов сужения:

При преобразовании примитивного типа сужения может быть потеряна информация о величине числового значения, а также может быть потеряна точность и диапазон.

Преобразование примитивного типа сужения из double в float регулируется правилами округления IEEE 754 (§4.2.4). Это преобразование может потерять точность, а также диапазон, что приводит к нулю float от ненулевого double и бесконечности float от конечного double. double NaN преобразуется в float NaN, а double бесконечность преобразуется в бесконечность с тем же знаком float.

Преобразование сужения знакового целого числа в целочисленный тип T просто отбрасывает все, кроме n младших разрядов, где n — количество битов, используемых для представления типа T. Помимо возможной потери информации о величине числового значения, это может привести к изменению знака результирующего значения по сравнению со знаком входного значения.

Преобразование сужения char в целочисленный тип T также просто отбрасывает все, кроме n младших разрядов, где n — количество битов, используемых для представления типа T. Помимо возможной потери информации о величине числового значения, это может привести к тому, что результирующее значение будет отрицательным, даже если символы представляют 16-битные беззнаковые целочисленные значения.

Преобразование сужения числа с плавающей точкой в целочисленный тип T выполняется в два этапа:

Несмотря на то, что может произойти переполнение, недополнение или другая потеря информации, преобразование примитивного типа сужения никогда не приводит к исключению во время выполнения (§11.1.1).

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..9223372036854775807
int: -2147483648..2147483647
short: 0..-1
char: 0..65535
byte: 0..-1

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 преобразуется в int с помощью расширяющего преобразования примитивных типов (§5.1.2), а затем полученное int преобразуется в char с помощью сужающего преобразования примитивных типов (§5.1.3).

Существует расширяющее преобразование ссылочного типа от любого ссылочного типа S к любому ссылочному типу T, если S является подтипом T (§4.10).

Расширяющие преобразования ссылочных типов никогда не требуют специальных действий во время выполнения и, следовательно, никогда не выбрасывают исключение во время выполнения. Они состоят просто в том, что ссылка рассматривается как имеющая какой-то другой тип, что может быть доказано правильным на этапе компиляции.

Тип null не является ссылочным типом (§4.1), поэтому расширяющее преобразование ссылочного типа не существует от типа null к ссылочному типу. Однако многие контексты преобразования явно позволяют преобразовать тип null в ссылочный тип.

Преобразование в обертку рассматривает выражения примитивного типа как выражения соответствующего ссылочного типа. В частности, следующие девять преобразований называются преобразованиями в обертку:

Во время выполнения преобразование в обертку происходит следующим образом:

Если значение p, которое нужно преобразовать в обертку, является результатом вычисления константного выражения (§15.28) типа boolean, char, short, int или long, и результат равен true, false, символу в диапазоне '\u0000' до '\u007f' включительно или целому числу в диапазоне -128 до 127 включительно, то пусть a и b будут результатами любых двух преобразований в обертку p. Всегда выполняется a == b.

В идеале преобразование в обертку примитивного значения всегда должно возвращать идентичную ссылку. На практике это может быть невозможным при использовании существующих методов реализации. Приведенное выше правило является прагматическим компромиссом, требующим, чтобы определенные общие значения всегда были упакованы в неразличимые объекты. Реализация может кешировать их, лениво или сразу. Для других значений это правило запрещает разработчику делать какие-либо предположения об идентичности упакованных значений. Это позволяет (но не требует) совместного использования некоторых или всех этих ссылок.

Это гарантирует, что в большинстве распространенных случаев поведение будет желаемым, без чрезмерной потери производительности, особенно на небольших устройствах. Реализации с меньшим ограничением по памяти могут, например, кэшировать все значения char и short, а также значения int и long в диапазоне от -32K до +32K.

Преобразование в обертку может привести к OutOfMemoryError, если необходимо создать новый экземпляр одного из классов-оберток (Boolean, Byte, Character, Short, Integer, Long, Float или Double), а доступной памяти недостаточно.

Преобразование распаковки рассматривает выражения ссылочного типа как выражения соответствующего примитивного типа. В частности, следующие восемь преобразований называются преобразованиями распаковки:

Во время выполнения преобразование распаковки происходит следующим образом:

Говорят, что тип преобразуется в числовой тип, если это числовой тип (§4.2) или это ссылочный тип, который может быть преобразован в числовой тип преобразованием распаковки.

Говорят, что тип преобразуется в целочисленный тип, если это целочисленный тип или это ссылочный тип, который может быть преобразован в целочисленный тип преобразованием распаковки.

Пусть G обозначает объявление обобщённого типа с n параметрами типа.

Существует преобразование без проверки от исходного класса или интерфейсного типа (§4.8) G к любому параметризованному типу вида G<T₁,...,T_n>.

Существует преобразование без проверки от исходного массива типа G[]^k к любому массивному типу вида G<T₁,...,T_n>[]^k. (Запись []^k обозначает массив типа с k измерениями.)

Использование преобразования без проверки вызывает предупреждение о компиляции без проверки, если все аргументы типа T_i (1 ≤ i ≤ n) являются неограниченными подстановочными знаками (§4.5.1), или предупреждение подавлено с помощью @SuppressWarnings (§9.6.4.5).

Преобразование без проверки используется для обеспечения бесшовного взаимодействия устаревшего кода, написанного до появления обобщённых типов, с библиотеками, которые были преобразованы для использования обобщённости (процесс, который мы называем обобщением). В таких обстоятельствах (прежде всего, клиенты Collections Framework в java.util), устаревший код использует сырые типы (например, Collection вместо Collection<String>). Выражения сырых типов передаются в качестве аргументов методам библиотек, которые используют параметризованные версии тех же типов как типы соответствующих формальных параметров.

Такие вызовы не могут быть доказаны статически безопасными в системе типов с использованием обобщений. Отклонение таких вызовов сделало бы недействительными большие объёмы существующего кода и помешало бы им использовать более новые версии библиотек. Это, в свою очередь, отбило бы у поставщиков библиотек желание использовать обобщения. Чтобы предотвратить такой нежелательный поворот событий, сырой тип может быть преобразован в любое вызов объявления обобщённого типа, к которому относится сырой тип. Хотя преобразование некорректно, оно допускается как уступка практичности. В таких случаях выдаётся предупреждение о преобразовании без проверки.

Пусть G обозначает объявление универсального типа (§8.1.2, §9.1.2) с n параметрами типа A₁,...,A_n с соответствующими ограничениями U₁,...,U_n.

Существует преобразование захвата от параметризованного типа G<T₁,...,T_n> (§4.5) к параметризованному типу G<S₁,...,S_n>, где для 1 ≤ i ≤ n :

Преобразование захвата для любого типа, кроме параметризованного типа (§4.5), действует как преобразование тождества (§5.1.1).

Преобразование захвата не применяется рекурсивно.

Преобразование захвата никогда не требует специальных действий во время выполнения и, следовательно, никогда не генерирует исключение во время выполнения.

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

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));
    }
}

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

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.

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

Математически продвинутые читатели захотят сопоставить преобразование захвата с известными понятиями теории типов. Читатели, незнакомые с теорией типов, могут пропустить эту дискуссию — или же изучить соответствующий текст, например, Типы и языки программирования Бенджамина Пирса, а затем вернуться к этому разделу.

Вот краткий обзор взаимоотношения преобразования захвата с известными понятиями теории типов. Типы-подстановки являются ограниченной формой экзистенциальных типов. Преобразование захвата в некотором роде соответствует открытию значения экзистенциального типа. Преобразование захвата выражения e можно рассматривать как открытие open e в области, которая включает в себя выражение верхнего уровня, которое охватывает e.

Классическая операция open над экзистенциальными значениями требует, чтобы захваченная переменная типа не выходила за пределы открытого выражения. Преобразование open, соответствующее преобразованию захвата, всегда находится в области, достаточно большой, чтобы захваченная переменная типа никогда не была видна за пределами этой области. Преимущество этой схемы состоит в том, что нет необходимости в операции close, как определено в статье О подтипизации на основе вариативности для параметризованных типов Ацуши Игараси и Мирко Вироли в материалах 16-й Европейской конференции по объектно-ориентированному программированию (ECOOP 2002). Подробный анализ подстановочных типов см. в статье Дикие FJ Мадса Торгерсена, Эрика Эрнста и Кристиана Плеснера Хансена в материалах 12-го семинара по основам объектно-ориентированного программирования (FOOL 2005).

Любой тип может быть преобразован в тип String с помощью преобразования в строку.

Значение x примитивного типа T сначала преобразуется в значение ссылки, как если бы оно было передано в качестве аргумента в выражение создания экземпляра соответствующего класса (§15.9):

Это значение ссылки затем преобразуется в тип String с помощью преобразования в строку.

Теперь нужно учитывать только значения ссылок:

Любое преобразование, которое не разрешено явно, запрещено.

Преобразование набора значений — это процесс сопоставления значения с плавающей точкой из одного набора значений в другой без изменения его типа.

В выражении, которое не является FP-строгим (§15.4), преобразование набора значений предоставляет выбор реализации языка программирования Java:

В FP-строгом выражении (§15.4) преобразование набора значений не предоставляет никаких вариантов; каждая реализация должна вести себя одинаково:

В FP-строгом выражении сопоставление значений из набора значений с расширенным порядком экспоненты чисел с плавающей точкой или набора значений с расширенным порядком экспоненты чисел с двойной точностью необходимо только тогда, когда вызывается метод, объявление которого не является FP-строгим, и реализация выбрала представление результата вызова метода как элемента набора значений с расширенным порядком экспоненты.

Как в FP-строгом коде, так и в коде, который не является FP-строгим, преобразование набора значений всегда оставляет неизменным любое значение, тип которого не является ни float, ни double.