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

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

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

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

Расширяющее преобразование примитивного типа от целочисленного типа к другому целочисленному типу или от float к double в выражении strictfp (§15.4) не теряет никакой информации; числовое значение сохраняется точно.

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

Расширяющее преобразование значения int или 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 выполняется в два шага:

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

Несмотря на то, что может произойти переполнение, недополнение или другая потеря информации, преобразование примитивных типов сужения никогда не приводит к исключению во время выполнения (§11.1.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, которое заключается в оболочку, является true, false, byte, или char в диапазоне \u0000 к \u007f, или int или short число между -128 и 127 (включительно), то пусть r1 и r2 будут результатами любых двух преобразований в оболочку p. Всегда имеет место то, что r1 == r2.

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

Это гарантирует, что в большинстве распространенных случаев поведение будет желаемым, не налагая чрезмерных штрафов за производительность, особенно на небольших устройствах. Менее ограниченные по памяти реализации могут, например, кэшировать все 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[] к любому массиву типа вида G<T₁,...,T_n>[].

Использование непроверенного преобразования вызывает предупреждение о непроверенном преобразовании во время компиляции, если G<...> — это параметризованный тип, в котором все аргументы типа являются не ограниченными универсальными символами (§4.5.1), или предупреждение о непроверенном преобразовании подавляется аннотацией SuppressWarnings (§9.6.3.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 с помощью преобразования строк.

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

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

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

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

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

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

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

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

Учитывая тип ссылки S (источник) и тип ссылки T (цель) на этапе компиляции, преобразование приведения типа существует от S к T, если не происходит ошибок на этапе компиляции из-за следующих правил.

Если S является типом класса:

Если S является типом интерфейса:

Если S является переменной типа, то этот алгоритм применяется рекурсивно, используя верхнюю границу S вместо S.

Если S является пересечением типов A₁ & ... & A_n, то это ошибка на этапе компиляции, если существует A_i (1 ≤ i ≤ n), такой что тип S не может быть приведён к типу A_i по этому алгоритму. То есть, успех приведения определяется наиболее ограниченным компонентом типа пересечения.

Если S является типом массива SC[], то есть массивом компонентов типа SC:

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; }
}
final class EndPoint extends Point {}

class Test {
    public static void main(String[] args) {
        Point p = new Point();
        ColoredPoint cp = new ColoredPoint();
        Colorable c;
        // The following may cause errors at run time because
        // we cannot be sure they will succeed; this possibility
        // is suggested by the casts:
        cp = (ColoredPoint)p;  // p might not reference an
                               // object which is a ColoredPoint
                               // or a subclass of ColoredPoint
        c = (Colorable)p;      // p might not be Colorable
        // The following are incorrect at compile time because
        // they can never succeed as explained in the text:
        Long l = (Long)p;            // compile-time error #1
        EndPoint e = new EndPoint();
        c = (Colorable)e;            // compile-time error #2
    }
}

class Point {
    int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }
    public String toString() { return "("+x+","+y+")"; }
}
interface Colorable { void setColor(int color); }
class ColoredPoint extends Point implements Colorable {
    int color;
    ColoredPoint(int x, int y, int color) {
        super(x, y); setColor(color);
    }
    public void setColor(int color) { this.color = color; }
    public String toString() {
        return super.toString() + "@" + color;
    }
}

class Test {
    public static void main(String[] args) {
        Point[] pa = new ColoredPoint[4];
        pa[0] = new ColoredPoint(2, 2, 12);
        pa[1] = new ColoredPoint(4, 5, 24);
        ColoredPoint[] cpa = (ColoredPoint[])pa;
        System.out.print("cpa: {");
        for (int i = 0; i < cpa.length; i++)
            System.out.print((i == 0 ? " " : ", ") + cpa[i]);
        System.out.println(" }");
    }
}

cpa: { (2,2)@12, (4,5)@24, null, null }

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

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

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

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

Непроверенное приведение вызывает предупреждение компилятора о непроверенном приведении, если не подавлена аннотация SuppressWarnings (§9.6.3.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);
    }
}