✅ Преобразование типов в Java - Типы, такие как явные и неявные, примеры

Введение в преобразование типов в Java

Введение в преобразование типов в Java

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

Преобразование типов

Есть 2 различных типа преобразования, которые мы используем в языках программирования.

1. Неявное преобразование типов

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

float i=0; int j=10; i=j;

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

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

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

float k=123.456 int i= (int) k

// это может быть явное преобразование, так же как, (int) является typecast, operator. На этом этапе нам, возможно, удастся избежать исключения, но вы можете обнаружить видимую потерю данных. т.е. я = 123

// .456 можно удалить в процессе конвертации

Преобразование типов в Java

Как и в других языках программирования, в Java есть 2 типа конвертации:

Неявное преобразование типов

Обычно это то, что мы называем расширением преобразования, и это можно сделать автоматически, потому что мы переходим к более широким типам данных. Так что, если у нас есть 32-разрядное целое число, и мы хотим перейти к 64-разрядному целому числу, это шире. Таким образом, значение может быть безопасно перемещено, так что это может быть сделано неявно. И компилятор должен принять решение о том, как сделать эти преобразования, и правила довольно просты.
Если у нас есть выражение с несколькими (смешанными) целочисленными размерами, если у нас есть короткое и длинное, какой бы ни был наибольший целочисленный размер, к чему его будут преобразовывать. Так что, если мы сделаем операцию с коротким и длинным, короткое будет неявно приведено в.
Если мы выполним операцию со смешанными размерами с плавающей запятой, поэтому у нас есть числа с плавающей запятой и двойное число, они всегда будут переходить к двойному, потому что двойное число является наибольшим размером с плавающей запятой.
И затем, если у нас есть операция, которая использует смешанные целочисленные типы и типы с плавающей запятой, компилятор приведёт к любой наибольшей с плавающей запятой в уравнении. Поэтому, если мы сделаем операцию с длинным и на плаву, длинный будет брошен на плаву.
Если мы сделаем операцию с длинным и двойным, то длинный будет приведен к двойному.

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

Мы явно выполняем в нашем коде при использовании этой операции приведения. Когда мы делаем это, мы берем на себя ответственность за все, что происходит в результате такого типа обращения. Из-за этого мы можем выполнять как расширенное преобразование, так и узкое. Столь расширяется от 32-битных, скажем, до 64-битных, сужается от 64-битных до 32-битных. Нам просто нужно знать, что мы знаем, что может произойти.
Если мы выполняем явное приведение из числа с плавающей запятой к целому числу, поэтому числа с плавающей запятой могут иметь дробную часть, целое число не может, поэтому любая дробная часть будет отброшена, когда мы приведем это число к целому числу.
Вы хотите быть осторожным при выполнении сужающего преобразования. Если у нас есть 64-разрядное целое число, оно может содержать слишком большие значения, чтобы поместиться в 32-разрядное целое число.
Поэтому, если мы приведем это 64-разрядное к 32-разрядному, программа фактически сделает это, но если значение слишком велико, чтобы поместиться в 32-разрядное, вы получите некоторые странные результаты из этого. Таким образом, вы хотите быть уверенными, что когда вы применяете заклинание, выполняющее сужающий состав, вы знаете, что то, что вы делаете, безопасно.
И последнее, вы просто должны быть осторожны при преобразовании целого числа в число с плавающей запятой, потому что, если у вас есть целое число с большим количеством значащих цифр, из-за способа хранения числа с плавающей запятой вы можете потерять часть эти значимые цифры.

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

Примеры преобразования типов упомянуты ниже подробно:

Код:

Здесь у нас есть простая программа, некоторое объявление вверху, float, double, byte, short и long, и каждая из переменных названа так, чтобы помочь определить, что их типы похожи на float is floatVal,

Код:

long is longVal

Код:

И программа просто выводит сообщение об успехе, если оно запускается.

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

На самом деле, давайте продолжим и назовем это result1. И давайте просто сделаем простое задание. И поэтому сначала мы просто назначим ему byteVal. Теперь, как мы ожидаем, если мы пойдем дальше и запустим это, так что запустите успешно.

Код:

Выход:

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

Если мы возьмем этот byteVal и сделаем вместо него longVal, то теперь он на самом деле long, если мы его запустим, мы получим здесь сообщение об ошибке с сообщением о несовместимом типе, возможной потере преобразования из длинного в короткое.

Код:

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

Код:

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

Выход:

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

Код:

Выход:

Итак, теперь давайте посмотрим на другой сценарий. Мы собираемся создать еще одну переменную, которую мы назовем result2 , и result2 также будет коротким. И то, что мы хотим сделать здесь, - это просто взять наш byteVal, и мы хотим вычесть longVal. Теперь мы знаем, что это недопустимо, потому что результатом выражения будет размер наибольшего целого числа в нем, то есть длины.

Код:

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

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

Поместите короткий бросок перед этим здесь. И обернуть все это в скобках. И запустить его.

Код:

Это будет успешно работать.

Выход:

Теперь объявите другую переменную с именем result3, но объявите ее как long. Итак, мы получили результат 3, и что мы будем здесь делать, мы назначим это longVal - floatVal. Таким образом, мы запускаем это, ошибка теряется при преобразовании, преобразовывающем из числа с плавающей точкой в длинное, потому что всякий раз, когда у нас есть целочисленный тип и любой тип с плавающей запятой, результатом будет тип с плавающей запятой.

Код:

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

Код:

Выход:

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

Код:

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

Код:

Выход:

Вывод

1. Переменные строго типизированы в Java
2. Примитивные типы

Целочисленные типы, типы с плавающей точкой, тип char, логический тип

3. Тип преобразования

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

Преобразование типов в Java - Типы, такие как явные и неявные, примеры