Tapez les conversions que le compilateur effectue automatiquement en Java. Convertissez les chaînes Java en d'autres types de valeurs. Exemple. Promotion d'octet en int où l'expression contient un opérande variable int

Il est souvent nécessaire de convertir des chaînes en valeurs d'autres types, telles que int ou boolean, et vice versa. Selon la convention acceptée, la responsabilité de la conversion de la chaîne V la valeur d'un autre type est affectée à la méthode correspondante de ce type. Ainsi, par exemple, la conversion d'une chaîne en une valeur de type int est effectuée par une méthode statique de la classe wrapper Integer. Le tableau suivant répertorie tous les types capables de convertir des valeurs en chaînes et vice versa, ainsi que les méthodes correspondantes.

TYPE Méthode de conversion - Méthode de conversion à partir d'une chaîne

tion Vers la ligne

booléen String.valueOf(boolean) new.Boolean(String). valeur booléenne()

octet String.valueOf (octet) Octet.parseByte (chaîne, int)

short String.valueOf(short) Short.parseShort(string, int)

int String.valueOf(int) Integer.parseInteger(string, int)

long String.valueOf(long) Long.parseLong(String, int)

float String.valueOf (float) Float.parseFloat (String)

double String.valueOf(double) Double.parseDouble(String)

Pour convertir une chaîne en valeur booléenne, vous devez créer un objet booléen, puis interroger sa valeur. Toutes les autres classes wrapper contiennent les méthodes correspondantes analyser. Méthodes analyser les types entiers existent sous deux formes surchargées : la première, en plus de la chaîne, nécessite de spécifier un argument supplémentaire de type int, représentant la base du système numérique - de 2 à 32 ; le second ne prend qu'un paramètre de chaîne et suppose par défaut l'utilisation du système de nombres décimaux. Dans tous les cas, sauf booléen, l'hypothèse suivante est faite : Si la chaîne représente une valeur qui ne peut pas être correctement convertie en un nombre du type approprié, une exception NumberFormatException est levée. La classe Boolean suit la convention selon laquelle tout paramètre de chaîne qui n'est pas égal à « true » (insensible à la casse) entraîne la création d'un objet booléen avec la valeur false.

Méthodes qui vous permettent de convertir des caractères représentés sous l'une des formes prises en charge par le langage (comme \b, \uxxxx etc.), les valeurs de type char et vice versa n'existent pas. Pour obtenir un objet String contenant un seul caractère, appelez simplement la méthode String.valueOf, en lui passant la valeur char correspondante en paramètre.

Il n'existe également aucun moyen de créer des représentations sous forme de chaîne de nombres spécifiés dans l'un des formats pris en charge par le langage - avec un zéro non significatif (O), indiquant un nombre octal, et un préfixe Ox (ou OX), servant de signe du Système de nombres hexadécimaux. En revanche, les classes wrapper d'entiers prennent en charge les versions de la méthode decode qui peuvent convertir des chaînes en valeurs numériques du type approprié et comprendre que le O initial est un nombre octal et que l'un des préfixes Ox OU Ox est un nombre hexadécimal.

Toute classe d'application peut prendre en charge la conversion de ses propres objets en chaînes et inversement si sa déclaration remplace la méthode toString en conséquence et fournit un constructeur spécial qui crée un objet de classe basé sur la chaîne passée en paramètre. Vous disposez également de la méthode String.valueOf(Object obj), qui renvoie soit un objet chaîne « nul » (si obj est nul), soit le résultat de la méthode obj.toString. La classe String contient suffisamment de surcharges de la méthode valueOf pour que vous puissiez convertir n'importe quelle valeur de n'importe quel type en un objet String en appelant simplement valueOf et en passant l'argument souhaité.

