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

Введение

В этом лабораторном занятии вы научитесь проверять, попадает ли целочисленное значение в диапазон данных типа byte в Java. Сначала мы рассмотрим определенный диапазон байта, который составляет от -128 до 127.

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

Определить диапазон байта (-128 до 127)

На этом этапе мы рассмотрим тип данных byte в Java и узнаем его диапазон. Тип данных byte является одним из примитивных типов данных в Java, используемых для хранения небольших целочисленных значений.

Переменная типа byte может хранить целочисленные значения от -128 до 127 включительно. Это происходит потому, что байт использует 8 бит памяти, и с 8 битами можно представить 2^8 = 256 различных значений. Эти значения разделены между отрицательными и положительными числами, включая ноль.

Создадим простую программу на Java, чтобы продемонстрировать тип данных byte.

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

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

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

   В этом коде:

   • Мы объявляем переменную byte с именем minByteValue и присваиваем ей минимально возможное значение для байта, которое равно -128.
   • Мы объявляем еще одну переменную byte с именем maxByteValue и присваиваем ей максимально возможное значение для байта, которое равно 127.
   • Затем мы используем System.out.println для вывода этих значений в консоль.

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

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

   javac HelloJava.java
   

   Если компиляция прошла успешно, вы не увидите никакого вывода.

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

   java HelloJava
   

   Вы должны увидеть следующий вывод, показывающий минимальное и максимальное значения, которые может хранить byte:

   Minimum byte value: -128
   Maximum byte value: 127
   

Эта программа демонстрирует определенный диапазон типа данных byte в Java. Понимание этих пределов важно при выборе подходящего типа данных для ваших переменных, чтобы избежать таких потенциальных проблем, как переполнение.

Сравнить целое число с пределами байта

На предыдущем этапе мы узнали о диапазоне типа данных byte (-128 до 127). Теперь давайте посмотрим, что произойдет, если мы попытаемся присвоить целочисленное значение, выходящее за этот диапазон, переменной типа byte.

В Java есть другие целочисленные типы данных, такие как int, которые могут хранить гораздо большие значения. Когда вы пытаетесь поместить большее значение в меньший контейнер (например, поместить значение int в byte), вы можете столкнуться с проблемами.

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

2. Измените метод main, чтобы он включал целочисленное значение, выходящее за диапазон байта. Замените существующий код внутри метода main следующим:

   public static void main(String[] args) {
       int largeIntValue = 200; // This value is outside the byte range
   
       // Trying to assign a large int value to a byte variable
       // byte myByte = largeIntValue; // This line will cause a compilation error
   
       System.out.println("Integer value: " + largeIntValue);
   
       // To assign a larger integer to a byte, you need a cast
       byte castedByte = (byte) largeIntValue;
       System.out.println("Casted byte value: " + castedByte);
   }
   

   Рассмотрим внесенные изменения:

   • Мы объявляем переменную int с именем largeIntValue и присваиваем ей значение 200, которое больше максимального значения, которое может хранить byte (127).
   • Закомментированная строка byte myByte = largeIntValue; показывает, что произойдет, если вы напрямую попытаетесь присвоить largeIntValue переменной типа byte. Это вызовет ошибку компиляции, так как Java не позволяет потенциально потерять данные без явного указания на это.
   • Строка byte castedByte = (byte) largeIntValue; демонстрирует, как принудительно выполнить присвоение с использованием приведения типов. (byte) перед largeIntValue сообщает Java преобразовать значение int в byte.

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

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

   javac HelloJava.java
   

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

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

   java HelloJava
   

   Вы увидите следующий вывод:

   Integer value: 200
   Casted byte value: -56
   

Обратите внимание, что значение castedByte равно -56, а не 200. Это происходит потому, что когда вы приводите значение, выходящее за диапазон целевого типа, значение "зацикливается". Это называется переполнением (или потерянной точностью для отрицательных чисел). Значение 200 представлено в двоичной системе, и когда оно усекается до 8 бит (байта), получается значение -56.

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

Тестирование с использованием граничных случаев

На предыдущих этапах мы рассмотрели диапазон типа данных byte и то, что происходит, когда мы пытаемся присвоить значение, выходящее за этот диапазон, с использованием приведения типов. Теперь давайте специально протестируем граничные случаи, которые представляют собой минимальное и максимальное значения диапазона byte (-128 и 127), а также значения, чуть выходящие за этот диапазон.

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

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

2. Измените метод main для тестирования значений вокруг пределов байта. Замените существующий код внутри метода main следующим:

   public class HelloJava {
       public static void main(String[] args) {
           // Values within the byte range
           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);
   
           // Edge cases
           byte minByte = -128;
           byte maxByte = 127;
   
           System.out.println("Minimum byte value: " + minByte);
           System.out.println("Maximum byte value: " + maxByte);
   
           // Values just outside the byte range (require casting)
           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);
       }
   }
   

   В этом коде мы тестируем:

   • Значения, уверенно находящиеся в диапазоне байта.
   • Точные минимальное и максимальное значения диапазона байта.
   • Значения, чуть выходящие за минимальный и максимальный диапазон, используя приведение типов, чтобы увидеть эффект переполнения/потерянной точности.

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

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

   javac HelloJava.java
   

   Компиляция должна пройти успешно.

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

   java HelloJava
   

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

   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
   

Обратите внимание на вывод для значений, чуть выходящих за диапазон.

• Приведение -129 к типу байт дает 127. Это происходит потому, что -129 на единицу меньше минимального значения (-128), и из -за эффекта зацикливания оно становится максимальным значением (127).
• Приведение 128 к типу байт дает -128. Это происходит потому, что 128 на единицу больше максимального значения (127), и оно зацикливается до минимального значения (-128).

Это демонстрирует циклическую природу переполнения/потерянной точности целых чисел при приведении значений, выходящих за диапазон фиксированного по размеру типа данных, такого как byte.

Резюме

В этом практическом занятии (лабораторной работе) мы начали с понимания фундаментального концепта типа данных byte в Java, а именно его определенного диапазона от -128 до 127. Мы узнали, что этот диапазон определяется 8 битами, используемыми для представления байта, что позволяет получить 256 различных значений. С помощью практической Java - программы мы показали, как объявлять и выводить минимальное и максимальное значения, которые может хранить переменная типа byte, тем самым подтвердив определенный диапазон. Этот первый этап создал прочную основу для последующих этапов сравнения целых чисел с этими пределами байта и тестирования граничных случаев.