Élargissement et rétrécissement des types primitifs

Salut! Au cours de votre progression dans CodeGym, vous avez rencontré plusieurs fois des types primitifs. Voici une courte liste de ce que nous savons d'eux :

1. Ce ne sont pas des objets et représentent une valeur stockée en mémoire
2. Il existe plusieurs sortes
   • Nombres entiers : byte , short , int , long
   • Nombres à virgule flottante (fractionnaires) : float et double
   • Valeurs logiques : booléen
   • Valeurs symboliques (pour représenter les lettres et les chiffres) : char

3. Chaque type a sa propre plage de valeurs :

Mais en plus d'avoir des valeurs différentes, ils diffèrent également par l'espace qu'ils occupent en mémoire. Un entier prend plus d'un octet. Et un long est plus grand qu'un court. La quantité de mémoire occupée par les primitives peut être comparée aux poupées gigognes russes : chaque poupée gigogne a de l'espace disponible à l'intérieur. Plus la poupée gigogne est grande, plus il y a d'espace. Une grande poupée gigogne ( longue ) accueillera facilement un plus petit int . Il s'adapte facilement et vous n'avez rien d'autre à faire. En Java, lorsque vous travaillez avec des primitives, cela s'appelle une conversion implicite. Autrement dit, cela s'appelle l'élargissement.

Élargissement en Java

Voici un exemple simple de conversion étendue :

public class Main {

   public static void main(String[] args) {

       int bigNumber = 10000000;

       byte littleNumber = 16;

       bigNumber = littleNumber;
       System.out.println(bigNumber);
   }
}

Ici, nous attribuons une valeur d'octet à une variable int . L'affectation réussit sans aucun problème : la valeur stockée dans un octet occupe moins de mémoire que ce qu'un int peut contenir. La petite poupée gigogne (valeur octet) s'insère facilement dans la grande poupée gigogne ( variable int ). C'est une autre affaire si vous essayez de faire le contraire, c'est-à-dire de mettre une grande valeur dans une variable dont la plage ne peut pas accueillir un tel type de données. Avec de vraies poupées gigognes, le nombre ne conviendrait tout simplement pas. Avec Java, c'est possible, mais avec des nuances. Essayons de mettre un int dans une variable courte :

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

   littleNumber = bigNumber;// Error!
   System.out.println(bigNumber);
}

Erreur! Le compilateur comprend que vous essayez de faire quelque chose d'anormal en insérant une grande poupée gigogne ( int ) à l'intérieur d'une petite ( short ). Dans ce cas, l'erreur de compilation est un avertissement du compilateur : "Hé, êtes-vous absolument certain de vouloir faire cela ?" Si vous êtes certain, alors vous dites au compilateur : "Tout va bien. Je sais ce que je fais !" Ce processus est appelé conversion de type explicite ou restriction.

Rétrécissement en Java

Pour effectuer une conversion restrictive, vous devez indiquer explicitement le type vers lequel vous souhaitez convertir votre valeur. En d'autres termes, vous devez répondre à la question du compilateur : "Eh bien, dans laquelle de ces petites poupées gigognes voulez-vous mettre cette grande poupée gigogne ?" Dans notre cas, cela ressemble à ceci :

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

   littleNumber = (short) bigNumber;
   System.out.println(littleNumber);
}

Nous indiquons explicitement que nous voulons mettre un int dans une variable courte et que nous en prenons la responsabilité. Voyant qu'un type plus étroit a été explicitement indiqué, le compilateur effectue la conversion. Quel est le résultat ? Sortie console : -27008 C'était un peu inattendu. Pourquoi exactement avons-nous obtenu cela? En fait, tout est très simple. A l'origine, la valeur était de 10000000. Elle était stockée dans une variable int , qui occupe 32 bits. Voici sa représentation binaire : Nous écrivons cette valeur dans une variable courte , qui ne peut stocker que 16 bits ! En conséquence, seuls les 16 premiers bits de notre numéro y seront déplacés. Le reste sera jeté. En conséquence, la variable courte reçoit la valeur suivante qui sous forme décimale est égal à -27008 C'est pourquoi le compilateur vous demande de "confirmer" en indiquant une conversion restrictive explicite vers un type spécifique. Tout d'abord, cela montre que vous assumez la responsabilité du résultat. Et deuxièmement, il indique au compilateur la quantité d'espace à allouer lors de la conversion. Après tout, dans le dernier exemple, si nous attribuions une valeur int à une variable byte plutôt qu'à un short , alors nous n'aurions que 8 bits à notre disposition, pas 16, et le résultat serait différent. Les types fractionnaires ( float et double ) ont leur propre processus pour réduire les conversions. Si vous essayez de convertir un nombre fractionnaire en un type entier, la partie fractionnaire sera ignorée.

