Conversions et promotions en Java

Feb 22 2023

Dans cet article, nous discuterons de la conversion primitive. · Conversion de type ∘ Conversion de type implicite ∘ Conversion de type explicite · Promotion automatique de type dans les expressions · Différence entre la conversion de type et la coercition de type En informatique, la conversion de type, la conversion de type, la coercition de type et la jonglerie de type sont différentes manières de changer une expression d'une type de données à un autre.

Dans cet article, nous discuterons de la conversion primitive .

· Conversion de type
∘ Conversion de type implicite
∘ Conversion de type explicite
· Promotion automatique de type dans les expressions
· Différence entre la conversion de type et la coercition de type

En informatique, la conversion de type , la conversion de type , la coercition de type et la jonglerie de type sont différentes façons de changer une expression d'un type de données à un autre. Un exemple serait la conversion d'une valeur entière en une valeur à virgule flottante ou sa représentation textuelle sous forme de chaîne, et vice versa. Les conversions de types peuvent tirer parti de certaines fonctionnalités des hiérarchies de types ou des représentations de données. Deux aspects importants d'une conversion de type sont de savoir si cela se produit implicitement (automatiquement) ou explicitement , et si la représentation sous-jacente des données est convertie d'une représentation à une autre, ou si une représentation donnée est simplement réinterprétéecomme représentation d'un autre type de données. En général, les types de données primitifs et composés peuvent être convertis.

Chaque langage de programmation a ses propres règles sur la façon dont les types peuvent être convertis. Les langages à typage fort effectuent généralement peu de conversions implicites et découragent la réinterprétation des représentations, tandis que les langages à typage faible effectuent de nombreuses conversions implicites entre les types de données. Un langage de frappe faible permet souvent de forcer le compilateur à interpréter arbitrairement un élément de données comme ayant des représentations différentes - cela peut être une erreur de programmation non évidente ou une méthode technique pour traiter directement le matériel sous-jacent.

Java fournit divers types de données, probablement tous les autres langages dynamiques tels que booléen, char, int, entier non signé, entier signé, flottant, double, long, etc. au total, fournissant 7 types où chaque type de données acquiert un espace différent lors du stockage en mémoire.

Conversion de type

Si vous avez de l'expérience en programmation, vous savez déjà qu'il est assez courant d'attribuer une valeur d'un type à une variable d'un autre type. Si les deux types sont compatibles, alors Java effectuera la conversion automatiquement (conversion de type ) . Par exemple, il est toujours possible d'affecter une valeur int à une variable longue. Cependant, tous les types ne sont pas compatibles et, par conséquent, toutes les conversions de types ne sont pas implicitement autorisées. Par exemple, il n'y a pas de conversion automatique définie de double en octet. Heureusement, il est toujours possible d'obtenir une conversion entre des types incompatibles. Pour ce faire, vous devez utiliser un cast , qui effectue un expliciteconversion entre types incompatibles . Examinons à la fois les conversions de type automatiques ou étendues ( type coercion , type juggling ) et les conversions restrictives ou explicites ( type casting ).

Comme vous pouvez le voir, il est possible d'effectuer un cast sur une valeur numérique ainsi que sur une variable. Notez que vous pouvez introduire des moulages superflus ; par exemple, le compilateur promouvra automatiquement une valeur int en long si nécessaire. Cependant, vous êtes autorisé à utiliser des transtypages superflus pour faire valoir un point ou pour clarifier votre code. Dans d'autres situations, un cast peut être essentiel juste pour obtenir le code à compiler.

En C et C++, la conversion de type peut causer des maux de tête. En Java, la conversion est sûre, à l'exception que lorsque vous effectuez une conversion dite restrictive (c'est-à-dire lorsque vous passez d'un type de données pouvant contenir plus d'informations à un autre qui n'en contient pas autant), vous exécutez le risque de perdre des informations. Ici, le compilateur vous oblige à utiliser un cast (casting de type) , en disant en fait : "Cela peut être une chose dangereuse à faire - si vous voulez que je le fasse de toute façon, vous devez rendre la conversion explicite.” Avec une conversion étendue, un cast (cast explicite) n'est pas nécessaire, car le nouveau type contiendra plus que les informations de l'ancien type afin qu'aucune information ne soit jamais perdue. Java vous permet de convertir n'importe quel type primitif en n'importe quel autre type primitif, à l'exception du booléen, qui n'autorise aucun transtypage. Les types de classe ne permettent pas le casting. Pour convertir l'un à l'autre, il doit y avoir des méthodes spéciales. (…)

Conversion de type implicite

Également connu sous le nom de "conversion automatique ou de type mariage".

Fait par le compilateur lui-même, sans aucun déclencheur externe de l'utilisateur.
Se produit généralement lorsque, dans une expression, plusieurs types de données sont présents. Dans une telle condition, une conversion de type (promotion de type) a lieu pour éviter la perte de données.
Tous les types de données des variables sont mis à niveau vers le type de données de la variable avec le plus grand type de données.

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

unsigned int -> long -> unsigned -> 

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

Les deux types sont compatibles. Par exemple, les types de données tels que numeric sont compatibles avec d'autres types de données numériques, mais ils ne sont pas compatibles avec les types de données boolean , char ou String . De la même manière que String n'est pas compatible avec un type de données booléen .
Le type de destination est plus grand que le type de source.

