Comment vérifier si un entier est dans la plage d'un octet (byte) en Java

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si une valeur entière se trouve dans la plage du type de données byte en Java. Nous commencerons par comprendre la plage définie d'un octet (byte), qui va de -128 à 127.

Ensuite, vous apprendrez à comparer un entier avec ces limites d'octet pour déterminer s'il se trouve dans la plage valide. Enfin, nous testerons la logique avec des cas limites pour garantir sa justesse.

Définir la plage d'un octet (byte) (-128 à 127)

Dans cette étape, nous allons explorer le type de données byte en Java et comprendre sa plage. Le type de données byte est l'un des types de données primitifs en Java, utilisé pour stocker de petites valeurs entières.

Une variable de type byte peut contenir des valeurs entières allant de -128 à 127, bornes incluses. Cela s'explique par le fait qu'un octet (byte) utilise 8 bits de mémoire, et avec 8 bits, vous pouvez représenter 2^8 = 256 valeurs différentes. Ces valeurs sont réparties entre les nombres négatifs et positifs, y compris zéro.

Créons un simple programme Java pour démontrer le type de données byte.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.

2. Remplacez tout le contenu du fichier par le code suivant :

   public class HelloJava {
       public static void main(String[] args) {
           byte minByteValue = -128;
           byte maxByteValue = 127;
   
           System.out.println("Minimum byte value: " + minByteValue);
           System.out.println("Maximum byte value: " + maxByteValue);
       }
   }
   

   Dans ce code :

   • Nous déclarons une variable byte nommée minByteValue et lui assignons la valeur minimale possible pour un octet (byte), qui est -128.
   • Nous déclarons une autre variable byte nommée maxByteValue et lui assignons la valeur maximale possible pour un octet (byte), qui est 127.
   • Nous utilisons ensuite System.out.println pour afficher ces valeurs dans la console.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Maintenant, compilons notre programme. Ouvrez le terminal en bas de l'éditeur WebIDE et assurez-vous que vous êtes dans le répertoire ~/project. Ensuite, exécutez la commande suivante :

   javac HelloJava.java
   

   Si la compilation réussit, vous ne verrez aucun message de sortie.

5. Enfin, exécutez le programme compilé en utilisant la commande java :

   java HelloJava
   

   Vous devriez voir la sortie suivante, montrant les valeurs minimale et maximale qu'un byte peut contenir :

   Minimum byte value: -128
   Maximum byte value: 127
   

Ce programme démontre la plage définie du type de données byte en Java. Comprendre ces limites est important lorsque vous choisissez le type de données approprié pour vos variables afin d'éviter des problèmes potentiels tels que le dépassement de capacité (overflow).

Comparer un entier avec les limites d'un octet (byte)

Dans l'étape précédente, nous avons appris sur la plage du type de données byte (-128 à 127). Maintenant, voyons ce qui se passe lorsque nous essayons d'assigner une valeur entière en dehors de cette plage à une variable de type byte.

Java dispose d'autres types de données entières comme int, qui peuvent contenir des valeurs beaucoup plus grandes. Lorsque vous essayez de placer une valeur plus grande dans un conteneur plus petit (comme placer une valeur int dans un byte), vous risquez de rencontrer des problèmes.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

2. Modifiez la méthode main pour inclure une valeur entière en dehors de la plage d'un octet (byte). Remplacez le code existant à l'intérieur de la méthode main par le code suivant :

   public static void main(String[] args) {
       int largeIntValue = 200; // Cette valeur est en dehors de la plage d'un octet (byte)
   
       // Tentative d'assigner une grande valeur int à une variable byte
       // byte myByte = largeIntValue; // Cette ligne causera une erreur de compilation
   
       System.out.println("Integer value: " + largeIntValue);
   
       // Pour assigner un entier plus grand à un octet (byte), vous avez besoin d'un cast
       byte castedByte = (byte) largeIntValue;
       System.out.println("Casted byte value: " + castedByte);
   }
   

   Examinons les modifications :

   • Nous déclarons une variable int nommée largeIntValue et lui assignons la valeur 200, qui est supérieure à la valeur maximale qu'un byte peut contenir (127).
   • La ligne commentée byte myByte = largeIntValue; montre ce qui se passerait si vous essayiez directement d'assigner largeIntValue à un byte. Cela entraînerait une erreur de compilation car Java vous empêche de perdre potentiellement des données sans lui avoir explicitement demandé de le faire.
   • La ligne byte castedByte = (byte) largeIntValue; montre comment forcer l'assignation en utilisant un cast de type. Le (byte) avant largeIntValue indique à Java de convertir la valeur int en un byte.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Maintenant, essayez de compiler le programme modifié dans le terminal :

   javac HelloJava.java
   

   Cette fois, la compilation devrait réussir car nous avons utilisé un cast de type.

