Приведение типов double в int java. Преобразование типов в Java

Иногда возникают ситуации, когда у вас есть величина какого-то определенного типа, а вам нужно ее присвоить переменной другого типа. Для некоторых типов это можно проделать и без приведения типа, в таких случаях говорят об автоматическом преобразовании типов. В Java автоматическое преобразование возможно только в том случае, когда точности представления чисел переменной-приемника достаточно для хранения исходного значения. Такое преобразование происходит, например, при занесении литеральной константы или значения переменной типа byte или short в переменную типа int. Это называется расширением (widening ) или повышением (promotion ), поскольку тип меньшей разрядности расширяется (повышается) до большего совместимого типа. Размера типа int всегда достаточно для хранения чисел из диапазона, допустимого для типа byte, поэтому в подобных ситуациях оператора явного приведения типа не требуется. Обратное в большинстве случаев неверно, поэтому для занесения значения типа int в переменную типа byte необходимо использовать оператор приведения типа. Эту процедуру иногда называют сужением (narrowing ), поскольку вы явно сообщаете транслятору, что величину необходимо преобразовать, чтобы она уместилась в переменную нужного вам типа. Для приведения величины к определенному типу перед ней нужно указать этот тип, заключенный в круглые скобки. В приведенном ниже фрагменте кода демонстрируется приведение типа источника (переменной типа int) к типу приемника (переменной типа byte). Если бы при такой операции целое значение выходило за границы допустимого для типа byte диапазона, оно было бы уменьшено путем деления по модулю на допустимый для byte диапазон (результат деления по модулю на число - это остаток от деления на это число),

int а = 100;
byte b = (byte) а;

2.2.1. Автоматическое преобразование типов в выражениях

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

byte а = 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. Не забывайте, что все целые литералы, в конце которых не стоит символ L (или 1), имеют тип int.

Если выражение содержит операнды типа float, то и тип всего выражения автоматически повышается до float. Если же хотя бы один из операндов имеет тип double, то тип всего выражения повышается до double. По умолчанию Java рассматривает все литералы с плавающей точкой как имеющие тип double. Приведенная ниже про1рамма показывает, как повышается тип каждой величины в выражении для достижения соответствия со вторым операндом каждого бинарного оператора.

