Как проверить, находится ли целое число в диапазоне типа short в Java

Введение

В этом лабораторном занятии (LabEx) вы научитесь проверять, попадает ли целочисленное значение в диапазон типа данных short в Java. Сначала мы разберем определенный диапазон short (-32768 до 32767), а затем проверим целочисленные значения на соответствие этим пределам. Наконец, мы рассмотрим, как эффективно обрабатывать граничные значения.

Установить диапазон short (-32768 до 32767)

На этом этапе мы рассмотрим тип данных short в Java и узнаем его диапазон. В программировании типы данных используются для классификации различных типов данных, которые может хранить переменная. Тип данных short представляет собой 16-разрядное знаковое целое число в дополнительном коде. Это означает, что он может хранить целые числа, как положительные, так и отрицательные, в определенном диапазоне.

Диапазон типа short в Java составляет от -32 768 до 32 767. Понимание этих пределов является важным для избежания ошибок, таких как переполнение (overflow) или недополнение (underflow), которые возникают, когда вы пытаетесь сохранить значение вне диапазона типа данных.

Давайте создадим простую программу на Java, чтобы увидеть, как работает тип данных short и наблюдать его пределы.

1. Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт.

2. Замените все содержимое файла следующим кодом:

   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);
       }
   }
   

   В этом коде:

   • Мы объявляем переменную myShort типа short и присваиваем ей значение 10000.
   • Затем мы объявляем maxShort и minShort и присваиваем им максимальное и минимальное значения, которые может хранить тип short.
   • Мы используем System.out.println() для вывода значений этих переменных в консоль.

3. Сохраните файл (Ctrl+S или Cmd+S).

4. Теперь давайте скомпилируем нашу программу. Откройте терминал в нижней части WebIDE и убедитесь, что вы находитесь в директории ~/project. Если нет, используйте команду cd ~/project. Затем скомпилируйте код с помощью команды javac:

   javac HelloJava.java
   

   Если нет ошибок, компиляция прошла успешно, и в директории ~/project будет создан файл HelloJava.class.

5. Наконец, запустите скомпилированную программу с помощью команды java:

   java HelloJava
   

   В терминале вы должны увидеть следующий вывод:

   My short variable: 10000
   Maximum short value: 32767
   Minimum short value: -32768
   

Этот вывод подтверждает, что наши переменные типа short хранят ожидаемые значения в пределах определенного диапазона. На следующем этапе мы рассмотрим, что происходит, когда мы пытаемся присвоить значения вне этого диапазона.

Проверить целое число на соответствие границам типа short

На предыдущем этапе мы узнали, как объявлять и использовать переменные типа short в рамках их допустимого диапазона. Теперь давайте рассмотрим, что происходит, когда мы пытаемся присвоить значение, выходящее за пределы диапазона short, переменной типа short.

В Java есть различные целочисленные типы данных, включая byte, short, int и long, каждый с разным диапазоном значений. Тип int (целое число) представляет собой 32 - разрядное знаковое целое число в дополнительном коде с диапазоном от -2 147 483 648 до 2 147 483 647. Этот диапазон значительно шире, чем у типа short.

Когда вы пытаетесь присвоить значение из более широкого типа данных (например, int) более узкому типу (например, short), Java требует, чтобы вы явно указали, что вы осознаете возможную потерю информации. Это называется приведением типов (type casting). Если вы не выполните приведение типов, Java выдаст ошибку компиляции, чтобы предотвратить случайную потерю данных.

Давайте модифицируем нашу программу HelloJava.java, чтобы продемонстрировать это.

1. Откройте файл HelloJava.java в редакторе WebIDE.

2. Замените существующий код следующим:

   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);
       }
   }
   

   В этом обновленном коде:

   • Мы объявляем переменную largeInt типа int со значением 40000, которое превышает максимальное значение, которое может хранить тип short (32767).
   • Закомментированная строка short myShort = largeInt; показывает, что произойдет без приведения типов - ошибка компиляции.
   • Строка short myShort = (short) largeInt; демонстрирует, как привести значение типа int к типу short. (short) перед largeInt - это оператор приведения типов.
   • Мы делаем то же самое для отрицательного значения anotherLargeInt (-40000), которое меньше минимального значения, которое может хранить тип short (-32768).

