Преобразование примитивных типов в 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 существует 2 типа преобразований - картинка Вам в помощь:

Напомним, что вся "Вселенная Java" состоит из:

• примитивных типов (byte, short, int, long, char, float, double, boolean)
• объектов

В данной статье мы:

• рассмотрим преобразование типов для примитивных типов переменных
• преобразование объектов (String, Scanner и др.) в этой статье не рассматривается, поскольку с объектами происходит отдельная «магия» - это тема для отдельной статьи.

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

Ну, что ж, давайте попробуем разобраться что такое "автоматическое преобразование".

Помните, когда мы рассматривали типы переменных (в статье ), мы говорили, что переменная - это некоторый «контейнер» , в котором может храниться значение для дальнейшего использования в программе. Также мы говорили о том, что каждый тип переменной имеет свой диапазон допустимых значений и объем занимаемой памяти. Вот она табличка, где это все было расписано:

Так вот, к чему мы, собственно говоря, клоним. К тому, что совсем не просто так Вам давались диапазоны допустимых значений и объем занимаемой памяти 🙂

Давайте, сравним, например:

1. byte и short. byte имеет меньший диапазон допустимых значений, чем short. То есть byte это как бы коробочка поменьше, а short - это коробочка побольше. И значит, мы можем byte вложить в short.

2. byte и int . byte имеет меньший диапазон допустимых значений, чем int. То есть byte это как бы коробочка поменьше, а int - это коробочка побольше. И значит, мы можем byte вложить в int.

3. int и long. int имеет меньший диапазон допустимых значений, чем long. То есть int это как бы коробочка поменьше, а long - это коробочка побольше. И значит, мы можем int вложить в long.

Это и есть пример автоматического преобразования. Это можно схематически изобразить в виде вот такой картинки:

Давайте рассмотрим как это работает на практике.

Пример №1

Код №1 - если Вы запустите это код на своем компьютере,

class Test { public static void main(String args) { byte a = 15; byte b = a; System.out.println(b); } }

class Test { byte a = 15 ; byte b = a ;

Код №2 - если Вы запустите это код на своем компьютере, в консоли будет выведено число 15

class Test { public static void main(String args) { byte a = 15; int b = a; System.out.println(b); } }

class Test { public static void main (String args ) { byte a = 15 ; int b = a ; System . out . println (b ) ;

И-и-и? Вы думаете, что раз в консоль было выведено одно и то же число, и код №1 отличается от кода №2 всего лишь типом переменной b, то между ними нет никакой разницы? Э то не так.

В коде №2 присутствует автоматическое преобразование типов , а в коде №1 - нет:

Хотя число, в принципе, одно и то же, но теперь оно находится в бо льшем контейнере, который занимает больше места на диске. При этом, JVM выполняет автоматические преобразования за Вас. Она знает, что int больше чем byte .

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

Другое дело если вы пытаетесь переложить что-то из большего контейнера в более маленький.

Вы можете знать, что в большем контейнере лежит то, что поместиться и в маленьком – но об этом не знает JVM, и пытается предохранить вас от ошибок.

Поэтому, вы должны «прямо сказать», что ситуация под контролем:

class Test { public static void main(String args) { int a=0; long b=15; a = (int) b; } }

class Test { public static void main (String args ) { int a = 0 ; long b = 15 ; a = (int ) b ;

Тут мы дописали (int) перед b . Если бы переменная a была, к примеру, типа byte , в скобках бы стояло (byte) . Общая формула выглядит так:

Она говорит "сделай из (большего) значения b переменную нужного мне (целевого) типа int ".

Если что-то пошло не так.

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

Оказывается, в контейнере останется лишь то, что туда «влезло». К примеру, у чисел с плавающей точкой будет «отсекаться» дробная часть:

//пример 1 class Test { public static void main(String args) { double a=11.2345; int b=(int)a; System.out.println(b); // в консоли получится число 11 } }

//пример 1 class Test { public static void main (String args ) { double a = 11.2345 ; int b = (int ) a ; System . out . println (b ) ; // в консоли получится число 11

Надо помнить, что дробная часть не округляется , а отбрасывается .

А что будет, если мы попытаемся поместить число, которое выходит за допустимые границы? Например, если в byte (диапазон byte от -128 до 127) положить число 128? Думаете, мы получим 1? Нет. Мы получим -128:

class Test { public static void main(String args) { double a=128; byte b=(byte)a; System.out.println(b); //в консоли увидим -128 } }

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

Задания:

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