class Promote {
public static void main (String args ) {
byte b= 42;
char с = "a’;
shorts = 1024;
int i = 50000;
float f = 5.67f;
doubled =.1234;
double result = (f*b) + (i/ c) - (d* s);
System, out. println ((f* b)+ "+ "+ (i / c)+ " -" + (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.

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

class SimpleTypes {
public static void main(String args ) {
byte b = 0x55;
short s = 0x55ff;
int i = 1000000;
long l = 0xffffffffL;
char с = ’a’;
float f= .25f;
double d = .00001234;
boolean bool = true;
System.out.println("byte b = " + b);
System.out.println("short s = " +s);
System.out.println("int i =” + i);
System.out.println("long 1 = " + l);
System.out.println("char с =” + с );
System.out.println("float f = " + f);
System.out.println("double d = " + d);
System.out.println("boolean bool =” + bool); }
}

Запустив эту программу, вы должны получить результат, показанный ниже:

byte b = 85
shorts = 22015
int i = 1000000
long 1 = 4294967295
char с = a
float f = 0.25
double d=1.234e-005
boolean bool = true

Обратите внимание на то, что целые числа печатаются в десятичном представлении, хотя мы задавали значения некоторых из них в шестнадцатиричном формате.

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

• Тождественное (identity);


• Расширение примитивного типа (widening primitive);


• Сужение примитивного типа (narrowing primitive);


• Расширение объектного типа (widening reference);


• Сужение объектного типа (narrowing reference);


• Преобразование к строке (String);


• Запрещенные преобразования (forbidden);

Рассмотрим их по отдельности.
Тождественное преобразование
Самым простым является тождественное преобразование. В Java преобразование выражения любого типа к точно такому же типу всегда допустимо и успешно выполняется.
Это важно для возможности утверждать с теоретической точки зрения, что любой тип в Java может участвовать в преобразовании, хотя бы в тождественном.
Преобразование примитивных типов (расширение и сужение)
Для простых типов расширение означает, что осуществляется переход от менее емкого типа к более ёмкому. Например, от типа byte (длина 1 байт) к типу int (длина 4 байта). Такие преобразование безопасны в том смысле, что новый тип всегда гарантировано вмещает в себя все данные, которые хранились в старом типе, и таким образом не происходит потери данных. Именно поэтому компилятор осуществляет его сам, незаметно для разработчика:

byte b=3;
int a=b;

Следующие 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; // () это как раз и есть операция преобразования типа
System.out.println(a); //результат 111111110656

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

• От 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

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

System.out.println((byte)383);
System.out.println((byte)384);
System.out.println((byte)-384);

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

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

char c=4000;
System.out.println((short)c);

Результат:

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

class Parent {
int x;
}

class ChildY extends Parent {
int y;
}

class ChildZ extends Parent {
int z;
}

В каждом классе объявлено поле с уникальным именем. Будем рассматривать это поле как пример набора уникальных свойств, присущи некоторому объектному типу.
Объекты класса Parent обладают только одним полем x, а значит, только ссылки типа Parent могут ссылаться на такие объекты. Объекты класса ChildY обладают полем y и полем x, полученным по наследству от класса Parent. Стало быть, на такие объекты могут указывать ссылки типа ChildY или Parent. Пример:

Parent p = new ChildY();

Обратите внимание, что с помощью такой ссылки p можно обращаться лишь к полю x созданного объекта. Поле y недоступно, так как компилятор, проверяя корректность выражения p.y, не может предугадать, что ссылка p будет указывать на объект типа ChildY во время исполнения программы. Он анализирует лишь тип самой переменной, а она объявлена как Parent, но в этом классе нет поля y, что и вызовет ошибку компиляции.
Аналогично, объекты класса ChildZ обладают полем z и полем x, полученным по наследству от класса Parent. Значит, на такие объекты могут указывать ссылки типа ChildZ и Parent.
Таким образом, ссылки типа Parent могут указать на объект любого из трех рассматриваемых типов, а ссылки типа ChildY и ChildZ – только на объекты точно такого же типа. Теперь можно перейти к преобразования ссылочных типов на основе такого дерева наследования.
Расширение означает переход от более конкретного типа к менее конкретному, т.е. переход от детей к родителям. Подобно случаю с примитивными типами, этот переход производиться самой JVM при необходимости и «незаметен» для разработчика, то есть не требует никаких специальных преобразования.

Parent p1=new ChildY();
Parent p2=new ChildZ();

В обеих строках переменным типа Parent присваивается значение другого типа, а значит, происходит преобразование. Поскольку это расширение, оно производиться автоматически и всегда успешно.
Нужно заметить, что при подобном преобразовании с самим объектом ничего не происходит. Несмотря на то что, например, поле y класса ChildY теперь недоступно, это не значит, что оно исчезло. Такое существенно изменение объекта не возможно. Он был порожден от класса ChildY и сохраняет все его свойства. Изменился лишь тип ссылки, через которую идет обращение к объекту.
Обратный переход, то есть движение по дереву наследования вниз, к наследникам, является сужением. Например, для рассматриваемого случая, переход от ссылки типа Parent , которая может ссылаться на объекты трех классов, к ссылке типа ChildY, которая может ссылаться только на один класс из трех, очевидно, является сужением. Такой переход может оказаться невозможным. Если ссылка типа Parent ссылается на объект типа Parent или ChildZ, то переход к ChildY невозможен, так как в обоих случаях объект не обладает полем y, которое объявлено в классе ChildY. Поэтому при сужении разработчику необходимо явным образом указывать на то, что необходимо попытаться провести такое преобразование. JVM во время исполнения проверит корректность перехода. Если он возможен, преобразование будет проведено. Если же нет – возникнет ошибка (обычно ClassCastException).

Parent p=new ChildY();
ChildY cy = (ChildY)p; //верно
Parent p2=new ChildZ();
ChildY cy2 = (ChildY)p2; //ошибка

Чтобы проверить, возможен ли желаемый переход, можно воспользоваться оператором instanceof:

Parent p=new ChildY();
if (p instanceof ChildY) {
ChildY cy = (ChildY)p;
}

Parent p2=new ChildZ();
if (p2 instanceof ChildY) {
ChildY cy = (ChildY)p2;
}

Parent p3=new Parent();
if (p3 instanceof ChildY) {
ChildY cy = (ChildY)p3;
}

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

• Числовые типы записываются в текстовом виде без потери точности представления. Сначала на основе примитивного значения порождается экземпляр соответствующего класса-«обертки», затем у него вызывается метод toString(). Но поскольку эти действия снаружи незаметны, JVM оптимизирует их и преобразует примитивные значения в текст напрямую.


• Булевские величины приводятся к строке «true» или «false» в зависимости от значения.


• Для объектных величин вызывается метод toString(). Если метод возвращает null, то результатом будет строка “null”.


• Для null-значения генерируется строка “null”.

Запрещенные преобразования
Не все переходы между произвольными типами допустимы. Например, к запрещенным преобразованиям относятся: переходы от любого ссылочного типа к примитивному и наоборот (кроме преобразования к строке), boolean можно привести только к этому типу или же к строке. Кроме того невозможно привести друг к другу, классы находящиеся на соседних ветвях дерева наследования. В примере, который рассматривался для иллюстрации ссылочных типов, переход от ChildY к ChildZ запрещен.
Этим список запрещенных преобразований не исчерпывается. Он довольно широк и в тоже время все варианты достаточно очевидны, поэтому подробно рассматриваться не будут. Желающие могут получить полную информацию из спецификации.
Разумеется, попытка осуществить запрещенное преобразование вызовет ошибку.

Применение приведений
Ситуации применения преобразования типов могут быть сгруппированы следующим образом:

• Присвоение значений переменным (assignment). Не все переходы допустимы при таком преобразовании – ограничения выбраны таким образом, чтобы не могла возникнуть исключительная ситуация.


• Вызов метода. Это преобразование применяется к аргументам вызываемого метода или конструктора. Такое приведение никогда не порождает ошибок. Так же приведение осуществляется при возвращении значения метода.


• Явное приведение. В этом случае явно указывается, к какому типу требуется привести исходное значение.


• Оператор конкатенации производит преобразование к строке своих аргументов.


• Числовое расширение. Числовые операции могут потребовать изменения типа аргумента(ов). Это преобразование имеет особое название – расширенное, так как выбор целевого типа может зависеть не только от исходного значения, но и от второго аргумента операции.

Задание #8
Добавить в проект использование приведения для иерархии ваших классов.

Иногда возникают ситуации, когда необходимо переменной одного типа присвоить значение переменной другого типа. Например:

Пример 1. Присвоение значения переменной одного типа другому

int i = 11; byte b = 22; i = b;

В Java существует 2 типа преобразований - автоматическое преобразование (неявное) и приведение типов (явное преобразование) .

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

Рассмотрим сначала автоматическое преобразование. Если оба типа совместимы, их преобразование будет выполнено в Java автоматически. Например, значение типа byte всегда можно присвоить переменной типа int , как это показано в примере 1.

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

• оба типа должны быть совместимы
• длина целевого типа должна быть больше длины исходного типа

В этом случае происходит преобразование с расширением .

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

Сплошные линии обозначают преобразования, выполняемые без потери данных. Штриховые линии говорят о том, что при преобразовании может произойти потеря точности.

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

Стоит немного пояснить почему, к примеру тип byte не преобразуется автоматически (не явно) в тип char , хотя тип byte имеет ширину 8 бит, а char - 16, тоже самое касается и преобразования типа short в char . Это происходит потому, что byte и short знаковые типы данных, а char без знаковый. Поэтому в данном случае требуется использовать явное приведение типов, поскольку компилятору надо явно указать что вы знаете чего хотите и как будет обрабатываться знаковый бит типов byte и short при преобразовании к типу char .

Поведение величины типа char в большинстве случаев совпадает с поведением величины целого типа, следовательно, значение типа char можно использовать везде, где требуются значения int или long . Однако напомним, что тип char не имеет знака, поэтому он ведет себя отлично от типа short , несмотря на то что диапазон обоих типов равен 16 бит.

2. Приведение типов

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

Чтобы выполнить преобразование двух несовместимых типов данных, нужно воспользоваться приведением типов. Приведение - это всего лишь явное преобразование типов. Общая форма приведения типов имеет следующий вид:

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

где параметр целевой_тип обозначает тип, в который нужно преобразовать указанное значение.

Пример 2. Приведение типов

Например, в следующем фрагменте кода тип int приводится к типу byte :

Int i = 11; byte b = 22; b = (byte) i;

Пример 3. Преобразования значений с плавающей точкой в целые числа

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

Double d = 3.89; int a = (int) d; //Результат будет 3

Пример 4. Преобразования более емкого целого типа к менее емкому целому числу

При приведении более емкого целого типа к менее емкому старшие биты просто отбрасываются:

Int i = 323; byte b = (byte) i; //Результат будет 67

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

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

Double d = 389889877779.89; short s = (short) d; //Результат будет -1

3. Автоматическое продвижение типов в выражениях

Помимо операций присваивания, определенное преобразование типов может выполняться и в выражениях.

В языке Java действуют следующие правила:

1. Если один операнд имеет тип double double .
2. float , другой тоже преобразуется к типу float .
3. Иначе, если один операнд имеет тип long , другой тоже преобразуется к типу long .
4. Иначе оба операнда преобразуются к типу int .
5. В выражениях совмещенного присваивания (+=,-=,*=,/=) нет необходимости делать приведение.

Приведем пример:

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

При умножении переменной b1 (byte ) на 2 (int ) результат будет типа int . Поэтому при попытке присвоить результат в переменную b2 (byte ) возникнет ошибка компиляции. Но при использовании совмещенной операции присваивания (*=), такой проблемы не возникнет.

Byte b1 = 1; byte b2 = 2 * b1; //Ошибка компиляции int i1 = 2 * b1; b2 *= 2;

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

В следующем примере тоже возникнет ошибка компиляции - несмотря на то, что складываются числа типа byte , результатом операции будет тип int, а не short.

Public class IntegerDemo1 { public static void main(String args) { byte b1 = 50, b2 = -99; short k = b1 + b2; //ошибка компиляции System.out.println("k=" + k); } }

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

Этот пример аналогичен предыдущему, но используется операция совмещенного присваивание, в которой приведение происходит автоматически.

Public class IntegerDemo2 { public static void main(String args) { byte b1 = 50, b2 = -99; b1 += b2; System.out.println("b1=" + b1); } }

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 .