So prüfen Sie, ob eine Ganzzahl im Byte-Bereich in Java liegt

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein ganzzahliger Wert im Bereich des byte-Datentyps in Java liegt. Wir beginnen damit, den definierten Bereich eines Bytes zu verstehen, der von -128 bis 127 reicht.

Anschließend lernen Sie, wie Sie einen Integer mit diesen Byte-Grenzwerten vergleichen, um festzustellen, ob er im gültigen Bereich liegt. Abschließend testen wir die Logik mit Randfällen, um deren Korrektheit sicherzustellen.

Byte-Bereich definieren (-128 bis 127)

In diesem Schritt werden wir uns mit dem byte-Datentyp in Java befassen und seinen Bereich verstehen. Der byte-Datentyp ist einer der primitiven Datentypen in Java und wird zum Speichern kleiner ganzzahliger Werte verwendet.

Eine byte-Variable kann ganzzahlige Werte von -128 bis 127 (einschließlich) aufnehmen. Dies liegt daran, dass ein Byte 8 Bits Speicherplatz verwendet, und mit 8 Bits können 2^8 = 256 verschiedene Werte dargestellt werden. Diese Werte sind auf negative und positive Zahlen verteilt, einschließlich Null.

Lassen Sie uns ein einfaches Java-Programm erstellen, um den byte-Datentyp zu demonstrieren.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.
Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:
```
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);
    }
}
```
In diesem Code:
- Wir deklarieren eine byte-Variable minByteValue und weisen ihr den minimal möglichen Wert für ein Byte zu, der -128 ist.
- Wir deklarieren eine weitere byte-Variable maxByteValue und weisen ihr den maximal möglichen Wert für ein Byte zu, der 127 ist.
- Anschließend verwenden wir System.out.println, um diese Werte in der Konsole auszugeben.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt lassen Sie uns unser Programm kompilieren. Öffnen Sie das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Führen Sie dann folgenden Befehl aus:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.
Führen Sie schließlich das kompilierte Programm mit dem java-Befehl aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen, die die minimalen und maximalen Werte zeigt, die ein byte aufnehmen kann:
```
Minimum byte value: -128
Maximum byte value: 127
```

Dieses Programm demonstriert den definierten Bereich des byte-Datentyps in Java. Das Verständnis dieser Grenzen ist wichtig, wenn Sie den geeigneten Datentyp für Ihre Variablen auswählen, um potenzielle Probleme wie Überläufe zu vermeiden.

Ganzzahl mit Byte-Grenzwerten vergleichen

Im vorherigen Schritt haben wir uns mit dem Bereich des byte-Datentyps (-128 bis 127) vertraut gemacht. Jetzt schauen wir uns an, was passiert, wenn wir versuchen, einem byte-Variablen einen ganzzahligen Wert zuzuweisen, der außerhalb dieses Bereichs liegt.

Java verfügt über andere ganzzahlige Datentypen wie int, die viel größere Werte aufnehmen können. Wenn Sie versuchen, einen größeren Wert in einen kleineren Container zu packen (z. B. einen int-Wert in ein byte), können Probleme auftreten.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Modifizieren Sie die main-Methode, um einen ganzzahligen Wert einzubeziehen, der außerhalb des Byte-Bereichs liegt. Ersetzen Sie den vorhandenen Code innerhalb der main-Methode durch Folgendes:
```
public static void main(String[] args) {
    int largeIntValue = 200; // Dieser Wert liegt außerhalb des Byte-Bereichs

    // Versuch, einen großen int-Wert einer byte-Variablen zuzuweisen
    // byte myByte = largeIntValue; // Diese Zeile würde einen Kompilierungsfehler verursachen

    System.out.println("Integer value: " + largeIntValue);

    // Um einen größeren Integer einem Byte zuzuweisen, benötigen Sie eine Typumwandlung (Cast)
    byte castedByte = (byte) largeIntValue;
    System.out.println("Casted byte value: " + castedByte);
}
```
Schauen wir uns die Änderungen an:
- Wir deklarieren eine int-Variable largeIntValue und weisen ihr den Wert 200 zu, der größer ist als der maximale Wert, den ein byte aufnehmen kann (127).
- Die auskommentierte Zeile byte myByte = largeIntValue; zeigt, was passieren würde, wenn Sie direkt versuchen, largeIntValue einem byte zuzuweisen. Dies würde zu einem Kompilierungsfehler führen, da Java Sie daran hindert, möglicherweise Daten zu verlieren, ohne es ausdrücklich zu erlauben.
- Die Zeile byte castedByte = (byte) largeIntValue; zeigt, wie Sie die Zuweisung mithilfe einer Typumwandlung (Cast) erzwingen können. Das (byte) vor largeIntValue teilt Java mit, den int-Wert in ein byte umzuwandeln.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Versuchen Sie nun, das modifizierte Programm im Terminal zu kompilieren:
```
javac HelloJava.java
```
Diesmal sollte die Kompilierung erfolgreich sein, da wir eine Typumwandlung verwendet haben.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie werden die folgende Ausgabe sehen:
```
Integer value: 200
Casted byte value: -56
```