Parfois, des situations surviennent lorsque vous avez une valeur d'un certain type et que vous devez l'attribuer à une variable d'un type différent. Pour certains types, cela peut être fait sans conversion de type ; dans de tels cas, ils parlent de conversion de type automatique. En Java, la conversion automatique n'est possible que si la représentation numérique de la variable de destination est suffisamment précise pour stocker la valeur d'origine. Une telle conversion se produit, par exemple, lors de la saisie d'une constante littérale ou de la valeur d'une variable de type byte ou short dans une variable de type int. Ça s'appelle extension (élargissement) ou augmenter (promotion), car un type de bits inférieurs est étendu (promu) vers un type compatible plus grand. Le type int est toujours suffisamment grand pour stocker des nombres dans la plage autorisée par le type byte, donc un opérateur de conversion de type explicite n'est pas requis dans de telles situations. L'inverse n'est pas vrai dans la plupart des cas, donc pour attribuer une valeur de type int à une variable de type byte, vous devez utiliser l'opérateur de conversion de type. Cette procédure est parfois appelée rétrécissement (rétrécissement), parce que vous dites explicitement au compilateur que la valeur doit être convertie pour s'adapter à une variable du type souhaité. Pour convertir une valeur en un type spécifique, vous devez la faire précéder de ce type, entre parenthèses. L'extrait de code suivant illustre la conversion du type d'une source (une variable int) en type d'une destination (une variable octet). Si, lors d'une telle opération, la valeur entière était en dehors de la plage autorisée pour le type d'octet, elle serait réduite en divisant modulo par la plage autorisée pour l'octet (le résultat de la division modulo par un nombre est le reste de la division par ce numéro),

entier a = 100 ;
octetb = (octet) a ;

2.2.1. Conversion de type automatique dans les expressions

Lors du calcul de la valeur d'une expression, la précision requise pour stocker les résultats intermédiaires doit souvent être supérieure à celle requise pour représenter le résultat final.

octet un = 40;
octet b = 50 ;
octet avec = 100;
int d = a* b / c;

Le résultat de l'expression intermédiaire (a*b) peut très bien sortir de la plage de valeurs autorisée pour le type d'octet. C'est pourquoi Java promeut automatiquement le type de chaque partie d'une expression en type int, afin qu'il y ait suffisamment de place pour le résultat intermédiaire (a* b).

La conversion de type automatique peut parfois provoquer des messages d'erreur inattendus du traducteur. Par exemple, le code ci-dessous, bien qu'il semble tout à fait correct, génère un message d'erreur lors de la phase de traduction. Dans celui-ci, nous essayons d'écrire la valeur 50*2, qui devrait s'adapter parfaitement au type d'octet, dans une variable d'octet. Mais en raison de la conversion automatique du type de résultat en int, nous recevons un message d'erreur du traducteur - après tout, lors de l'écriture de int en octet, une perte de précision peut survenir.

octet b = 50 ;
b = b*2 :
^ Type incompatible pour =. Casting explicite nécessaire pour convertir int en octet.
(Type incompatible pour =. Conversion explicite requiseentier dansoctet)

Texte corrigé :
octetb = 50 ;
b = (octet) (b*2);

ce qui fait que b est défini sur la valeur correcte 100.

Si une expression utilise des variables de types byte, short et int, le type de l'expression entière est automatiquement promu en int pour éviter tout débordement. Si dans une expression le type d'au moins une variable est long, alors le type de l'expression entière est également élevé à long. N'oubliez pas que tous les littéraux entiers qui ne se terminent pas par un L (ou 1) sont de type int.

Si une expression contient des opérandes de type float, alors le type de l'expression entière est automatiquement promu en float. Si au moins un des opérandes est de type double, alors le type de l'expression entière est élevé à double. Par défaut, Java traite tous les littéraux à virgule flottante comme étant de type double. Le programme suivant montre comment le type de chaque valeur dans une expression est promu pour correspondre au deuxième opérande de chaque opérateur binaire.

classe Promouvoir (
public static void main (arguments de chaîne) (
octet b= 42 ;
char avec= "une';
short = 1024 ;
int je = 50 000 ;
flotteur f = 5,67f ;
doublé = 0,1234 ;
double résultat = (f*b) + (i/ c) - (d* s) ;
Système, dehors. println ((f* b)+ "+ "+ (i / c)+ " -" + (d* s));
Système, dehors. println("résultat = "+ résultat); )
}

La sous-expression f*b est un float multiplié par un octet, son type est donc automatiquement promu en float. Le type de la sous-expression suivante i/c (int divisé par char) est promu en int. De même, le type de la sous-expression d*s (double times short) est promu en double. Dans la prochaine étape des calculs, nous traitons de trois résultats intermédiaires de types float, int et double. Premièrement, lors de l’ajout des deux premiers, le type int est promu en float et le résultat est un float. Lorsqu'une valeur double en est soustraite, le type de résultat est promu en double. Le résultat final de l’expression entière est une valeur double.

