Преобразования и продвижение в Java

В этой статье мы обсудим примитивное преобразование.

· Преобразование типов
∘ Неявное преобразование типов
∘ Явное преобразование типов
· Автоматическое преобразование типов в выражениях
· Разница между приведением типов и приведение типов

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

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

Java предоставляет различные типы данных, как и любые другие динамические языки, такие как boolean, char, int, unsigned int, signed int, float, double, long и т. д., всего 7 типов, где каждый тип данных занимает разное пространство при сохранении в памяти.

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

Если у вас есть предыдущий опыт программирования, то вы уже знаете, что довольно часто значение одного типа присваивается переменной другого типа. Если два типа совместимы, Java выполнит преобразование автоматически. (преобразование типа). Например, всегда можно присвоить значение int длинной переменной. Однако не все типы совместимы, и поэтому не все преобразования типов разрешены неявно. Например, не определено автоматическое преобразование из double в byte. К счастью, по-прежнему можно получить преобразование между несовместимыми типами. Для этого необходимо использовать приведение, которое выполняет явное преобразование между несовместимыми типами. Рассмотрим как автоматическое или расширяющее преобразование типов (приведение типов, жонглирование типами), так и сужающее или явное преобразование (приведение типов).

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

В C и C++ преобразование типов может вызвать некоторые головные боли. В Java преобразование безопасно, за исключением того, что когда вы выполняете так называемое сужающее преобразование (то есть когда вы переходите от типа данных, который может содержать больше информации, к типу, который не содержит столько же), вы запускаете риск потери информации. Здесь компилятор заставляет вас использовать приведение (приведение типов), фактически говоря: «Это может быть опасным — если вы все равно хотите, чтобы я это сделал, вы должны сделать преобразование >явно». При расширяющем преобразовании приведение (явное приведение) не требуется, поскольку новый тип будет более чем содержать информацию из старого типа, так что никакая информация никогда не будет потеряна. Java позволяет преобразовывать любой примитивный тип в любой другой примитивный тип, кроме логического, который вообще не допускает приведения. Типы классов не допускают кастинга. Чтобы преобразовать одно в другое, должны быть специальные методы. (…)

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

Также известен как «автоматическое преобразование или преобразование типов».

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

bool -> char -> short int -> int -> 

unsigned int -> long -> unsigned -> 

long long -> float -> double -> long double

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

• Оба типа совместимы. Например, такие типы данных, как числовые, совместимы с другими числовыми типами данных, но несовместимы с данными boolean, char или String. типы. Точно так же, как String несовместим с типом данных boolean.
• Тип назначения больше, чем тип источника.

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

При неявных преобразованиях возможна потеря информации, могут быть потеряны знаки (когда signed неявно преобразуется в unsigned) и может произойти переполнение (когда long long неявно преобразуется в float).

иногда мы называем этот тип преобразования типом преобразования.

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

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

Пример Type Ceorcion —

int x=30;
float y;
y=x;  // y==30.000000.

На следующем рисунке показаны преобразования типов между числовыми типами данных Java.

Java автоматически принуждает данные в направлении стрелок, сплошных или пунктирных. Например:

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

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

Давайте рассмотрим пример неявного приведения типов в Java.

Здесь мы преобразуем значение int в значение long и, наконец, в значение double с помощью простого оператора присваивания:

public class Main {
  public static void main(String[] args) {
    int a = 20;
    long b = a;     //implicit casting from int to long data type
    double c = b; 
    System.out.println(a);
    System.out.println(b);
    System.out.println(c);
  }
}  // implicit casting from long to double data type

Выход:

20
20
20.0

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

Другими словами, «преобразование типа» относится к общему процессу изменения типа, тогда как приведение типа относится более конкретно к неявному преобразованию типа. Далее мы можем разделить приведение типов на два вида — контролируемые программистом и контролируемые компилятором (иногда называемые жонглированием).

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

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

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

Чтобы создать преобразование между двумя несовместимыми типами, необходимо использовать приведение типов. Приведение — это просто явное преобразование типа.

В Java это можно сделать с помощью оператора приведения ():

Это делается путем явного определения требуемого типа перед выражением в скобках.

Он имеет такой общий вид:

(target-type) expression

где target-type указывает тип данных, в который преобразуется окончательный результат.

Здесь target-type указывает желаемый тип, в который нужно преобразовать указанное значение. Например, следующий фрагмент преобразует int в byte. Если целочисленное значение превышает диапазон байтов, оно будет уменьшено по модулю (остаток от деления целого числа на) диапазона байтов.

int a; 
byte b; // … 
b = (byte) a;

Другой тип преобразования будет происходить, когда значение с плавающей запятой назначается целочисленному типу: усечение. Как известно, целые числа не имеют дробных частей. Таким образом, когда значение с плавающей запятой присваивается целочисленному типу, дробная часть теряется. Например, если целому числу присвоено значение 1,23, результирующее значение будет просто 1. 0,23 будет усечено. Конечно, если размер целочисленного компонента слишком велик для целевого целочисленного типа, то это значение будет уменьшено по модулю диапазона целевого типа.

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

// Demonstrate casts.
class Conversion {
public static void main(String args[]) {
byte b;
int i = 257;
double d = 323.142;
System.out.println("\nConversion of int to byte.");
b = (byte) i;
System.out.println("i and b " + i + " " + b);
System.out.println("\nConversion of double to int.");
i = (int) d;
System.out.println("d and i " + d + " " + i);
System.out.println("\nConversion of double to byte.");
b = (byte) d;
System.out.println("d and b " + d + " " + b);
}
}

Эта программа генерирует следующий вывод:

