Приведение типов в Java

Аннотация: Эта лекция посвящена вопросам преобразования типов. Поскольку Java – язык строго типизированный, компилятор и виртуальная машина всегда следят за работой с типами, гарантируя надежность выполнения программы. Однако во многих случаях то или иное преобразование необходимо осуществить для реализации логики программы. С другой стороны, некоторые безопасные переходы между типами Java позволяет осуществлять неявным для разработчика образом, что может привести к неверному пониманию работы программы. В лекции рассматриваются все виды преобразований, а затем все ситуации в программе, где они могут применяться. В заключение приводится начало классификации типов переменных и типов значений, которые они могут хранить. Этот вопрос будет подробнее рассматриваться в следующих лекциях.

Что все это означает? Начнем по порядку. Для простых типов расширение означает, что осуществляется переход от менее емкого типа к более емкому. Например, от типа byte (длина 1 байт) к типу int (длина 4 байта). Такие преобразования безопасны в том смысле, что новый тип всегда гарантированно вмещает в себя все данные, которые хранились в старом типе, и таким образом не происходит потери данных. Именно поэтому компилятор осуществляет его сам, незаметно для разработчика:

byte b=3; int a=b;

В последней строке значение переменной b типа byte будет преобразовано к типу переменной a (то есть, int ) автоматически, никаких специальных действий для этого предпринимать не нужно.

Следующие 19 преобразований являются расширяющими:

от byte к short , int , long , float , double
от short к int , long , float , double
от char к int , long , float , double
от int к long , float , double
от long к float , double
от float к double

Обратите внимание, что нельзя провести преобразование к типу char от типов меньшей или равной длины (byte , short ), или, наоборот, к short от char без потери данных. Это связано с тем, что char , в отличие от остальных целочисленных типов, является беззнаковым.

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

Повторим этот пример:

long a=111111111111L; float f = a; a = (long) f; print(a);

Результатом будет:

Обратное преобразование - сужение - означает, что переход осуществляется от более емкого типа к менее емкому. При таком преобразовании есть риск потерять данные. Например, если число типа int было больше 127, то при приведении его к byte значения битов старше восьмого будут потеряны. В Java такое преобразование должно совершаться явным образом, т.е. программист в коде должен явно указать, что он намеревается осуществить такое преобразование и готов потерять данные.

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

от byte к char
от short к byte , char
от char к byte , short
от int к byte , short , char
от long к byte , short , char , int
от float к byte , short , char , int , long
от double к byte , short , char , int , long , float

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

print((byte)383); print((byte)384); print((byte)-384);

Результатом будет:

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

Это верно и для типа char :

char c=40000; print((short)c);

Результатом будет:

Сужение дробного типа до целочисленного является более сложной процедурой. Она проводится в два этапа.

На первом шаге дробное значение преобразуется в long , если целевым типом является long , или в int - в противном случае (целевой тип byte , short , char или int ). Для этого исходное дробное число сначала математически округляется в сторону нуля, то есть дробная часть просто отбрасывается.

Например, число 3,84 будет округлено до 3 , а -3,84 превратится в -3 . При этом могут возникнуть особые случаи:

если исходное дробное значение является NaN , то результатом первого шага будет 0 выбранного типа (т.е. int или long );
если исходное дробное значение является положительной или отрицательной бесконечностью, то результатом первого шага будет, соответственно, максимально или минимально возможное значение для выбранного типа (т.е. для int или long );
наконец, если дробное значение было конечной величиной, но в результате округления получилось слишком большое по модулю число для выбранного типа (т.е. для int или long ), то, как и в предыдущем пункте, результатом первого шага будет, соответственно, максимально или минимально возможное значение этого типа. Если же результат округления укладывается в диапазон значений выбранного типа, то он и будет результатом первого шага.

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

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

ТИП Метод для преобразова- Метод для преобразования из строки

ния В строку

boolean String.valueOf(boolean) new.Boolean(String). booleanvalue()

byte String.valueOf(byte) Byte.parseByte(string, int)

short String.valueOf(short) Short.parseShort(string, int)

int String.valueOf(int) Integer.parseInteger(string, int)