5. Exécutez le programme compilé :

   java HelloJava
   

   Vous verrez la sortie suivante :

   Integer value: 200
   Casted byte value: -56
   

Notez que la valeur de castedByte est -56, et non 200. Cela s'explique par le fait que lorsque vous effectuez un cast d'une valeur en dehors de la plage du type cible, la valeur "reboucle". Cela est connu sous le nom de débordement (ou sous-débordement pour les nombres négatifs). La valeur 200 est représentée en binaire, et lorsqu'elle est tronquée pour s'adapter à 8 bits (un octet), cela donne la valeur -56.

Cette étape souligne l'importance de comprendre les plages des types de données et d'utiliser avec soin le cast de type lors de la conversion entre différents types pour éviter des résultats inattendus dus au débordement ou au sous-débordement.

Tester avec des cas limites

Dans les étapes précédentes, nous avons vu la plage du type de données byte et ce qui se passe lorsque nous essayons d'assigner une valeur en dehors de cette plage en utilisant un cast. Maintenant, testons spécifiquement les cas limites, qui sont les valeurs minimale et maximale de la plage d'un byte (-128 et 127), ainsi que les valeurs juste en dehors de cette plage.

Tester les cas limites est une pratique courante en programmation pour s'assurer que votre code se comporte correctement aux limites des valeurs attendues.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

2. Modifiez la méthode main pour tester les valeurs autour des limites d'un octet (byte). Remplacez le code existant à l'intérieur de la méthode main par le code suivant :

   public class HelloJava {
       public static void main(String[] args) {
           // Valeurs dans la plage d'un octet (byte)
           byte valueWithinRange1 = 0;
           byte valueWithinRange2 = 100;
           byte valueWithinRange3 = -50;
   
           System.out.println("Value within range 1: " + valueWithinRange1);
           System.out.println("Value within range 2: " + valueWithinRange2);
           System.out.println("Value within range 3: " + valueWithinRange3);
   
           // Cas limites
           byte minByte = -128;
           byte maxByte = 127;
   
           System.out.println("Minimum byte value: " + minByte);
           System.out.println("Maximum byte value: " + maxByte);
   
           // Valeurs juste en dehors de la plage d'un octet (byte) (nécessitent un cast)
           int valueJustBelowMin = -129;
           int valueJustAboveMax = 128;
   
           byte castedBelowMin = (byte) valueJustBelowMin;
           byte castedAboveMax = (byte) valueJustAboveMax;
   
           System.out.println("Value just below min (-129) casted to byte: " + castedBelowMin);
           System.out.println("Value just above max (128) casted to byte: " + castedAboveMax);
       }
   }
   

   Dans ce code, nous testons :

   • Des valeurs bien dans la plage d'un octet (byte).
   • Les valeurs minimale et maximale exactes de la plage d'un octet (byte).
   • Des valeurs juste en dehors des limites minimale et maximale, en utilisant un cast pour voir l'effet de débordement/sous-débordement.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme dans le terminal :

   javac HelloJava.java
   

   La compilation devrait réussir.

5. Exécutez le programme compilé :

   java HelloJava
   

   Vous devriez voir une sortie similaire à celle-ci :

   Value within range 1: 0
   Value within range 2: 100
   Value within range 3: -50
   Minimum byte value: -128
   Maximum byte value: 127
   Value just below min (-129) casted to byte: 127
   Value just above max (128) casted to byte: -128
   

Observez la sortie pour les valeurs juste en dehors de la plage.

• Le cast de -129 en un octet (byte) donne 127. Cela s'explique par le fait que -129 est inférieur de 1 à la valeur minimale (-128), et en raison de l'effet de rebouclage, il devient la valeur maximale (127).
• Le cast de 128 en un octet (byte) donne -128. Cela s'explique par le fait que 128 est supérieur de 1 à la valeur maximale (127), et il reboucle à la valeur minimale (-128).

Cela démontre la nature cyclique du débordement/sous-débordement d'entiers lors du cast de valeurs en dehors de la plage d'un type de données de taille fixe comme byte.

Résumé

Dans ce laboratoire (lab), nous avons commencé par comprendre le concept fondamental du type de données byte en Java, en particulier sa plage définie de -128 à 127. Nous avons appris que cette plage est déterminée par les 8 bits utilisés pour représenter un octet (byte), permettant 256 valeurs distinctes. Grâce à un programme Java pratique, nous avons démontré comment déclarer et afficher les valeurs minimale et maximale qu'une variable byte peut contenir, confirmant ainsi la plage définie. Cette première étape a fourni une solide base pour les étapes suivantes consistant à comparer des entiers avec ces limites d'octet (byte) et à tester les cas limites.