Comment vérifier si un entier est dans la plage du type short en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une valeur entière se situe dans la plage du type de données short en Java. Nous commencerons par comprendre la plage définie du type short (-32768 à 32767), puis nous passerons à la vérification des valeurs entières par rapport à ces limites. Enfin, nous explorerons comment gérer efficacement les valeurs limites.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java/BasicSyntaxGroup -.-> java/data_types("Data Types") java/BasicSyntaxGroup -.-> java/type_casting("Type Casting") subgraph Lab Skills java/data_types -.-> lab-560007{{"Comment vérifier si un entier est dans la plage du type short en Java"}} java/type_casting -.-> lab-560007{{"Comment vérifier si un entier est dans la plage du type short en Java"}} end

Définir la plage du type `short` (-32768 à 32767)

Dans cette étape, nous allons explorer le type de données short en Java et comprendre sa plage. En programmation, les types de données sont utilisés pour classer différents types de données qu'une variable peut contenir. Le type de données short est un entier signé sur 16 bits en complément à deux. Cela signifie qu'il peut stocker des nombres entiers, positifs et négatifs, dans une plage spécifique.

La plage d'un type short en Java va de -32 768 à 32 767. Comprendre ces limites est crucial pour éviter des erreurs telles que le débordement (overflow) ou le sous-débordement (underflow), qui se produisent lorsque vous essayez de stocker une valeur en dehors de la plage du type de données.

Créons un simple programme Java pour voir le type de données short en action et observer ses limites.

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

Remplacez tout le contenu du fichier par le code suivant :

public class HelloJava {
    public static void main(String[] args) {
        // Declare and initialize a short variable
        short myShort = 10000;
        System.out.println("My short variable: " + myShort);

        // Demonstrate the maximum value of short
        short maxShort = 32767;
        System.out.println("Maximum short value: " + maxShort);

        // Demonstrate the minimum value of short
        short minShort = -32768;
        System.out.println("Minimum short value: " + minShort);
    }
}

Dans ce code :

Nous déclarons une variable myShort de type short et lui assignons la valeur 10000.
Nous déclarons ensuite maxShort et minShort et leur assignons les valeurs maximale et minimale qu'un short peut contenir.
Nous utilisons System.out.println() pour afficher les valeurs de ces variables dans la console.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilons notre programme. Ouvrez le terminal en bas de l'éditeur WebIDE et assurez-vous que vous êtes dans le répertoire ~/project. Sinon, utilisez la commande cd ~/project. Ensuite, compilez le code en utilisant la commande javac :
```
javac HelloJava.java
```
S'il n'y a pas d'erreurs, la compilation est réussie et un fichier HelloJava.class sera créé dans le répertoire ~/project.
Enfin, exécutez le programme compilé en utilisant la commande java :
```
java HelloJava
```
Vous devriez voir la sortie suivante dans le terminal :
```
My short variable: 10000
Maximum short value: 32767
Minimum short value: -32768
```

Cette sortie confirme que nos variables de type short contiennent les valeurs attendues dans la plage définie. Dans l'étape suivante, nous explorerons ce qui se passe lorsque nous essayons d'assigner des valeurs en dehors de cette plage.

Vérifier un entier par rapport aux limites du type `short`

Dans l'étape précédente, nous avons vu comment déclarer et utiliser des variables de type short dans leur plage valide. Maintenant, explorons ce qui se passe lorsque nous essayons d'assigner une valeur en dehors de la plage du type short à une variable de ce type.

Java dispose de différents types de données entières, notamment byte, short, int et long, chacun ayant une plage différente. Un int (entier) est un entier signé sur 32 bits en complément à deux, avec une plage allant de -2 147 483 648 à 2 147 483 647. Cette plage est beaucoup plus large que celle d'un short.

Lorsque vous essayez d'assigner une valeur d'un type de données plus large (comme int) à un type de données plus petit (comme short), Java vous oblige à lui indiquer explicitement que vous êtes conscient du risque de perte d'informations. Cela s'appelle le transtypage (type casting). Si vous ne faites pas de transtypage, Java vous donnera une erreur de compilation pour éviter une perte de données accidentelle.

Modifions notre programme HelloJava.java pour illustrer cela.

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

Remplacez le code existant par le suivant :

public class HelloJava {
    public static void main(String[] args) {
        int largeInt = 40000; // This value is outside the short range

        // Attempt to assign largeInt to a short variable without casting
        // short myShort = largeInt; // This line will cause a compilation error

        // To assign a value from a larger type, we need to cast it
        short myShort = (short) largeInt;
        System.out.println("Value of largeInt cast to short: " + myShort);

        int anotherLargeInt = -40000; // Another value outside the short range
        short anotherShort = (short) anotherLargeInt;
        System.out.println("Value of anotherLargeInt cast to short: " + anotherShort);
    }
}

Dans ce code mis à jour :

