Como Verificar se um Inteiro Está Dentro da Faixa de Byte em Java - Tutorial

Introdução

Neste laboratório, você aprenderá como verificar se um valor inteiro está dentro da faixa do tipo de dado byte em Java. Começaremos entendendo a faixa definida de um byte, que é de -128 a 127.

Em seguida, você aprenderá como comparar um inteiro com esses limites de byte para determinar se ele está dentro da faixa válida. Finalmente, testaremos a lógica com casos extremos (edge cases) para garantir sua correção.

Definir a Faixa de Byte (-128 a 127)

Nesta etapa, exploraremos o tipo de dado byte em Java e entenderemos sua faixa. O tipo de dado byte é um dos tipos de dados primitivos em Java, usado para armazenar pequenos valores inteiros.

Uma variável byte pode conter valores inteiros de -128 a 127, inclusive. Isso ocorre porque um byte usa 8 bits de memória, e com 8 bits, você pode representar 2^8 = 256 valores diferentes. Esses valores são divididos entre números negativos e positivos, incluindo zero.

Vamos criar um programa Java simples para demonstrar o tipo de dado byte.

Abra o arquivo HelloJava.java no editor WebIDE, caso ainda não esteja aberto.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
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);
    }
}
```
Neste código:
- Declaramos uma variável byte chamada minByteValue e atribuímos a ela o valor mínimo possível para um byte, que é -128.
- Declaramos outra variável byte chamada maxByteValue e atribuímos a ela o valor máximo possível para um byte, que é 127.
- Em seguida, usamos System.out.println para imprimir esses valores no console.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, vamos compilar nosso programa. Abra o Terminal na parte inferior do WebIDE e certifique-se de estar no diretório ~/project. Em seguida, execute o seguinte comando:
```
javac HelloJava.java
```
Se a compilação for bem-sucedida, você não verá nenhuma saída.
Finalmente, execute o programa compilado usando o comando java:
```
java HelloJava
```
Você deve ver a seguinte saída, mostrando os valores mínimo e máximo que um byte pode conter:
```
Minimum byte value: -128
Maximum byte value: 127
```

Este programa demonstra a faixa definida do tipo de dado byte em Java. Entender esses limites é importante ao escolher o tipo de dado apropriado para suas variáveis, a fim de evitar possíveis problemas como overflow (estouro).

Comparar Inteiro com Limites de Byte

Na etapa anterior, aprendemos sobre a faixa do tipo de dado byte (-128 a 127). Agora, vamos ver o que acontece quando tentamos atribuir um valor inteiro que está fora dessa faixa a uma variável byte.

Java possui outros tipos de dados inteiros como int, que podem conter valores muito maiores. Quando você tenta colocar um valor maior em um contêiner menor (como colocar um valor int em um byte), pode encontrar problemas.

Abra o arquivo HelloJava.java no editor WebIDE.
Modifique o método main para incluir um valor inteiro que está fora da faixa de byte. Substitua o código existente dentro do método main pelo seguinte:
```
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);
}
```
Vamos analisar as alterações:
- Declaramos uma variável int chamada largeIntValue e atribuímos a ela o valor 200, que é maior que o valor máximo que um byte pode conter (127).
- A linha comentada byte myByte = largeIntValue; mostra o que aconteceria se você tentasse atribuir diretamente largeIntValue a um byte. Isso resultaria em um erro de compilação porque Java impede que você potencialmente perca dados sem explicitamente dizer para fazê-lo.
- A linha byte castedByte = (byte) largeIntValue; demonstra como forçar a atribuição usando um type cast (conversão de tipo). O (byte) antes de largeIntValue diz ao Java para converter o valor int em um byte.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, tente compilar o programa modificado no Terminal:
```
javac HelloJava.java
```
Desta vez, a compilação deve ser bem-sucedida porque usamos um type cast.

Execute o programa compilado:

java HelloJava

Você verá a seguinte saída:

Integer value: 200
Casted byte value: -56

Observe que o valor de castedByte é -56, não 200. Isso ocorre porque, quando você converte um valor que está fora da faixa do tipo de destino, o valor "envolve" (wraps around). Isso é conhecido como overflow (ou underflow para números negativos). O valor 200 é representado em binário, e quando é truncado para caber em 8 bits (um byte), resulta no valor -56.

Esta etapa destaca a importância de entender as faixas de tipos de dados e usar a conversão de tipo com cuidado ao converter entre diferentes tipos para evitar resultados inesperados devido a overflow ou underflow.

Testar com Casos Extremos (Edge Cases)

Nas etapas anteriores, vimos a faixa do tipo de dado byte e o que acontece quando tentamos atribuir um valor fora dessa faixa usando casting (conversão de tipo). Agora, vamos testar especificamente os casos extremos (edge cases), que são os valores mínimo e máximo da faixa byte (-128 e 127), e valores logo fora dessa faixa.

Testar casos extremos é uma prática comum em programação para garantir que seu código se comporte corretamente nos limites dos valores esperados.

Abra o arquivo HelloJava.java no editor WebIDE.

Modifique o método main para testar valores em torno dos limites de byte. Substitua o código existente dentro do método main pelo seguinte:

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

Neste código, estamos testando:

Valores confortavelmente dentro da faixa de byte.
Os valores mínimo e máximo exatos da faixa de byte.
Valores logo fora da faixa mínima e máxima, usando casting para ver o efeito de overflow/underflow.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```
A compilação deve ser bem-sucedida.

Execute o programa compilado:

java HelloJava

Você deve ver uma saída semelhante a esta:

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

Observe a saída para os valores logo fora da faixa.

Converter -129 para um byte resulta em 127. Isso ocorre porque -129 é um a menos que o valor mínimo (-128), e devido ao efeito de wrap-around (envolvimento), ele se torna o valor máximo (127).
Converter 128 para um byte resulta em -128. Isso ocorre porque 128 é um a mais que o valor máximo (127), e ele envolve para o valor mínimo (-128).

Isso demonstra a natureza cíclica do overflow/underflow de inteiros ao converter valores fora da faixa de um tipo de dado de tamanho fixo como byte.

Resumo

Neste laboratório, começamos entendendo o conceito fundamental do tipo de dado byte em Java, especificamente sua faixa definida de -128 a 127. Aprendemos que essa faixa é determinada pelos 8 bits usados para representar um byte, permitindo 256 valores distintos. Por meio de um programa Java prático, demonstramos como declarar e imprimir os valores mínimo e máximo que uma variável byte pode conter, confirmando a faixa definida. Esta etapa inicial forneceu uma base sólida para as etapas subsequentes de comparação de inteiros com esses limites de byte e testes com casos extremos.