	byte	short	char	int	long	float	double	boolean
byte
short
char
int
Long
Float
double
boolean

На пересечении напишите: а – если преобразование происходит автоматически, на – если нужно использовать явное преобразование, х – если преобразование невозможно.

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

1. Посмотрите еще раз, какой размер имеет каждый примитивный тип. Попытайтесь составить блок-схему, показывающую, куда помещаются какие типы. Проведите стрелочки с надписью «расширяющее преобразование» и «сужающее преобразование».

Вопросы

На собеседовании на должность Junior Java Developer Вас могут спросить:

Что Вы знаете о преобразовании примитивных типов данных, есть ли потеря данных, можно ли преобразовать логический тип?

Попробуйте ответить на вопрос.

Подытожим:

• Если Вы "кладёте" в больший контейнер содержимое меньшего контейнера», преобразование происходит автоматически, и ошибок возникать не должно.

• Если есть необходимость положить «значение из большего контейнера в меньший», нужно быть осторожным, и пользоваться явным приведением типов.

• При приведении float или double к целочисленным типам, дробная часть не округляется, а просто отбрасывается.
• Тип boolean не приводится ни к одному из типов.
• Тип char приводится к числовым типам, как код символа в системе UNICODE.
• Если число больше своего контейнера, результат будет непредсказуемым.

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

Надеемся, что наша статья была Вам полезна. Также есть возможность записаться на наши курсы по Java в Киеве. Обучаем с нуля. Детальную информацию Вы можете найти у нас на .

Мы закончили нашу прошлую статью о на том, что я пообещал Вам рассказать, какие типы можно приводить и как это все делается. Давайте же приступим.

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

byte->short->int->long->float->double

Если операнды a и b комбинируются бинарным оператором (ниже мы это обсудим), перед его исполнением оба операнда преобразуются в данные одного типа следующим образом:

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

Разрешенные преобразования типов

Сплошные линии показывают преобразование, выполненное без потери информации. Это преобразование выполняется неявно. Преобразования, когда может произойти потеря информации, называются каст (casting). Они показанные штриховыми линиями. Если к типу данных на рисунке нет линий, то такое преобразование невозможно. Преобразования с потерей информации нужно проводить очень внимательно. Так, как можно потерять значительную часть данных и при этом программа может работать правильно.

Для сужения каст необходимо сделать явным. Например: byte b = (byte)128; прикастили инт к байт типу.

Предлагаю сделать несколько примеров.

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

• Имена переменных не могут начинаться с цифры, в именах не могут использоваться как символы арифметических и логических операторов, а также символ ‘#’.
• Применение символов ‘$’ или ‘_’ приемлемо, включая первую позицию и имя.
• Переменная примитивного типа, объявленная как член класса (глобальная переменная), по умолчанию задается нулем.
• Если переменная объявлена как локальная переменная в методе, перед использованием она должна обязательно быть проинициализирована. Так как локальные переменные не изициализируются по умолчанию. Это значит, что Вы не можете объявить локальную переменную и оставить ее без инициализации. То есть вот так: int i;. Если Вы так сделаете в методе, компилятор попросит Вас задать значение по умолчанию в то время, как создав такую переменную как член класса (глобальную) компилятор сам задаст ей значение 0.
• Область действия и время жизни переменной ограничено блоком {}, в котором она объявлена. Если Вы создали переменную внутри метода (как мы это делали в примерах), то Вы не сможете использовать ее вне метода, так как метод ограничен скобками {}. Глобальную переменную видно во всех блоках.
• Также запрещено использовать зарезервированные слова java. Весь перечень ключевых слов можно увидеть на картинке ниже.

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

Java имеет несколько типов операторов: простое присваивание, арифметическое, унарное, равноправное и реляционное, условное, сравнение типов, побитовое и битовое смещение.

Много умных слов, но очень просто все объяснит вот эта картинка:

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

public class OperatorsInJava {

int a = 5 ;

int b = 6 ;

int sum = a + b;

int difference = a - b;

Каждое выражение в 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 .

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 .