Beachten Sie, dass der Wert von castedByte -56 und nicht 200 ist. Dies liegt daran, dass wenn Sie einen Wert, der außerhalb des Bereichs des Zieltyps liegt, umwandeln, der Wert "überläuft" (wraparound). Dies wird als Überlauf (oder Unterlauf für negative Zahlen) bezeichnet. Der Wert 200 wird in Binärdarstellung repräsentiert, und wenn er auf 8 Bits (ein Byte) gekürzt wird, ergibt sich der Wert -56.

Dieser Schritt zeigt die Wichtigkeit des Verständnisses von Datentypbereichen und die vorsichtige Verwendung von Typumwandlungen beim Konvertieren zwischen verschiedenen Typen, um unerwartete Ergebnisse aufgrund von Überlauf oder Unterlauf zu vermeiden.

Mit Randfällen testen

In den vorherigen Schritten haben wir uns mit dem Bereich des byte-Datentyps vertraut gemacht und gesehen, was passiert, wenn wir versuchen, einen Wert außerhalb dieses Bereichs mithilfe von Typumwandlung (Casting) zuzuweisen. Jetzt wollen wir speziell die Randfälle testen, also die minimalen und maximalen Werte des byte-Bereichs (-128 und 127) sowie Werte, die gerade außerhalb dieses Bereichs liegen.

Das Testen von Randfällen ist eine gängige Praxis in der Programmierung, um sicherzustellen, dass Ihr Code an den Grenzen der erwarteten Werte korrekt funktioniert.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Modifizieren Sie die main-Methode, um Werte um die Byte-Grenzen herum zu testen. Ersetzen Sie den vorhandenen Code innerhalb der main-Methode durch Folgendes:

public class HelloJava {
    public static void main(String[] args) {
        // Werte innerhalb des Byte-Bereichs
        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);

        // Randfälle
        byte minByte = -128;
        byte maxByte = 127;

        System.out.println("Minimum byte value: " + minByte);
        System.out.println("Maximum byte value: " + maxByte);

        // Werte gerade außerhalb des Byte-Bereichs (erfordern Typumwandlung)
        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);
    }
}

In diesem Code testen wir:

Werte, die sicher innerhalb des Byte-Bereichs liegen.
Die exakten minimalen und maximalen Werte des Byte-Bereichs.
Werte, die gerade außerhalb des minimalen und maximalen Bereichs liegen, und zwar mithilfe von Typumwandlung, um die Auswirkungen von Überlauf/Unterlauf zu sehen.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Die Kompilierung sollte erfolgreich sein.

Führen Sie das kompilierte Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Beobachten Sie die Ausgabe für die Werte, die gerade außerhalb des Bereichs liegen.

Die Typumwandlung von -129 in ein Byte ergibt 127. Dies liegt daran, dass -129 um eins kleiner als der minimale Wert (-128) ist, und aufgrund des Wrap-around-Effekts wird es zum maximalen Wert (127).
Die Typumwandlung von 128 in ein Byte ergibt -128. Dies liegt daran, dass 128 um eins größer als der maximale Wert (127) ist, und es wrappt um zum minimalen Wert (-128).

Dies zeigt die zyklische Natur des ganzzahligen Überlaufs/Unterlaufs bei der Typumwandlung von Werten außerhalb des Bereichs eines Datentyps fester Größe wie byte.

Zusammenfassung

In diesem Lab haben wir zunächst das grundlegende Konzept des byte-Datentyps in Java verstanden, insbesondere seinen definierten Bereich von -128 bis 127. Wir haben gelernt, dass dieser Bereich durch die 8 Bits bestimmt wird, die zur Darstellung eines Bytes verwendet werden und 256 verschiedene Werte ermöglichen. Mittels eines praktischen Java-Programms haben wir gezeigt, wie man die minimalen und maximalen Werte, die eine byte-Variable aufnehmen kann, deklariert und ausgibt, und so den definierten Bereich bestätigt. Dieser erste Schritt bildete eine solide Grundlage für die folgenden Schritte, in denen wir Ganzzahlen mit diesen Byte-Grenzwerten verglichen und Randfälle getestet haben.