long String.valueOf(long) Long.parseLong(String, int)

float String.valueOf(float) Float.parseFloat(String)

double String.valueOf(double) Double.parseDouble(String)

Для преобразования строки в значение Boolean необходимо создать объект Boolean и затем запросить его значение. Все остальные классы-оболочки содержат Соответствующие методы parse. Методы parse целочисленных типов существуют в двух перегруженных формах: первая, помимо строки, требует задания дополнительного аргумента типа int, представляющего основание системы счисления – от 2 до 32; вторая принимает только параметр строки и по умолчанию предполагает использование десятичной системы счисления. Во всех случаях, кроме Boolean, предполагается следующее: если строка представляет значение, которое не может быть корректно преобразовано в число соответствующего типа, выбрасывается исключение NumberFormatException. Класс Boolean удовлетворяет соглашению, в соответствии с которым любая строка-параметр, не равная “true” (без учета регистра символов), приводит к созданию объекта вооlеаn со значением false.

Методов, позволяющих преобразовать символы, которые представлены в одной из поддерживаемых языком форм (таких как \b, \uxxxx и т.д.), В значения типа char и наоборот, не существует. Чтобы получить объект String, содержащий единственный символ, достаточно вызвать метод String.valueOf, передав ему в качестве параметра соответствующее значение типа char.

Отсутствуют также и способы создания строковых представлений чисел, заданных в одном из поддерживаемых языком форматов – с ведущим нулем (О), обозначающим восьмеричное число, и префиксом Ох (или ОХ), служащим признаком шестнадцатеричной системы счисления. Напротив, в целочисленных классах-оболочках поддерживаются версии метода decode, способного преобразовать строки в числовые значения соответствующего типа и “понимающего”, что ведущий О обозначает восьмеричное число, а один из префиксов Ох ИЛИ Ох – шестнадцатеричное.

Любой прикладной класс способен обеспечить поддержку преобразований собственных объектов в строки и обратно, если в его объявлении будет соответствующим образом переопределен метод toString и предусмотрен специальный конструктор, создающий объект класса на основе строки, переданной в качестве параметра. В вашем распоряжении имеется также метод String.valueOf(Object obj), который возвращает либо строковый объект “null” (если значение obj равно null), либо результат работы метода obj.toString. Класс String содержит достаточное количество перегруженных версий метода valueOf, позволяющих преобразовать любое значение любого типа в объект String посредством простого вызова valueOf с передачей нужного аргумента.

1. Что такое явное и автоматическое приведение типов в выражениях?

Приведение типов может быть явное и автоматическое.

При явном приведении типов сама операция приведения задается явным образом.

При автоматическом приведении типов нужно, чтобы выполнялись два условия:

оба типа должны быть совместимыми;
длина исходного типа (типа источника) должна быть меньше длины целевого типа (типа приемника).

2. Как выглядит явное приведение типов в выражениях? Примеры

Явное приведение типов позволяет осуществлять присвоение несовместимых типов. Общая форма явного приведения типов имеет вид:

(целевой_тип) значение

целевой_тип – это тип, в который нужно привести указанное значение .

Примеры явного приведения типов.

// явное приведение типов в выражениях byte b; int a; double d; float f; d = -39.9203; a = (int )d; // a = -39 f = (float )d; // f = -39.9203 b = (byte )d; // b = -39 d = 302930932; b = (byte )d; // b = -12 - урезание значения a = -27; b = (byte )a; // b = -27

3. Примеры автоматического приведения типов

Пример 1 . Автоматическое приведение целочисленных типов.

// автоматическое приведение целочисленных типов int a; byte b; short sh; b = -23; a = b; // a = -23 - автоматическое приведение типов sh = -150; a = sh; // a = -150 long l = 200; // Ошибка: "Type mismatch: cannot convert from long to int" // a = l; l = b; // l = -23 l = sh; // l = -150 char c = "Z" ; a = c; // a = 90 - код символа "Z" boolean b1 = false ; //a = b1; - ошибка, типы несовместимые

Пример 2 . Автоматическое приведение типов с плавающей запятой.

