» Язык
java
» Главная
страница
» Вернуться
к содержанию
Автоматическое
преобразование типов в выражениях
Когда
вы вычисляете значение выражения,
точность, требуемая для хранения
промежуточных результатов, зачастую
должна быть выше, чем требуется
для представления окончательного
результата.
byte
a = 40;
byte
b = 50;
byte
с = 100;
int
d = a* b / с;
Результат
промежуточного выражения (а*
b) вполне может выйти за диапазон
допустимых для типа byte значений.
Именно поэтому Java автоматически
повышает тип каждой части выражения
до типа int, так что для промежуточного
результата (а* b) хватает места.
Автоматическое
преобразование типа иногда может
оказаться причиной неожиданных
сообщений транслятора об ошибках.
Например, показанный ниже код,
хотя и выглядит вполне корректным,
приводит к сообщению об ошибке
на фазе трансляции. В нем мы
пытаемся записать значение 50*
2, которое должно прекрасно
уместиться в тип byte, в байтовую
переменную. Но из-за автоматического
преобразования типа результата
в int мы получаем сообщение
об ошибке от транслятора — ведь
при занесении int в byte может
произойти потеря точности.
byte
b = 50;
b
= b* 2;
^
Incompatible type for =. Explicit
cast needed to convert int to
byte.
(Несовместимый
тип для =. Необходимо явное
преобразование int в byte)
Исправленный
текст:
byte
b = 50;
b
= (byte) (b* 2);
что
приводит к занесению в b правильного
значения 100.
Если
в выражении используются переменные
типов byte, short и int, то
во избежание переполнения тип
всего выражения автоматически
повышается до int. Если же в
выражении тип хотя бы одной
переменной — long, то и тип
всего выражения тоже повышается
до long. He забывайте, что все
целые литералы, в конце которых
не стоит символ L (или 1), имеют
тип int.
Если
выражение содержит операнды
типа float, то и тип всего выражения
автоматически повышается до
float. Если же хотя бы один
из операндов имеет тип double,
то тип всего выражения повышается
до double. По умолчанию Java
рассматривает все литералы с
плавающей точкой, как имеющие
тип double. Приведенная ниже
программа показывает, как повышается
тип каждой величины в выражении
для достижения соответствия
со вторым операндом каждого
бинарного оператора.
class
Promote {
public
static void main (String args
[]) { byte b = 42;
char
с = 'a';
short
s = 1024;
int
i = 50000;
float
f = 5.67f;
double
d =.1234;
double
result = (f* b) + (i/ c) - (d*
s);
System.
out. println ((f* b)+ "+
"+ (i / с)+ " - "
+ (d* s));
System.
out. println ("result =
"+ result);
}
}
Подвыражение
f* b — это число типа float,
умноженное на число типа byte.
Поэтому его тип автоматически
повышается до float. Тип следующего
подвыражения i/с (int, деленный
на char) повышается до int.
Аналогично этому тип подвыражения
d*s (double, умноженный на short)
повышается до double. На следующем
шаге вычислений мы имеем дело
с тремя промежуточными результатами
типов float, int и double. Сначала
при сложении первых двух тип
int повышается до float и получается
результат типа float. При вычитании
из него значения типа double
тип результата повышается до
double. Окончательный результат
всего выражения — значение типа
double.
Следующий
урок
|