Conversion de types Java

Qu’est-ce que le transtypage de type en Java ?

Un type de données est un ensemble prédéfini de valeurs qui spécifient le type de valeurs qui peuvent y être stockées ainsi que l'opération qui peut y être effectuée. Le Java Type Casting est un processus par lequel un type de données est converti en un autre. Cela peut être à la fois implicite et explicite . Le transtypage implicite, également appelé transtypage automatique, est effectué par le compilateur. Le transtypage explicite est effectué manuellement par le programmeur dans le code.

Pourquoi la conversion de type est-elle requise ?

Java possède différents types de données primitifs qui nécessitent différents espaces en mémoire. Cela peut entraîner des problèmes de compatibilité lors de l'attribution d'une valeur d'un type de données à un autre. Si les types de données sont déjà compatibles, le transtypage est effectué automatiquement par le compilateur. Ainsi, le transtypage résout un problème de compatibilité majeur lorsqu’il s’agit de différents types de données dans notre programme.

Types de conversion de types Java

Il existe deux types de conversion de type en Java.

1. Conversion de type élargie – Également connue sous le nom de conversion de type implicite ou automatique
2. Conversion de type rétrécissante – également connue sous le nom de conversion de type explicite ou manuelle

Moulage de type élargissant

Le transtypage élargi, comme son nom l'indique, fait référence à l'élargissement d'un type de données plus petit à un type de données plus grand. Nous effectuons ce transtypage lorsque nous voulons convertir un petit type en un grand type. Les types de données doivent être compatibles les uns avec les autres. Il n’y a pas de conversion implicite du type numérique en type char ou booléen. En Java, les types char et boolean ne sont pas compatibles. Ce type de casting est effectué automatiquement par le compilateur sans aucune perte d'informations. Il ne nécessite aucun déclenchement externe de la part du programmateur.

Exemple

//Automatic type conversion
public class WideningExample {
   public static void main(String[] args) {

       int i = 100;
       System.out.println("int value: " + i);

       // int to long type
       long l = i;
       System.out.println("int to long value: " + l);

       // long to float type
       float f = l;
       System.out.println("int to float value: " + f);


       byte b = 1;
       System.out.println("byte value: " + b);

       // byte to int type
       i = b;
       System.out.println("byte to int value: " + i);

       char c = 'a';
       System.out.println("char value: " + c);

       // char to int type
       i = c;

       // prints the ASCII value of the given character
       // ASCII value of 'a' = 97
       System.out.println("char to int value: " + i);
   }
}

Sortir

Explication

Dans le code ci-dessus, nous avons montré un transtypage élargi qui est effectué automatiquement par le compilateur. Tout d’abord, nous avons attribué des valeurs à un int , un byte et un char . Nous avons ensuite attribué les valeurs int à un long et float , tous deux plus grands que int . Nous avons également attribué les valeurs byte et char à int . byte et char sont des types de données plus petits que int , ces conversions étaient donc implicites.

Moulage de type rétrécissant

Le transtypage restrictif, comme son nom l'indique, fait référence au rétrécissement d'un type de données plus grand à un type de données plus petit. Nous effectuons ce transtypage lorsque nous voulons convertir un grand type en un petit type. Pour ce type de conversion, nous remplaçons la conversion par défaut de Java en spécifiant notre propre conversion. Pour y parvenir, nous écrivons la variable ou la valeur qui doit être typée précédée du type de données cible entre parenthèses '()'. Cependant, ce type de moulage peut entraîner une éventuelle perte de précision.

Exemple

//Manual Type Conversion
public class NarrowingExample {
   public static void main(String[] arg) {

       // double data type
       double d = 97.04;
       // Print statements
       System.out.println("double value: " + d);

       // Narrowing type casting from double to long
       // implicitly writing the target data type in () followed by initial data type
       long l = (long) d;

       // fractional part lost - loss of precision
       System.out.println("long value: " + l);

       // Narrowing type casting from double to int
       // implicitly writing the target data type in () followed by initial data type
       int i = (int) l;

       // fractional part lost - loss of precision
       System.out.println("int value: " + i);

       // Narrowing type casting from double to int
       // implicitly writing the target data type in () followed by initial data type
       char c = (char) i;

       // displaying character corresponding to the ASCII value of 100
       System.out.println("char value: " + c);
   }
}

Sortir

Explication

Le transtypage restreint doit être effectué explicitement par le programmeur en utilisant une syntaxe standard. Dans le programme ci-dessus, nous avons commencé avec une valeur double qui est plus grande que les types de données long et int . Nous avons typé ce double en long et int en utilisant des parenthèses avec les types de données cibles souhaités. Nous avons également transtypé manuellement « int » en « char ».

Conclusion

À la fin de cet article, nous espérons que vous vous êtes familiarisé en détail avec Java Type Casting. Vous avez appris les deux types de transtypage en Java. Vous avez également appris à convertir manuellement les types de données non compatibles à l'aide du transtypage Narrowing. Vous pouvez essayer vous-même d’autres combinaisons de types de données avec des valeurs différentes pour les comprendre plus en profondeur. Continuez à vous entraîner pour une maîtrise plus approfondie du concept. D’ici là, continuez à grandir et continuez à briller !