// автоматическое приведение типов с плавающей запятой float f; double d; f = 3.409033f; d = f; // d = 3.409033

Пример 3 . Автоматическое приведение смешанных типов. Такой случай возможен, если переменной типа с плавающей запятой присваивается значение переменной целочисленного типа.

// автоматическое приведение смешанных типов float f; double d; a = 28; d = a; // d = 28.0 f = a; // f = 28.0 // Ошибка: Type mismatch: cannot convert from float to int // a = f;

4. Как осуществляется автоматическое продвижение типов в выражениях?

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

При автоматическом продвижении типов в выражениях:

если один из целочисленных операндов имеет тип int, то все значения типов byte, short и char продвигаются к типу int;
если один из целочисленных операндов имеет тип long, то все выражение продвигается к типу long;
если один из операндов относится к типу float, то тип всего выражения будет также типа float (если нет операндов типа double);
если один из операндов относится к типу double, то тип всего выражения будет также double.

5. Пример продвижения из типа byte в int в котором выражение не содержит операндов-переменных типа int (long)

// byte -> int byte b; b = 1000 / 20; // b = 50, работает, так как результат помещается в тип byte

Вышеприведенный пример работает корректно, так как:

результат помещается (совместим) в тип byte;
нет операндов типа int.

В вышеприведенном примере значения 1000 превышает диапазон значений типа byte. Сначала число 1000 приводится к типу int. Но результат

1000 / 20 = 50

приводится к типу byte и может корректно поместиться в переменной b .

Если написать так:

byte b; b = 100000 / 20; // ошибка, так как результат не помещается в тип byte

то выйдет ошибка компиляции с выводом сообщения:

В этом случае результат не помещается в тип byte:

100000 / 20 = 5000

Тогда это число (5000) автоматически становится типом int и компилятор выдаст сообщение об ошибке.

Если сделать явное приведение типов:

byte b; b = (byte ) (100000 / 20); // b = -120

то в этом случае результат 5000 типа int превращается в тип byte. Как известно, переменная типа int занимает 32 бита, а переменная типа byte занимает 8 бит. Значение переменной типа int урезается. И имеем то, что имеем (b = -120 ).

Вышеприведенные примеры относятся и к переменным типов short и char.

6. Пример. Продвижение из типа byte в тип int, в котором выражение содержит операнд-переменную типа int

// продвижение типов в выражениях // byte -> int byte b; int d; d = 20; // ошибка, результат есть типом int, так как переменная d есть типа int // b = 1000 / d;

В вышеприведенном примере в выражении используется переменная d типа int . Поэтому компилятор выдаст сообщение об ошибке:

Type mismatch: cannot convert from int to byte

Это означает, что результат есть типа int (а не byte ) даже если значение помещается в диапазон значений типа byte. Поскольку в выражении используется переменная-операнд d типа int.

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

// продвижение типов в выражениях // byte -> int byte b; int d; d = 20; b = (byte )(1000 / d); // b = 50 - работает корректно

7. Пример. Продвижение из типа int в тип long

Пример продвижения типов из int в long. Если один из операндов есть типа long, то все выражение продвигается к типу long.

int d; long l; d = 10000 * 200; // работает, d = 2000000 // Ошибка! Type mismatch: cannot convert from long to int // d = 1L * 2L; - операнды 1L и 2L есть типа long l = 100; // ошибка, один из операндов есть типа long // d = l * 2;

Как видно из примера, если один из операндов есть типа long , то все выражение становится типа long .

Последнее обновление: 29.10.2018

Каждый базовый тип данных занимает определенное количество байт памяти. Это накладывает ограничение на операции, в которые вовлечены различные типы данных. Рассмотрим следующий пример:

Int a = 4; byte b = a; // ! Ошибка

В данном коде мы столкнемся с ошибкой. Хотя и тип byte, и тип int представляют целые числа. Более того значение переменной a, которое присваивается переменной типа byte, вполне укладывается в диапазон значений для типа byte (от -128 до 127). Тем не менее мы сталкиваемся с ошибкой на этапе компиляции. Поскольку в данном случае мы пытаемся присвоить некоторые данные, которые занимают 4 байта, переменной, которая занимет всего один байт.