3. Сохраните файл (Ctrl+S или Cmd+S).

4. Теперь скомпилируйте модифицированную программу в терминале:

   javac HelloJava.java
   

   На этот раз компиляция должна пройти успешно, так как мы использовали приведение типов.

5. Запустите скомпилированную программу:

   java HelloJava
   

   Вы увидите вывод, похожий на следующий:

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

Обратите внимание, что выходные значения (-25536 и 25536) не совпадают с исходными значениями (40000 и -40000). Это происходит потому, что при приведении значения, выходящего за пределы диапазона целевого типа данных, значение "зацикливается". Это пример переполнения (overflow) (для положительных значений, превышающих максимум) и недополнения (underflow) (для отрицательных значений, превышающих минимум). Точное результирующее значение зависит от того, как числа представлены в двоичной системе. Это демонстрирует, почему важно понимать диапазоны типов данных и аккуратно использовать приведение типов, чтобы избежать непредвиденных результатов.

Обработка граничных значений

На предыдущих этапах мы узнали о диапазоне значений типа данных short и увидели, что происходит при приведении больших целочисленных значений, выходящих за этот диапазон. Также важно понять, как Java обрабатывает значения, находящиеся именно на границах диапазона short (-32768 и 32767).

При работе с граничными значениями необходимо быть осторожными, особенно при выполнении арифметических операций. Прибавление 1 к максимальному значению или вычитание 1 из минимального значения может привести к переполнению (overflow) или недополнению (underflow), в результате чего значение "зацикливается" до другого конца диапазона.

Давайте последний раз модифицируем нашу программу HelloJava.java, чтобы продемонстрировать такое поведение на границах диапазона.

1. Откройте файл HelloJava.java в редакторе WebIDE.

2. Замените существующий код следующим:

   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);
       }
   }
   

   В этом коде:

   • Мы начинаем с максимального значения типа short (maxShort).
   • Мы прибавляем 1 к maxShort. По умолчанию арифметические операции, включающие типы short (и byte), преобразуются в тип int. Поэтому результат maxShort + 1 представляет собой значение типа int. Мы сохраняем это значение в переменной overflowInt.
   • Затем мы преобразуем overflowInt обратно в тип short и сохраняем его в переменной overflowShort. Именно здесь происходит переполнение, и значение "зацикливается".
   • Мы выполняем аналогичные операции с минимальным значением типа short (minShort), вычитая 1, чтобы продемонстрировать недополнение.

3. Сохраните файл (Ctrl+S или Cmd+S).

4. Скомпилируйте программу в терминале:

   javac HelloJava.java
   

5. Запустите скомпилированную программу:

   java HelloJava
   

   Вы должны увидеть вывод, похожий на следующий:

   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
   

Как вы можете видеть, когда мы прибавляем 1 к максимальному значению типа short (32767) и преобразуем его обратно в тип short, оно "зацикливается" до минимального значения (-32768). Аналогично, при вычитании 1 из минимального значения типа short (-32768) и преобразовании обратно в тип short оно "зацикливается" до максимального значения (32767).

Важно помнить об этом поведении при работе с целочисленными типами фиксированного размера, такими как short. Всегда будьте внимательны к диапазону значений типа данных, чтобы избежать непредвиденных результатов из - за переполнения или недополнения.

Резюме

В этом практическом занятии (lab) мы изучили тип данных short в Java, поняли, что он представляет собой 16 - разрядное знаковое целое число в дополнительном коде, и узнали его конкретный диапазон от -32 768 до 32 767. Мы рассмотрели, как объявлять и инициализировать переменные типа short и продемонстрировали максимальные и минимальные значения, которые он может хранить, с помощью простой Java - программы. Этот базовый этап является важным для предотвращения потенциальных ошибок переполнения (overflow) или недополнения (underflow) при работе с целочисленными значениями в этом диапазоне.