Глава 5. Преобразования и контексты

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

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

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

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

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

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

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

Расширяющее преобразование от int к float, или от long к float, или от int к double, или от long к double происходит в соответствии с правилами IEEE 754 для преобразования из целочисленного формата в двоичный формат с плавающей запятой.

Расширяющее преобразование от float к double происходит в соответствии с правилами IEEE 754 для преобразования между двоичными форматами с плавающей запятой.

Несмотря на то, что может произойти потеря точности, расширяющее преобразование примитивного типа никогда не приводит к исключению во время выполнения (§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 конкретных преобразования примитивных типов называются сужающими примитивными преобразованиями:

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

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

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

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

Сужающее преобразование из double в float происходит в соответствии с правилами IEEE 754 для преобразования между двоичными форматами чисел с плавающей точкой с использованием политики округления до ближайшего значения (§15.4). Это преобразование может потерять точность, но также может потерять диапазон, что приводит к нулю float из ненулевого double и бесконечности float из конечного double. double NaN преобразуется в float NaN, а double бесконечность преобразуется в бесконечность с тем же знаком float.

Несмотря на то, что может произойти переполнение, недополнение или другая потеря информации, сужающее примитивное преобразование никогда не приводит к исключению во время выполнения (§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 в тип ссылки.

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

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

Если значение p, которое упаковывается, является результатом вычисления константного выражения (§15.29) типа boolean, byte, 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 на экзистенциалах требует, чтобы захваченная переменная типа не покидала открытое выражение. Преобразование захвата, которое соответствует преобразованию захвата, всегда находится в достаточно большой области, чтобы захваченная переменная типа никогда не была видна вне этой области. Преимущество этой схемы заключается в том, что нет необходимости в операции close, как определено в статье О варьируемости, основанной на подтипах, для параметризованных типов Ацуси Игараси и Мирко Вироли, в материалах 16-й европейской конференции по объектно-ориентированному программированию (ECOOP 2002). Подробное описание диких символов см. в Wild FJ Мадса Торгертсена, Эрика Эрнста и Кристиана Плезнера Хансена в 12-й рабочей группе по основам объектно-ориентированного программирования (FOOL 2005).

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

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

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

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

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