Тем не менее в программе может потребоваться, чтобы подобное преобразование было выполнено. В этом случае мнеобходимо использовать операцию преобразования типов (операция ()):

Int a = 4; byte b = (byte)a; // преобразование типов: от типа int к типу byte System.out.println(b); // 4

Операция преобразования типов предполагает указание в скобках того типа, к которому надо преобразовать значение. Например, в случае операции (byte)a , идет преобразование данных типа int в тип byte. В итоге мы получим значение типа byte.

Явные и неявные преобразования

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

Автоматические преобразования

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

Автоматически без каких-либо проблем производятся расширяющие преобразования (widening) - они расширяют представление объекта в памяти. Например:

Byte b = 7; int d = b; // преобразование от byte к int

В данном случае значение типа byte, которое занимает в памяти 1 байт, расширяется до типа int, которое занимает 4 байта.

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

byte -> short -> int -> long

int -> double

short -> float -> double

char -> int

Автоматические преобразования с потерей точности

Некоторые преобразования могут производиться автоматически между типами данных одинаковой разрядности или даже от типа данных с большей разрядностью к типа с меньшей разрядностью. Это следующие цепочки преобразований: int -> float , long -> float и long -> double произволятся без ошибок, но при преобразовании мы можем столкнуться с потерей информации.

Например:

Int a = 2147483647; float b = a; // от типа int к типу float System.out.println(b); // 2.14748365E9

Явные преобразования

Во всех остальных преобразованиях примитивных типов явным образом применяется опрерация преобразования типов. Обычно это сужающие преобразования (narrowing) от типа с большей разрядностью к типу с меньшей разрядностью:

Long a = 4; int b = (int) a;

Потеря данных при преобразовании

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

Int a = 5; byte b = (byte) a; System.out.println(b); // 5

Число 5 вполне укладывается в диапазон значений типа byte, поэтому после преобразования переменная b будет равна 5. Но что будет в следующем случае:

Int a = 258; byte b = (byte) a; System.out.println(b); // 2

Результатом будет число 2. В данном случае число 258 вне диапазона для типа byte (от -128 до 127), поэтому произойдет усечение значения. Почему результатом будет именно число 2?

Число a, которое равно 258, в двоичном системе будет равно 00000000 00000000 00000001 00000010 . Значения типа byte занимают в памяти только 8 бит. Поэтому двоичное представление числа int усекается до 8 правых разрядов, то есть 00000010 , что в десятичной системе дает число 2.

Усечение рациональных чисел до целых

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

Double a = 56.9898; int b = (int)a;

Здесь значение числа b будет равно 56, несмотря на то, что число 57 было бы ближе к 56.9898. Чтобы избежать подобных казусов, надо применять функцию округления, которая есть в математической библиотеке Java:

Double a = 56.9898; int b = (int)Math.round(a);

Преобразования при операциях

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

если один из операндов операции относится к типу double , то и второй операнд преобразуется к типу double

если предыдущее условие не соблюдено, а один из операндов операции относится к типу float , то и второй операнд преобразуется к типу float

если предыдущие условия не соблюдены, один из операндов операции относится к типу long , то и второй операнд преобразуется к типу long

иначе все операнды операции преобразуются к типу int

Примеры преобразований:

Int a = 3; double b = 4.6; double c = a+b;

Так как в операции участвует значение типа double, то и другое значение приводится к типу double и сумма двух значений a+b будет представлять тип double.

Другой пример:

Byte a = 3; short b = 4; byte c = (byte)(a+b);

Две переменных типа byte и short (не double, float или long), поэтому при сложении они преобразуются к типу int , и их сумма a+b представляет значение типа int. Поэтому если затем мы присваиваем эту сумму переменной типа byte, то нам опять надо сделать преобразование типов к byte.

Если в операциях участвуют данные типа char, то они преобразуются в int:

Int d = "a" + 5; System.out.println(d); // 102