Conversion of int to byte. i and b 257 1 
Conversion of double to int. d and i 323.142 323 
Conversion of double to byte. d and b 323.142 67

Рассмотрим каждую конверсию. Когда значение 257 приводится в байтовую переменную, результатом является остаток от деления 257 на 256 (диапазон байта), который в данном случае равен 1. Когда d преобразуется в int, его дробная часть теряется. Когда d преобразуется в байт, его дробная часть теряется, а значение уменьшается по модулю 256, что в данном случае равно 67.

Давайте посмотрим на пример явного приведения типов в Java:

public class Main  {  
  public static void main(String args[])  {  
    double d = 57.17;  
    int i = (int)d;  // Explicit casting from long to int data type
    System.out.println(d);  
    System.out.println(i);  //fractional part lost
  }  
}

Выход:

57.17
57
57

В приведенном выше примере мы преобразовали тип данных double в тип данных int. Десятичная часть значения теряется после приведения типа.

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

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

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

Ниже приведена схематическая иллюстрация возможных промо-акций типов:

Вы обнаружите, что если вы выполняете какие-либо математические или побитовые операции над примитивными типами данных, которые меньше, чем int (т. е. char, byte или short), эти значения будут преобразованы в int перед выполнением операций, и в результате значение будет типа int. Поэтому, если вы хотите вернуться к меньшему типу, вы должны использовать приведение. (И, поскольку вы выполняете присваивание обратно меньшему типу, вы можете потерять информацию.) В общем, самый большой тип данных в выражении — это тот, который определяет размер результата этого выражения; если вы умножите число с плавающей запятой и число с двойной точностью, результат будет двойным; если вы добавите int и long, результат будет длинным.

Чтобы понять больше:

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

byte a = 40;
byte b = 50;
byte c = 100;
int d = a * b / c;

Результат промежуточного термина a*b легко превышает диапазон любого из его байтовых операндов. Чтобы решить проблему такого рода, Java автоматически продвигает каждый операнд byte, short или char в int при оценке выражение. Это означает, что подвыражение a*b выполняется с использованием целых чисел, а не байтов. Таким образом, 2000, результат промежуточного выражения, 50 * 40, допустим, хотя a и b оба указаны как тип >байт.

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

byte b = 50;
b = b * 2; // Error! Cannot assign an int to a byte!

Код пытается сохранить 50 * 2, совершенно правильное значение байта, обратно в байтовую переменную. Однако, поскольку операнды автоматически повышались до int при вычислении выражения, результат также повышался до int. Таким образом, результат выражения теперь имеет тип int, который нельзя присвоить байту без использования приведения. Это справедливо даже в том случае, если, как в данном конкретном случае, присваиваемое значение по-прежнему соответствовало бы целевому типу.

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

byte b = 50;
b = (byte)(b * 2);

что дает правильное значение 100.

Правила автоматического продвижения типов

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

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

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

Давайте рассмотрим несколько примеров Java, иллюстрирующих числовые правила продвижения в Java-.

1- Когда один из операндов двойной.

public class PromotionExample {
 public static void main(String[] args) {
  int i = 30;
  double d = 2.5;
  double result = i * d;
  System.out.println("Result is- " + result);
 }
}
// output :
// Result is- 75.0

В коде один из операндов — int, а другой операнд — double, поэтому результат выражения должен быть double из-за числового продвижения.

2- Когда один из операндов с плавающей запятой.

public class PromotionExample {
 public static void main(String[] args) {
  short s = 4;
  int i = 30;
  float f = 6.75f;
  float result = (s+i) * f;
  System.out.println("Result is- " + result);
 }
}
//output
// Result is- 229.5

В коде один из операндов является плавающим, поэтому все выражение становится плавающим.

3- Попытка присвоить результат int, когда один из операндов имеет значение float.

public class PromotionExample {
 public static void main(String[] args) {
  byte a= 100;
  byte b= 50;
  int i= 80;
  float f = 80;
  result = f/i *b; // line 6
 }
}

Разница между приведением типов и приведением типов

Давайте посмотрим на разницу между приведением типов и приведением типов, которые приведены ниже:

1. При приведении типов тип данных преобразуется программистом в другой тип данных с помощью оператора приведения. В то время как при приведении типа тип данных преобразуется компилятором в другой тип данных.
2. Приведение типов можно применять как к совместимым типам данных, так и к несовместимым типам данных. В то время как приведение типов можно применять только к совместимым типам данных.
3. При приведении типов оператор приведения необходим для приведения типа данных к другому типу данных. В то время как при приведении типов нет необходимости в операторе приведения.
4. При преобразовании типов (явное преобразование типов) конечный тип данных может быть меньше исходного типа данных при преобразовании типа данных в другой тип данных. strong> преобразование типов) тип данных назначения не может быть меньше исходного типа данных.
5. Приведение типов происходит во время разработки программы программистом. В то время как преобразование типов (неявное преобразование типов) выполняется во время компиляции.
6. Приведение типов также называется сужающим преобразованием, поскольку в этом случае конечный тип данных может быть меньше исходного типа данных. Тогда как тип приведение (неявное преобразование типа) также называется расширяющим преобразованием, поскольку при этом конечный тип данных не может быть меньше исходного типа данных.
7. Приведение типов часто используется в кодировании и конкурентном программировании. В то время как приведение типов (неявное преобразование типов) в кодировании и конкурентном программировании используется меньше, так как может привести к неправильному ответу.
8. Приведение типов более эффективно и надежно, тогда как приведение типов (неявное преобразование типов) менее эффективно и менее надежно.

Спасибо за чтение. Приятного обучения 😄

Поддержите нашу публикацию, подписавшись на нее

Также обратитесь к следующим статьям.