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

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

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

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

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

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

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

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

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

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

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

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

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

unsigned int -> long -> unsigned -> 

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

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

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

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

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

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

Пример типа Ceorcion –

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

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 указывает желаемый тип для преобразования указанного значения. Например, следующий фрагмент преобразует int в byte . Если целочисленное значение больше диапазона байта , оно будет уменьшено по модулю (остаток от деления целого числа на) диапазона байтов.

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

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

// 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

Давайте посмотрим на пример явного приведения типов в 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• Все переменные типов 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

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. При приведении типов ( явное преобразование типов) целевой тип данных может быть меньше, чем исходный тип данных, при преобразовании типа данных в другой тип данных . меньше исходного типа данных.
5. Приведение типов происходит во время разработки программы программистом. В то время как преобразование типов ( имплецитное преобразование типов) выполняется во время компиляции.
6. Приведение типов также называется сужающим преобразованием, поскольку при этом целевой тип данных может быть меньше, чем исходный тип данных. В то время как приведение типов ( имплецитное преобразование типов) также называется расширяющим преобразованием, поскольку в этом случае целевой тип данных не может быть меньше, чем исходный тип данных.
7. Приведение типов часто используется в кодировании и конкурентном программировании. В то время как приведение типов ( имплецитное преобразование типов) меньше используется в кодировании и конкурентном программировании, поскольку оно может привести к неправильному ответу.
8. Приведение типов более эффективно и надежно. В то время как принуждение типов ( имплецитное преобразование типов) менее эффективно и менее надежно.

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

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

2023 React JS Тенденции, за которыми стоит следить Взлом кликов и меры по его предотвращению Интеграция Splunk с SpringBoot Часть 1 Кодирование: проверьте, являются ли две строки анаграммами в Javascript Почему Java — самый любимый язык программирования на планете Понять методы в Java 5 распространенных вопросов по JavaScript: Введение в архитектуру Spark 25. Самое большое поддерево бинарного поиска (BST)