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

Введение

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

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

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-560006{{"Как проверить, находится ли целое число в диапазоне байта в Java"}} java/type_casting -.-> lab-560006{{"Как проверить, находится ли целое число в диапазоне байта в Java"}} end

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

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

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

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

Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт.
Замените все содержимое файла следующим кодом:
```
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 для вывода этих значений в консоль.
Сохраните файл (Ctrl+S или Cmd+S).
Теперь скомпилируем нашу программу. Откройте терминал внизу WebIDE и убедитесь, что вы находитесь в директории ~/project. Затем выполните следующую команду:
```
javac HelloJava.java
```
Если компиляция прошла успешно, вы не увидите никакого вывода.
Наконец, запустите скомпилированную программу с помощью команды java:
```
java HelloJava
```
Вы должны увидеть следующий вывод, показывающий минимальное и максимальное значения, которые может хранить byte:
```
Minimum byte value: -128
Maximum byte value: 127
```

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

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

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

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

Откройте файл HelloJava.java в редакторе WebIDE.
Измените метод 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.
Сохраните файл (Ctrl+S или Cmd+S).
Теперь попробуйте скомпилировать измененную программу в терминале:
```
javac HelloJava.java
```
На этот раз компиляция должна пройти успешно, так как мы использовали приведение типов.
Запустите скомпилированную программу:
```
java HelloJava
```
Вы увидите следующий вывод:
```
Integer value: 200
Casted byte value: -56
```

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

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

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

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

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

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

Измените метод 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);
    }
}

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

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

Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу в терминале:
```
javac HelloJava.java
```
Компиляция должна пройти успешно.

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

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, тем самым подтвердив определенный диапазон. Этот первый этап создал прочную основу для последующих этапов сравнения целых чисел с этими пределами байта и тестирования граничных случаев.