Nous déclarons une variable int nommée largeInt avec la valeur 40000, qui est supérieure à la valeur maximale qu'un short peut contenir (32767).
La ligne commentée short myShort = largeInt; montre ce qui se passerait sans transtypage – une erreur de compilation.
La ligne short myShort = (short) largeInt; montre comment transtyper la valeur int en short. Le (short) avant largeInt est l'opérateur de transtypage.
Nous faisons de même pour une valeur négative anotherLargeInt (-40000), qui est inférieure à la valeur minimale qu'un short peut contenir (-32768).

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilez le programme modifié dans le terminal :
```
javac HelloJava.java
```
Cette fois, la compilation devrait réussir car nous avons utilisé le transtypage.

Exécutez le programme compilé :

java HelloJava

Vous verrez une sortie similaire à celle-ci :

Value of largeInt cast to short: -25536
Value of anotherLargeInt cast to short: 25536

Remarquez que les valeurs de sortie (-25536 et 25536) ne sont pas les valeurs originales (40000 et -40000). Cela s'explique par le fait que lorsque vous transtypez une valeur en dehors de la plage du type de données cible, la valeur "reboucle". Il s'agit d'un exemple de débordement (overflow) (pour les valeurs positives dépassant la valeur maximale) et de sous-débordement (underflow) (pour les valeurs négatives dépassant la valeur minimale). La valeur résultante exacte dépend de la représentation binaire des nombres. Cela montre pourquoi il est important de comprendre les plages des types de données et d'utiliser le transtypage avec précaution pour éviter des résultats inattendus.

Gérer les valeurs limites

Dans les étapes précédentes, nous avons appris sur la plage du type de données short et avons vu ce qui se passe lorsque nous transtypons des valeurs entières plus grandes qui sont en dehors de cette plage. Il est également important de comprendre comment Java gère les valeurs exactement aux limites de la plage du type short (-32768 et 32767).

Lorsque vous travaillez avec des valeurs aux limites, vous devez être prudent, surtout lors de l'exécution d'opérations arithmétiques. Ajouter 1 à la valeur maximale ou soustraire 1 de la valeur minimale peut entraîner un débordement (overflow) ou un sous-débordement (underflow), faisant reboucler la valeur à l'autre extrémité de la plage.

Modifions notre programme HelloJava.java une dernière fois pour illustrer ce comportement aux limites.

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

Remplacez le code existant par le suivant :

public class HelloJava {
    public static void main(String[] args) {
        short maxShort = 32767;
        System.out.println("Maximum short value: " + maxShort);

        // Adding 1 to the maximum short value
        // Note: The result of maxShort + 1 is an int by default
        int overflowInt = maxShort + 1;
        System.out.println("Maximum short + 1 (as int): " + overflowInt);

        // Casting the overflowed int back to short
        short overflowShort = (short) overflowInt;
        System.out.println("Maximum short + 1 (cast to short): " + overflowShort);

        short minShort = -32768;
        System.out.println("Minimum short value: " + minShort);

        // Subtracting 1 from the minimum short value
        // Note: The result of minShort - 1 is an int by default
        int underflowInt = minShort - 1;
        System.out.println("Minimum short - 1 (as int): " + underflowInt);

        // Casting the underflowed int back to short
        short underflowShort = (short) underflowInt;
        System.out.println("Minimum short - 1 (cast to short): " + underflowShort);
    }
}

Dans ce code :

Nous commençons par la valeur maximale du type short (maxShort).
Nous ajoutons 1 à maxShort. Par défaut, les opérations arithmétiques impliquant des types short (et byte) sont promues au type int. Ainsi, maxShort + 1 donne un résultat de type int. Nous stockons ce résultat dans overflowInt.
Nous transtypons ensuite overflowInt en short et le stockons dans overflowShort. C'est là que le débordement se produit, et la valeur reboucle.
Nous effectuons des opérations similaires avec la valeur minimale du type short (minShort), en soustrayant 1 pour illustrer le sous-débordement.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le terminal :
```
javac HelloJava.java
```

Exécutez le programme compilé :

java HelloJava

Vous devriez voir une sortie similaire à celle-ci :

Maximum short value: 32767
Maximum short + 1 (as int): 32768
Maximum short + 1 (cast to short): -32768
Minimum short value: -32768
Minimum short - 1 (as int): -32769
Minimum short - 1 (cast to short): 32767

Comme vous pouvez le voir, lorsque nous ajoutons 1 à la valeur maximale du type short (32767) et que nous la transtypons en short, elle reboucle à la valeur minimale (-32768). De même, en soustrayant 1 de la valeur minimale du type short (-32768) et en la transtypant en short, elle reboucle à la valeur maximale (32767).

Il est important de se rappeler de ce comportement lorsque vous travaillez avec des types entiers de taille fixe comme short. Toujours être attentif à la plage du type de données pour éviter des résultats inattendus dus au débordement ou au sous-débordement.

Résumé

Dans ce laboratoire (lab), nous avons appris sur le type de données short en Java, en comprenant sa nature de nombre signé sur 16 bits en complément à deux et sa plage spécifique allant de -32 768 à 32 767. Nous avons exploré comment déclarer et initialiser des variables de type short et avons démontré les valeurs maximale et minimale qu'il peut contenir grâce à un simple programme Java. Cette étape fondamentale est cruciale pour éviter les erreurs potentielles de débordement (overflow) ou de sous-débordement (underflow) lors du travail avec des valeurs entières dans cette plage.