public static void main(String[] args) {

   double d = 2.7;

   long x = (int) d;
   System.out.println(x);
}

Sortie console : 2

carboniser

Vous savez déjà que char est utilisé pour afficher des caractères individuels.

public static void main(String[] args) {

   char c = '!';
   char z = 'z';
   char i = '8';

}

Mais ce type de données a plusieurs caractéristiques qu'il est important de comprendre. Reprenons le tableau des plages de valeurs : La plage de 0 à 65536 est indiquée pour le type char . Mais qu'est ce que ça veut dire? Après tout, un char ne représente pas que des nombres, mais aussi des lettres, des signes de ponctuation… Le fait est qu'en Java les valeurs char sont stockées au format Unicode. Nous avons déjà rencontré Unicode dans l'une des leçons précédentes. Vous vous souvenez probablement qu'Unicode est une norme d'encodage de caractères qui inclut les symboles de presque toutes les langues écrites du monde. En d'autres termes, il s'agit d'une liste de codes spéciaux qui représentent presque tous les caractères dans n'importe quelle langue. L'ensemble du tableau Unicode est très volumineux et, bien sûr, il n'est pas nécessaire de l'apprendre par cœur. En voici une petite partie : L'essentiel est de comprendre comment les caractères sont stockés et de se rappeler que si vous connaissez le code d'un caractère particulier, vous pouvez toujours produire ce caractère dans votre programme. Essayons avec un nombre aléatoire :

public static void main(String[] args) {

   int x = 32816;

   char c = (char) x ;
   System.out.println(c);
}

Sortie de la console : 耰 Il s'agit du format utilisé pour stocker les caractères en Java. Chaque symbole correspond à un nombre : un code numérique de 16 bits (deux octets). En Unicode, 32816 correspond au caractère chinois 耰. Notez le point suivant. Dans cet exemple, nous avons utilisé une variable int . Il occupe 32 bits en mémoire, alors qu'un char en occupe 16. Ici, nous avons choisi un int , car notre nombre (32816) ne rentre pas dans un short . Bien que la taille d'un char (tout comme un short ) soit de 16 bits, il n'y a pas de nombres négatifs dans la plage de char , donc la partie "positive" du charla plage est deux fois plus grande (65536 au lieu de 32767 pour le type court ). Nous pouvons utiliser un int tant que notre code reste en dessous de 65536. Mais si vous créez une valeur int supérieure à 65536, elle occupera plus de 16 bits. Et cela se traduira par un rétrécissement de la conversion

char c = (char) x;

les bits supplémentaires seront ignorés (comme indiqué ci-dessus) et le résultat sera assez inattendu.

Particularités de l'ajout de caractères et d'entiers

Prenons un exemple inhabituel :

public class Main {

   public static void main(String[] args) {

      char c = '1';

      int i = 1;

       System.out.println(i + c);
   }
}

Sortie console : 50 O_О Comment cela a-t-il un sens ? 1+1. D'où vient le 50 ?! Vous savez déjà que charles valeurs sont stockées en mémoire sous forme de nombres compris entre 0 et 65536, et que ces nombres sont une représentation Unicode d'un caractère. Lorsque nous ajoutons un caractère et un type de nombre entier, le caractère est converti en le numéro Unicode correspondant. Dans notre code, lorsque nous avons ajouté 1 et '1', le symbole '1' a été converti en son propre code, qui est 49 (vous pouvez le vérifier dans le tableau ci-dessus). Par conséquent, le résultat est 50. Prenons à nouveau notre vieil ami 耰 comme exemple et essayons de l'ajouter à un certain nombre.

public static void main(String[] args) {

   char c = '耰';
   int x = 200;

   System.out.println(c + x);
}

Sortie console : 33016 Nous avons déjà découvert que 耰 correspond à 32816. Et quand on additionne ce nombre et 200, on obtient notre résultat : 33016. :) Comme vous pouvez le voir, l'algorithme ici est assez simple, mais il ne faut pas l'oublier .