Каждое выражение в Java имеет тип, который определяется структурой выражения и типами составляющих его операндов (констант, переменных и методов). Однако, иногда нам может потребоваться явное преобразование выражения в другой тип. Кроме того, в некоторых ситуациях исполняющая система Java сама неявно проводит такие преобразования.

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

Преобразование типа int в тип long требует во время выполнения программы расширения знака 32-битового целого значения до 64-битового целого. Потери информации при этом не происходит.
Преобразование типа float в тип long требует во время выполнения программы нетривиального преобразования 32-битового плавающего значения в 64-битовое целое. В зависимости от исходного значения может произойти или не произойти потеря информации.
Преобразование типа Thread в тип Object не требует никаких действий: поскольку класс Thread является потомком класса Object , любая ссылка на объект типа Thread автоматически является ссылкой на объект типа Object .
Преобразование типа Object в тип Thread требует проверки в период исполнения. Если преобразуемая ссылка действительно является ссылкой на объект типа Thread , то она возвращается как результат преобразования, в противном случае генерируется исключение.

5.4.1.1. Расширяющие преобразования чисел

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

преобразования byte в short , int , long , float и double ;
преобразования short в int , long , float и double ;
преобразования char в int , long , float и double ;
преобразования int в long , float и double ;
преобразования long в float и double ;
преобразования float в double .

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

Class Test { public static void main(String args) { int bigNumber = 1234567890; float approximate = bigNumber; System.out.println(approximate); } }

выведет на экран строку 1234567936 . Это связано с тем, что при преобразовании int в float результирующее значение равно 1.2345679E9 из-за того, что мантисса чисел типа float вмещает только 8 десятичных цифр (здесь для правильной работы следует использовать преобразование к типу double ). Тем не менее, исполняющая система никогда не генерирует ошибок при выполнении перечисленных преобразований.

5.4.1.2. Сужающие преобразования чисел

Сужающие преобразования чисел это преобразования числового типа в "меньший" числовой тип, которые могут привести как к потере величины, так и к потере точности. Такими преобразованиями в Java являются:

преобразования byte в char ;
преобразования short в byte и char ;
преобразования int в byte , short и char ;
преобразования long в byte , short , int и char ;
преобразования float в byte , short , int , long и char ;
преобразования double в byte , short , int , long , float и char ;

Мы не будем здесь подробно рассматривать правила, по которым происходят эти преобразования, поскольку интуитивно они понятны, а формально достаточно громоздки. При их применении важно помнить, что Java, в отличие от других языков, не генерирует ошибок при переполнении (overflow) или потере значения (underflow), поэтому контроль за корректностью преобразований полностью ложится на программиста.

5.4.1.3. Расширяющие преобразования ссылок

Расширяющие преобразования ссылок это преобразования производных ссылочных типов в типы их предков, которые не требуют никаких действий на этапе исполнения и никогда не генерируют ошибок. Такими преобразованиями в Java являются:

преобразование любого класса или интерфейса в его предка (в частности, в тип Object);
преобразование класса в интерфейс, который он реализует;
преобразование любого массива в тип Object или тип Cloneable ;
преобразование массива типа S в массив типа T, если S и T ссылочные типы, и преобразование S в T является расширяющим;
преобразование нулевого типа в любой ссылочной тип.

5.4.1.4. Сужающие преобразования ссылок

Сужающие преобразования ссылок это преобразования производных ссылочных типов в типы их потомков. Эти преобразования требуют проверки своей легитимности на этапе исполнения и могут генерировать исключение ClassCastException . Такими преобразованиями в Java являются:

преобразование любого класса в его потомка (в частности, преобразование типа Object в любой другой класс);
преобразование класса в интерфейс, когда класс не является финальным и не реализует данный интерфейс (в частности, преобразование типа Object в любой интерфейс);
преобразование типа Object в любой массив;
преобразование любого интерфейса в класс, который не является финальным;
преобразование любого интерфейса в класс, который является финальным и реализует данный интерфейс;
преобразование интерфейса J в интерфейс K, когда J не является потомком K, и не существует метода, декларированного и в J, и в K с одинаковой сигнатурой, но разными типами результата;
преобразование массива типа S в массив типа T, если S и T ссылочные типы, и преобразование S в T является сужающим.

