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

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

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 является подтипом (§4.10) T.

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

Шесть видов преобразований называются преобразованиями сужения ссылок:

Такие преобразования требуют проверки во время выполнения, чтобы выяснить, является ли фактическое ссылочное значение допустимым значением нового типа. Если нет, то выбрасывается ClassCastException.

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

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

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

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

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

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

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

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

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

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

Пусть 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 в 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 с помощью преобразования в строку.

Теперь необходимо рассматривать только значения ссылок:

Подробности контекста строк см. в §5.4.

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

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

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

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

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

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

Приведение типа S к типу T статически известно как корректное, если и только если S <: T (§4.10).

Приведение типа S к параметризованному типу (§4.5) T является непроверяемым, если не выполняется хотя бы одно из следующих условий:

Приведение типа S к переменной типа T является непроверяемым, если S <: T.

Приведение типа S к пересечению типов T₁ & ... & T_n является непроверяемым, если существует T_i (1 ≤ i ≤ n), при котором приведение S к T_i является непроверяемым.

Непроверяемое приведение типа S к типу T (не пересечению) является полностью непроверяемым, если приведение |S| к |T| статически известно как корректное. В противном случае оно является частично непроверяемым.

Непроверяемое приведение типа S к пересечению типов T₁ & ... & T_n является полностью непроверяемым, если для всех i (1 ≤ i ≤ n) приведение S к T_i либо статически известно как корректное, либо полностью непроверяемое. В противном случае оно является частично непроверяемым.

Непроверяемое приведение вызывает предупреждение о непроверяемом приведении во время компиляции, если оно не подавлено с помощью аннотации SuppressWarnings (§9.6.4.5).

Приведение является проверяемым, если оно не статически известно как корректное и не является непроверяемым.

Если приведение к ссылочному типу не является ошибкой во время компиляции, существует несколько случаев:

Вот алгоритм проверки того, является ли тип R во время выполнения объекта совместимым с типом T, который является стиранием (§4.6) типа, указанного в операторе приведения. Если генерируется исключение во время выполнения, это ClassCastException.

Если R — обычный класс (не класс массива):

Если R — интерфейс:

Если R — класс, представляющий тип массива RC[], то есть массив компонентов типа RC:

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