Il est possible que les conversions implicites perdent des informations, des signes peuvent être perdus (lorsque signé est implicitement converti en non signé) et un débordement peut se produire (lorsque long long est implicitement converti en flottant).

nous appelons parfois ce type de conversion type ceorcion.

En Java, le mécanisme de conversion d'un type d'objet en un autre objet d'un type différent avec un contenu similaire est appelé coercition. En d'autres termes, nous pouvons dire que la coercition est le processus de conversion d'un type de données en un autre type de données. De manière plus spécifique, la conversion implicite est appelée coercition . Il est également connu sous le nom de coercition de type .

Dans le type ceorcion , un type de données est automatiquement converti en un autre type de données par un compilateur au moment du compilateur. Dans le type ceorcion , le type de données de destination ne peut pas être inférieur au type de données source, c'est pourquoi il est également appelé conversion étendue. Une autre chose importante est qu'elle ne peut être appliquée qu'aux types de données compatibles.

Exemple de type Ceorcion –

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

Java forcera automatiquement les données dans la direction des flèches, soit en continu, soit en pointillés. Par exemple:

Les coercitions qui traversent une flèche en pointillé sont autorisées mais peuvent entraîner une perte de précision. Cela signifie que la valeur convertie peut ne pas être égale à la valeur de départ. Par exemple:

Le compilateur produit une erreur si une instruction tente de contraindre les données dans le sens des flèches.

Regardons un exemple de transtypage de type implicite en Java.

Ici, nous allons convertir une valeur int en une valeur longue et enfin en une valeur double en utilisant un simple opérateur d'affectation :

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

En d'autres termes, la « conversion de type » fait référence au processus général de modification d'un type, tandis que la coercition de type fait référence plus spécifiquement à la conversion implicite d'un type. Nous pouvons en outre subdiviser la coercition de type en deux types - contrôlé par le programmeur et contrôlé par le compilateur (parfois appelé jonglerie ).

Conversion de type explicite

Bien que les conversions de type automatiques soient utiles, elles ne répondront pas à tous les besoins. Par exemple, que se passe-t-il si vous souhaitez affecter une valeur int à une variable byte ? Cette conversion ne sera pas effectuée automatiquement, car un octet est plus petit qu'un int. Ce type de conversion est parfois appelé conversion de type et est défini par l'utilisateur.

Ce processus est également appelé conversion de type de réduction, car vous réduisez explicitement la valeur afin qu'elle tienne dans le type cible.

Pour créer une conversion entre deux types incompatibles, vous devez utiliser un transtypage de type. Un transtypage est simplement une conversion de type explicite.

En Java, cela peut être fait en utilisant un opérateur cast () :

Cela se fait en définissant explicitement le type requis devant l'expression entre parenthèses.

Il a cette forme générale :

(target-type) expression

Ici, target-type spécifie le type souhaité vers lequel convertir la valeur spécifiée. Par exemple, le fragment suivant convertit un int en un byte . Si la valeur de l'entier est supérieure à la plage d'un octet , elle sera réduite modulo (le reste d'une division entière par la) plage de l'octet.

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

Le programme suivant illustre certaines conversions de type qui nécessitent des transtypages :

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

Regardons un exemple de casting explicite en 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

Promotion automatique des types dans les expressions

La promotion de type est une occurrence courante dans la programmation Java, qui peut être réalisée automatiquement avec des types de données primitifs grâce à l'utilisation de la promotion de type automatique. Elle est également appelée promotion automatique du type de données.

Comme vous le savez peut-être, en plus des affectations, il existe un autre endroit où certaines conversions de type peuvent se produire : dans les expressions.

Vous trouverez ci-dessous une illustration schématique des promotions de type possibles :

Vous découvrirez que si vous effectuez des opérations mathématiques ou au niveau du bit sur des types de données primitifs plus petits qu'un int (c'est-à-dire, char, byte ou short), ces valeurs seront promues en int avant d'effectuer les opérations, et le résultat la valeur sera de type int. Donc, si vous souhaitez réaffecter dans le type plus petit, vous devez utiliser un cast. (Et, puisque vous réaffectez dans un type plus petit, vous risquez de perdre des informations.) En général, le plus grand type de données dans une expression est celui qui détermine la taille du résultat de cette expression ; si vous multipliez un float et un double, le résultat sera double ; si vous ajoutez un int et un long, le résultat sera long.

Pour mieux comprendre :

considérer ce qui suit. Dans une expression, la précision requise d'une valeur intermédiaire dépassera parfois la plage de l'un ou l'autre des opérandes. Par exemple, examinez l'expression suivante :

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

Aussi utiles que soient les promotions automatiques, elles peuvent provoquer des erreurs de compilation déroutantes. Par exemple, ce code apparemment correct pose problème :

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

Dans les cas où vous comprenez les conséquences d'un débordement, vous devez utiliser un casting explicite, tel que

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

Règles de promotion de type automatique

Les règles suivantes pour la promotion de type doivent être suivies lors de l'exécution d'expressions en Java pour obtenir des résultats corrects :