5.4.1.5. Преобразования в строки

Любое выражение в Java, включая null , может быть преобразовано в тип String .

5.4.1.6. Недопустимые преобразования

Следующие преобразования типов в Java запрещены:

преобразование любого ссылочного типа в любой примитивный тип;
преобразование любого примитивного типа в любой ссылочной тип, кроме типа String ;
преобразование нулевого типа в любой примитивный тип;
преобразования в нулевой тип или тип boolean ;
преобразования типа boolean в любой другой тип, кроме типа String ;
преобразование одного класса в другой, если ни один из них не является предком другого (кроме преобразования в тип String);
преобразование класса в интерфейс, если класс является финальным и не реализует данный интерфейс;
преобразование класса в массив, если класс отличен от Object ;
преобразование интерфейс в класс, который является финальным и не реализует данный интерфейс (кроме преобразования в тип String);
преобразование интерфейса J в интерфейс K, если существует метод, декларированный и в J, и в K с одинаковой сигнатурой, но разными типами результата;
преобразование массива в класс, отличный от Object и String ;
преобразование массива в интерфейс, отличный от Cloneable ;
преобразование массива типа S в массив типа T, если преобразование S в T является запрещенным

5.4.2. Контексты преобразований

5.4.2.1. Преобразование при присваивании

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

переменная имеет тип byte , short или char ;
значением выражения является константа типа int , которая попадает в диапазон возможных значений переменной.

Например, оператор byte x = 123; допустим, поскольку константа 123 (имеющая тип int ) лежит в диапазоне допустимых значений типа byte .

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

Short s = 123; char c = s; // генерирует ошибку компиляции

приведет к генерации ошибки, поскольку типы char и short несовместимы по присваиванию согласно данных выше определениям (первый реализован 16-битовыми словами без знака, а второй со знаком).

5.4.2.2. Преобразование аргументов метода

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

Class Test { static int m(byte a, int b) { return a + b; } static int m(short a, short b) { return a - b; } public static void main(String args) { System.out.println(m(1, 2) ); // генерирует ошибку компиляции } }

Здесь класс Test содержит два одноименных метода, которые различаются только типами параметров. Если бы сужающие преобразования аргументов были в Java разрешены, то исполняющей системе пришлось бы определять, к какому из этих методов относится вызов m(1, 2) . Чтобы избежать подобных двусмысленностей, разработчики языка решили проблему радикально: они запретили подобные вызовы методов. В данной ситуации для вызова, к примеру, первого метода мы должны явно указать тип первого операнда (второй по умолчанию уже имеет тип int ), а именно m((byte)1, 2) .

5.4.2.3. Преобразование в строку

Преобразование в строку происходит только в одном случае: когда бинарная операция + применяется к двум операндам, один из которых имеет тип String . В этой ситуации второй операнд также преобразуется к типу String , и результатом операции является конкатенация полученных строк. Подробнее этот процесс описан в гл. 5.14 .

5.4.2.4. Явное преобразование типа

Явное преобразование типа происходит, когда к операнду явно применяется операция приведения типа (type cast). В этой ситуации могут применяться все описанные выше виды преобразований типов, кроме преобразования в строку. Попытка явного преобразования к типу, отмеченная выше, как запрещенная, вызовет ошибку компиляции. Кроме того, на этапе выполнения возможна генерация исключения ClassCastException, если заданное преобразование недопустимо.

5.4.3. Преобразования типов числовых операндов

Преобразование типов в процессе вычисления числовых выражений имеет ряд особенностей. Они сводятся к двум случаям: преобразования операндов в унарных операциях и в бинарных операциях.

Перед выполнением унарной операции:

если операнд имеет тип byte , short или char , он преобразуется к типу int ;
в остальных случаях его тип не изменяется.

Перед выполнением бинарной операции:

если один из операндов типа double , то второй также преобразуется к типу double ;
float , то второй также преобразуется к типу float ;
в противном случае, если один из операндов типа long , то второй также преобразуется к типу long ;
в противном случае, оба операнда преобразуются к типу int .