Maintenant que nous avons vu tous les types simples, y compris les entiers, les nombres réels, les caractères et les booléens, essayons de tout rassembler. L'exemple ci-dessous crée des variables de chacun des types simples et imprime les valeurs de ces variables.

classe SimpleTypes (
public static void main (arguments de chaîne) (
octet b = 0x55 ;
court s = 0x55ff ;
int je = 1 000 000 ;
long l = 0xffffffffL;
char avec= 'un';
flotteur f= 0,25f ;
double d = 0,00001234 ;
booléen bool = vrai ;
System.out.println("octet b = " + b);
System.out.println("short s = " +s);
System.out.println("int i =" + i);
System.out.println("long 1 = " + l);
System.out.println("char avec= » + s);
System.out.println("float f = " + f);
System.out.println("double d = " + d);
System.out.println("boolean bool =” + bool); )
}

En exécutant ce programme, vous devriez obtenir le résultat ci-dessous :

octet b = 85
short = 22015
entier je = 1000000
long 1 = 4294967295
char avec=un
flotteur f = 0,25
doubled=1.234e-005
booléen booléen = vrai

Veuillez noter que les entiers sont imprimés en notation décimale, bien que nous ayons précisé les valeurs de certains d'entre eux en notation hexadécimale.

Cet article :

• rédigé par l'équipe. Nous espérons que cela vous sera utile. Bonne lecture !
• c'est l'un des articles de notre

La conversion de type est un sujet qui peut sembler intimidant pour ceux qui découvrent la programmation Java. Cependant, nous vous assurons que tout est en réalité simple. L'essentiel est de comprendre quelles lois régissent l'interaction entre les variables et rappelez-vous-en lors de l'écriture de programmes. Alors, découvrons-le.

Il existe 2 types de transformations en Java - l'image vous aidera :

Rappelons que l'ensemble de « l'Univers Java » est constitué de :

• types primitifs (byte, short, int, long, char, float, double, boolean)
• objets

Dans cet article, nous :

• envisager la conversion de type pour les types de variables primitifs
• la conversion d'objets (String, Scanner, etc.) n'est pas prise en compte dans cet article, car une « magie » distincte se produit avec les objets - c'est un sujet pour un article séparé.

Conversion automatique

Eh bien, essayons de comprendre ce qu'est la « conversion automatique ».

Rappelez-vous, lorsque nous avons examiné les types de variables (dans l'article), nous avons dit que une variable est une sorte de « conteneur » , qui peut stocker une valeur pour une utilisation ultérieure dans le programme. Nous avons également parlé du fait que chaque type de variable a sa propre plage de valeurs valides et la quantité de mémoire qu'elle occupe. Voici le panneau où tout était écrit :

Voilà donc ce à quoi nous voulons en venir. De plus, ce n'est pas seulement qu'on vous a donné des plages de valeurs acceptables et la quantité de mémoire occupée :)

Comparons, par exemple :

1. octet et court. byte a une plage de valeurs valides plus petite que short. Autrement dit, byte est comme une boîte plus petite et short est une boîte plus grande. Et ça veut dire nous pouvons mettre l'octet en bref.

2. octet et int. byte a une plage de valeurs valides plus petite que int. Autrement dit, byte est comme une boîte plus petite et int est comme une boîte plus grande. Et ça veut dire nous pouvons mettre un octet dans int.

3. int et long. int a une plage de valeurs valides plus petite que long. Autrement dit, int est comme une boîte plus petite et long est comme une boîte plus grande. Et ça veut dire nous pouvons mettre du temps.

Ceci est un exemple de conversion automatique. Cela peut être schématiquement représenté sous la forme d’une image comme celle-ci :

Voyons comment cela fonctionne dans la pratique.

Exemple n°1

Code n°1 - si vous exécutez ce code sur votre ordinateur,

classe Test ( public static void main(String args) ( octet a = 15; octet b = a; System.out.println(b); ) )

Code n°2 - si vous exécutez ce code sur votre ordinateur, le numéro 15 sera affiché dans la console

classe Test ( public static void main(String args) ( octet a = 15; int b = a; System.out.println(b); ) )

Bourriquet ? Pensez-vous que fois le même numéro a été émis sur la console, et le code n°1 ne diffère du code n°2 que par le type de variable b , alors il n'y a aucune différence entre eux ? E ce n'est pas vrai.

Le code n°2 contient automatiqueconversion de types , mais dans le code n°1 - non :

Bien que le nombre soit en principe le même, il est désormais en b Ô un conteneur plus grand qui occupe plus d'espace disque. Dans ce cas, la JVM effectue des conversions automatiques pour vous. Elle le sait int plus que octet .

Moulage de caractères

C'est une autre affaire si vous essayez de transférer quelque chose d'un conteneur plus grand vers un plus petit.

Vous savez peut-être que le plus grand conteneur contient quelque chose qui peut tenir dans le petit - mais la JVM ne le sait pas et essaie de vous protéger des erreurs.

Il faut donc « dire clairement » que la situation est sous contrôle :

classe Test ( public static void main(String args) ( int a=0; long b=15; a = (int) b; ) )

Ici, nous avons ajouté (int) avant b. Si la variable un c'était par exemple comme octet, entre parenthèses il y aurait (octet). La formule générale ressemble à ceci :

Elle dit "donne (plus) de sens b une variable du type dont j'ai besoin (cible) int ".

Si quelque chose ne va pas.

Avant cela, nous abordions les situations en supposant que nous savions exactement ce que nous faisions. Mais que se passe-t-il si vous essayez de mettre quelque chose dans un récipient qui n’y rentre pas ?

Il s’avère que seul ce qui « rentre » restera dans le conteneur. Par exemple, pour les nombres à virgule flottante la partie fractionnaire sera « coupée » :

//exemple 1 classe Test ( public static void main(String args) ( double a=11.2345; int b=(int)a; System.out.println(b); // la console affichera le numéro 11 ) )

Il faut se rappeler que la partie fractionnaire pas arrondi, UN écarté.

Que se passe-t-il si nous essayons de placer un nombre en dehors de la plage autorisée ? Par exemple, si vous mettez le nombre 128 en octet (plage d'octets de -128 à 127) ? Pensez-vous que nous en aurons 1 ? Non. On obtient -128 :

class Test ( public static void main(String args) ( double a=128; byte b=(byte)a; System.out.println(b); //nous verrons -128 dans la console) )

La valeur d'une variable avec une telle transformation peut être calculée, mais l'objectif du programmeur est d'éviter une situation dans laquelle la valeur dépasse les limites autorisées, car cela peut conduire à un fonctionnement incorrect du programme.

Quêtes :

1. Écrivez systématiquement dans le compilateur les conversions de tous les types primitifs entre eux, y compris les caractères et les types. Créez un tableau comme celui-ci :

A l'intersection écrivez : a - si la conversion se fait automatiquement, on - si vous devez utiliser une conversion explicite, x - si la conversion est impossible.

* convertir un type en lui-même est appelé identique– il n'est pas nécessaire de l'enregistrer

1. Regardez à nouveau la taille de chaque type primitif. Essayez de créer un organigramme montrant quels types vont où. Dessinez des flèches intitulées « transformation en expansion » et « transformation restrictive ».

Questions

Lors d'un entretien pour le poste de Développeur Java Junior, il peut vous être demandé :

Que savez-vous de la conversion des types de données primitifs, y a-t-il une perte de données, est-il possible de convertir un type booléen ?

Essayez de répondre à la question.

Résumons :

• Si vous « mettez » le contenu d'un conteneur plus petit dans un conteneur plus grand, la conversion se produit automatiquement et aucune erreur ne devrait se produire.

• S'il est nécessaire de mettre « une valeur d'un conteneur plus grand dans un conteneur plus petit », vous devez être prudent et utiliser un transtypage de type explicite.

• Lors de la conversion de float ou double en types entiers, la partie fractionnaire n'est pas arrondie, mais simplement supprimée.
• Le type booléen ne peut être converti en aucun type.
• Le type char est converti en types numériques, comme un code de caractère dans le système UNICODE.
• Si le nombre est plus grand que son contenant, le résultat sera imprévisible.

Cet article ne décrit qu'une partie du matériel sur le thème de la fonte de caractères. Il existe également des conversions de type d'objet, des conversions en chaîne (après tout, tout peut être écrit dans une chaîne, n'est-ce pas ?) et une promotion automatique de type dans les expressions.

Nous espérons que notre article vous a été utile. Il est également possible de s'inscrire à nos cours Java à Kyiv. Nous enseignons à partir de zéro. Vous pouvez trouver des informations détaillées sur notre site Web.

Parfois, des situations surviennent lorsqu'il est nécessaire d'attribuer une valeur à une variable d'un type à une variable d'un autre type. Par exemple:

Exemple 1 : Affectation de la valeur d'une variable d'un type à un autre

Il existe 2 types de transformations en Java - conversion automatique (implicite) Et transtypage (conversion explicite).

1. Conversion automatique

Examinons d'abord la conversion automatique. Si les deux types sont compatibles, leur conversion se fera automatiquement en Java. Par exemple, une valeur comme octet peut toujours être affecté à une variable comme int , comme le montre l'exemple 1.

Pour la conversion de type automatique, deux conditions doivent être remplies :

• les deux types doivent être compatibles
• la longueur du type cible doit être supérieure à la longueur du type source

Dans ce cas, ça arrive conversion avec extension.

Le diagramme suivant montre l'élargissement de la conversion en Java :

Les lignes pleines indiquent les transformations effectuées sans perte de données. Les lignes pointillées indiquent qu'une perte de précision peut survenir lors de la conversion.

Par exemple, le type de données int toujours assez grand pour stocker toutes les valeurs valides du type octet , donc aucun opérateur de conversion de type explicite n'est requis dans ce cas. Dans une perspective de conversion élargie, les types de données numériques, y compris les nombres entiers et à virgule flottante, sont compatibles les uns avec les autres. Dans le même temps, il n'y a pas de conversion automatique des types numériques en types carboniser ou booléen . Espèces carboniser Et booléen sont également incompatibles les uns avec les autres.

Cela vaut la peine d'expliquer un peu pourquoi, par exemple le type octet ne se convertit pas automatiquement (pas explicitement) en type carboniser , bien que tapez octet a une largeur de 8 bits et carboniser - 16, il en va de même pour la conversion de type court V carboniser . Cela arrive parce que octet Et court types de données signés, et carboniser non signé. Par conséquent, dans ce cas, vous devez utiliser une conversion de type explicite, car le compilateur doit indiquer explicitement que vous savez ce que vous voulez et comment le bit signé des types sera traité. octet Et court lors de la conversion en type carboniser .

Comportement de la valeur de type carboniser coïncide dans la plupart des cas avec le comportement d'une valeur de type entier, donc une valeur de type carboniser peut être utilisé partout où des valeurs sont requises int ou long . Rappelons cependant que le type carboniser n'a aucun signe, donc il se comporte différemment du type court , malgré le fait que la plage des deux types est de 16 bits.

2. Casting de caractères

Malgré la commodité de la conversion de type automatique, elle n’est pas en mesure de satisfaire tous les besoins urgents. Par exemple, que se passe-t-il si la valeur est comme int doit être affecté à une variable de type octet ? Cette conversion ne sera pas effectuée automatiquement car la longueur du type octet moins que le type int . Parfois, ce type de transformation est appelé transformation rétrécissante, car la valeur est explicitement réduite pour s'adapter au type de données cible.

Pour convertir entre deux types de données incompatibles, vous devez utiliser un transtypage. Un cast n'est qu'une conversion de type explicite. La forme générale de la fonte de caractères est la suivante :

valeur (type_cible)

où est le paramètre type_cible indique le type vers lequel la valeur spécifiée doit être convertie.

Exemple 2 : conversion de type

Par exemple, dans l'extrait de code suivant, le type int lancer pour taper octet:

Int je = 11 ; octet b = 22 ; b = (octet)i;

Exemple 3 : conversions de virgule flottante en nombre entier

Regardons un exemple de conversion de valeurs à virgule flottante en nombres entiers. Dans cet exemple, la partie fractionnaire de la valeur à virgule flottante est simplement ignorée (opération de troncature) :

Doubled = 3,89 ; int a = (int) d; //Le résultat sera 3

Exemple 4 : Conversions d'un type entier plus grand vers un type entier plus petit

Lors de la conversion d'un type entier plus grand en un type plus petit, les bits les plus significatifs sont simplement ignorés :

Int je = 323 ; octet b = (octet)i ; //Le résultat sera 67

Exemple 5 : Conversion d'une valeur à virgule flottante plus grande en une capacité entière plus petite

Lors de la conversion d'une valeur à virgule flottante plus grande en un entier, les bits les plus significatifs sont tronqués et ignorés :

Double d = 389889877779,89 ; court s = (court) d; //Le résultat sera -1

3. Promotion automatique du type dans les expressions

En plus des opérations d'affectation, certaines conversions de types peuvent également être effectuées dans les expressions.

Les règles suivantes s'appliquent en Java :

1. Si un opérande est de type double double.
2. flotter, l'autre est également converti en type flotter.
3. Sinon, si un opérande est de type long, l'autre est également converti en type long.
4. Sinon, les deux opérandes sont convertis en type int.
5. Dans les expressions d'affectation mixte (+=,-=,*=,/=), il n'est pas nécessaire d'effectuer une conversion.

Voici un exemple :

Exemple 6. Promotion automatique du type dans les expressions

En multipliant la variable b1 ( octet) par 2 ( int) le résultat sera comme int. Par conséquent, lorsque vous essayez d'attribuer le résultat à la variable b2 ( octet) une erreur de compilation se produira. Mais lors de l’utilisation de l’opérateur d’affectation combinée (*=), un tel problème ne se posera pas.

Octet b1 = 1 ; octet b2 = 2 * b1 ; //Erreur de compilation int i1 = 2 * b1; b2 *= 2 ;

Exemple 7. Promotion automatique du type dans les expressions

Dans l'exemple suivant, une erreur de compilation se produira également - malgré le fait que des nombres comme octet, le résultat de l'opération sera du type int, et non court.

Classe publique IntegerDemo1 ( public static void main(String args) ( octet b1 = 50, b2 = -99; short k = b1 + b2; //erreur de compilation System.out.println("k=" + k); ) )

Exemple 8. Promotion automatique du type dans les expressions

Cet exemple est similaire au précédent, mais utilise l'opération d'affectation combinée, dans laquelle la conversion se produit automatiquement.

Classe publique IntegerDemo2 ( public static void main(String args) ( octet b1 = 50, b2 = -99; b1 += b2; System.out.println("b1=" + b1); ) )

Annotation: Cette conférence est consacrée aux problèmes de conversion de type. Java étant un langage fortement typé, le compilateur et la machine virtuelle surveillent toujours les types pour garantir la fiabilité du programme. Cependant, dans de nombreux cas, l'une ou l'autre transformation doit être effectuée pour mettre en œuvre la logique du programme. D'un autre côté, Java permet d'effectuer certaines transitions sûres entre les types d'une manière implicite pour le développeur, ce qui peut conduire à des malentendus sur le fonctionnement du programme. Le cours aborde tous les types de transformations, puis toutes les situations du programme où elles peuvent être appliquées. Enfin, nous commençons à classer les types de variables et les types de valeurs qu'elles peuvent stocker. Cette question sera abordée plus en détail dans les conférences ultérieures.

Qu’est-ce que tout cela signifie ? Commençons dans l'ordre. Pour les types simples, l'expansion signifie qu'une transition est effectuée d'un type de moins grande capacité à un type de plus grande capacité. Par exemple, du type byte (1 octet de long) au type int (4 octets de long). De telles conversions sont sûres dans le sens où le nouveau type est toujours assuré de contenir toutes les données stockées dans l'ancien type, et donc aucune perte de données ne se produit. C'est pourquoi le compilateur l'implémente lui-même, sans que le développeur ne le remarque :

octet b = 3 ; int a=b;

Dans la dernière ligne, la valeur de la variable d'octet b sera automatiquement convertie en type de variable a (c'est-à-dire int ), aucune action particulière n'est nécessaire pour cela.

Les 19 transformations suivantes sont des transformations d'expansion :

• d'octet à court, int, long, float, double
• de court à int, long, float, double
• de char à int, long, float, double
• de int à long, float, double
• de long à flotter, double
• du flotteur au double

Veuillez noter que vous ne pouvez pas convertir en char à partir de types de longueur plus petite ou égale (octet, short) ou, à l'inverse, en short à partir de char sans perdre de données. Cela est dû au fait que char, contrairement aux autres types entiers, n'est pas signé.

Cependant, il ne faut pas oublier que même en cas d'expansion, les données peuvent toujours être faussées dans des cas particuliers. Ils ont déjà été abordés dans la leçon précédente, il s'agit de convertir des valeurs int en type float et de convertir des valeurs longues en type float ou double. Bien que ces types fractionnaires puissent contenir des nombres beaucoup plus grands que les entiers correspondants, ils comportent moins de chiffres significatifs.

Reprenons cet exemple :

longue a = 111111111111L ; flotter f = a; a = (long) f ; imprimer(a);

Le résultat sera :

La transformation inverse - le rétrécissement - signifie que la transition s'effectue d'un type plus volumineux à un type moins volumineux. Avec cette conversion, il existe un risque de perte de données. Par exemple, si un nombre int était supérieur à 127, lors de sa conversion en octet, les valeurs des bits supérieures au huitième seront perdues. En Java, une telle conversion doit être effectuée explicitement, c'est-à-dire Le programmeur doit indiquer explicitement dans le code qu'il a l'intention d'effectuer une telle conversion et qu'il est prêt à perdre des données.

Les transformations suivantes se rétrécissent :

• de l'octet au caractère
• du court à l'octet, char
• du caractère à l'octet, court
• de l'int à l'octet, court, char
• de long à octet, court, char, int
• du flottant à l'octet, court, char, int, long
• du double à l'octet, court, char, int, long, float

Lors de la réduction d'un type entier à un type entier plus étroit, tous les bits de poids fort qui n'appartiennent pas au nouveau type sont simplement ignorés. Aucun arrondi ou autre action n'est effectué pour obtenir un résultat plus correct :

print((octet)383); print((octet)384); print((octet)-384);

Le résultat sera :

On peut voir que le bit de signe n'a eu aucun effet lors du rétrécissement, puisqu'il a simplement été rejeté - le résultat de l'apport de nombres opposés (384 et -384) s'est avéré être le même. Par conséquent, non seulement la valeur absolue exacte peut être perdue, mais aussi le signe de la grandeur.

Cela est également vrai pour le type char :

caractère c = 40 000 ; print((court)c);

Le résultat sera :

Réduire un type fractionnaire en un type entier est une procédure plus complexe. Elle s'effectue en deux étapes.

La première étape convertit la valeur fractionnaire en long si le type cible est long , ou en int sinon (le type cible est byte , short , char ou int ). Pour ce faire, le nombre fractionnaire d'origine est d'abord arrondi mathématiquement vers zéro, c'est-à-dire que la partie fractionnaire est simplement supprimée.

Par exemple, le nombre 3,84 sera arrondi à 3 et -3,84 deviendra -3. Dans ce cas, des cas particuliers peuvent se présenter :

• si la valeur fractionnaire d'origine est NaN , alors le résultat de la première étape sera 0 du type choisi (c'est-à-dire int ou long );
• si la valeur fractionnaire d'origine est l'infini positif ou négatif, alors le résultat de la première étape sera, respectivement, la valeur maximale ou minimale possible pour le type sélectionné (c'est-à-dire int ou long );
• enfin, si la valeur fractionnaire était une valeur finale, mais qu'à la suite de l'arrondi, le nombre était trop grand en valeur absolue pour le type sélectionné (c'est-à-dire pour int ou long ), alors, comme dans le paragraphe précédent, le résultat du premier le pas sera respectivement la valeur maximale ou minimale possible de ce type. Si le résultat de l'arrondi se situe dans la plage de valeurs du type sélectionné, ce sera alors le résultat de la première étape.
et int sont assez évidents - les infinis fractionnaires ont été transformés respectivement en valeurs minimales et maximales possibles de ces types. Le résultat pour les trois types suivants (short, char, byte) est essentiellement un rétrécissement supplémentaire des valeurs obtenues pour int, selon la deuxième étape de la procédure de conversion. Et cela se fait, comme décrit, simplement en supprimant les bits les plus significatifs. Rappelons que la valeur minimale possible sous forme de bits est représentée par 1000..000 (seulement 32 bits pour int, c'est-à-dire un et 31 zéro). Le maximum possible est de 1111..111 (31 unités). En supprimant les bits les plus significatifs, nous obtenons le résultat 0 pour l'infini négatif, qui est le même pour les trois types. Pour l'infini positif, nous obtenons un résultat dans lequel tous les bits sont égaux à 1

En conclusion, attirons encore une fois l'attention sur le fait que les valeurs primitives de type booléen ne peuvent participer qu'aux conversions d'identité.