So überprüfen Sie, ob eine Ganzzahl im short-Bereich in Java liegt

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein ganzzahliger Wert im Bereich des short-Datentyps in Java liegt. Wir beginnen damit, den definierten Bereich von short (-32768 bis 32767) zu verstehen und prüfen dann Ganzzahlen gegen diese Grenzen. Abschließend werden wir untersuchen, wie Sie Grenzwerte effektiv behandeln können.

Den short-Bereich festlegen (-32768 bis 32767)

In diesem Schritt werden wir uns mit dem short-Datentyp in Java befassen und seinen Bereich verstehen. In der Programmierung werden Datentypen verwendet, um verschiedene Arten von Daten zu klassifizieren, die eine Variable enthalten kann. Der short-Datentyp ist ein 16-Bit vorzeichenbehafteter Zweierkomplement-Ganzzahltyp. Das bedeutet, dass er ganze Zahlen, sowohl positive als auch negative, innerhalb eines bestimmten Bereichs speichern kann.

Der Bereich eines short in Java liegt zwischen -32.768 und 32.767. Das Verständnis dieser Grenzen ist entscheidend, um Fehler wie Überlauf (overflow) oder Unterlauf (underflow) zu vermeiden, die auftreten, wenn Sie einen Wert außerhalb des Bereichs des Datentyps speichern möchten.

Lassen Sie uns ein einfaches Java-Programm erstellen, um den short-Datentyp in Aktion zu sehen und seine Grenzen zu beobachten.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.

Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:

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

In diesem Code:

Wir deklarieren eine Variable myShort vom Typ short und weisen ihr den Wert 10000 zu.
Wir deklarieren dann maxShort und minShort und weisen ihnen die maximalen und minimalen Werte zu, die ein short aufnehmen kann.
Wir verwenden System.out.println(), um die Werte dieser Variablen 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. Wenn nicht, verwenden Sie den Befehl cd ~/project. Kompilieren Sie dann den Code mit dem Befehl javac:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, war die Kompilierung erfolgreich, und es wird eine Datei HelloJava.class im Verzeichnis ~/project erstellt.
Führen Sie schließlich das kompilierte Programm mit dem Befehl java aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe im Terminal sehen:
```
My short variable: 10000
Maximum short value: 32767
Minimum short value: -32768
```

Diese Ausgabe bestätigt, dass unsere short-Variablen die erwarteten Werte innerhalb des definierten Bereichs enthalten. Im nächsten Schritt werden wir untersuchen, was passiert, wenn wir versuchen, Werte außerhalb dieses Bereichs zuzuweisen.

Ganzzahl anhand der short-Grenzen überprüfen

Im vorherigen Schritt haben wir gesehen, wie man short-Variablen innerhalb ihres gültigen Bereichs deklariert und verwendet. Jetzt wollen wir untersuchen, was passiert, wenn wir versuchen, einem short-Variablen einen Wert zuzuweisen, der außerhalb des short-Bereichs liegt.

Java verfügt über verschiedene Ganzzahl-Datentypen, darunter byte, short, int und long, wobei jeder einen anderen Bereich hat. Ein int (Ganzzahl) ist ein 32-Bit vorzeichenbehafteter Zweierkomplement-Ganzzahltyp mit einem Bereich von -2.147.483.648 bis 2.147.483.647. Dieser Bereich ist viel größer als der von short.

Wenn Sie versuchen, einen Wert von einem größeren Datentyp (wie int) einem kleineren Datentyp (wie short) zuzuweisen, muss Java explizit wissen, dass Sie sich der möglichen Informationsverlust bewusst sind. Dies wird Typumwandlung (type casting) genannt. Wenn Sie keine Typumwandlung durchführen, gibt Java Ihnen einen Kompilierungsfehler, um versehentlichen Datenverlust zu vermeiden.

Lassen Sie uns unser HelloJava.java-Programm ändern, um dies zu demonstrieren.

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

Ersetzen Sie den vorhandenen Code durch den folgenden:

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

In diesem aktualisierten Code:

Wir deklarieren eine int-Variable largeInt mit dem Wert 40000, der größer ist als der maximale Wert, den ein short aufnehmen kann (32767).
Die auskommentierte Zeile short myShort = largeInt; zeigt, was passieren würde, wenn keine Typumwandlung durchgeführt würde – ein Kompilierungsfehler.
Die Zeile short myShort = (short) largeInt; zeigt, wie man den int-Wert in einen short umwandelt. Das (short) vor largeInt ist der Typumwandlungsoperator.
Wir tun dasselbe für einen negativen Wert anotherLargeInt (-40000), der kleiner ist als der minimale Wert, den ein short aufnehmen kann (-32768).

Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Diesmal sollte die Kompilierung erfolgreich sein, da wir die Typumwandlung verwendet haben.

Führen Sie das kompilierte Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Beachten Sie, dass die Ausgabewerte (-25536 und 25536) nicht die ursprünglichen Werte (40000 und -40000) sind. Dies liegt daran, dass wenn Sie einen Wert, der außerhalb des Bereichs des Ziel-Datentyps liegt, umwandeln, der Wert "überläuft" (wraps around). Dies ist ein Beispiel für Überlauf (overflow) (für positive Werte, die den Maximalwert überschreiten) und Unterlauf (underflow) (für negative Werte, die den Minimalwert unterschreiten). Der genaue resultierende Wert hängt davon ab, wie die Zahlen in Binärform dargestellt werden. Dies zeigt, warum es wichtig ist, die Bereiche der Datentypen zu verstehen und die Typumwandlung vorsichtig zu verwenden, um unerwartete Ergebnisse zu vermeiden.

Grenzwerte behandeln

In den vorherigen Schritten haben wir über den Bereich des short-Datentyps gelernt und gesehen, was passiert, wenn wir größere Ganzzahlwerte umwandeln, die außerhalb dieses Bereichs liegen. Es ist auch wichtig zu verstehen, wie Java Werte genau an den Grenzen des short-Bereichs (-32768 und 32767) behandelt.

Wenn Sie mit Werten an den Grenzen arbeiten, müssen Sie vorsichtig sein, insbesondere bei der Durchführung von arithmetischen Operationen. Das Hinzufügen von 1 zum maximalen Wert oder das Subtrahieren von 1 vom minimalen Wert kann zu Überlauf (overflow) oder Unterlauf (underflow) führen, wodurch der Wert an das andere Ende des Bereichs "springt".

Lassen Sie uns unser HelloJava.java-Programm ein letztes Mal ändern, um dieses Verhalten an den Grenzen zu demonstrieren.

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

Ersetzen Sie den vorhandenen Code durch den folgenden:

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

In diesem Code:

Wir beginnen mit dem maximalen short-Wert (maxShort).
Wir addieren 1 zu maxShort. Standardmäßig werden arithmetische Operationen mit short (und byte) zu int erweitert. Daher ergibt maxShort + 1 ein int. Wir speichern dies in overflowInt.
Wir wandeln dann overflowInt wieder in einen short um und speichern es in overflowShort. Hier tritt der Überlauf auf, und der Wert "springt" an das andere Ende des Bereichs.
Wir führen ähnliche Operationen mit dem minimalen short-Wert (minShort) durch, indem wir 1 subtrahieren, um den Unterlauf zu demonstrieren.

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

Führen Sie das kompilierte Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Wie Sie sehen können, wenn wir 1 zum maximalen short-Wert (32767) hinzufügen und ihn wieder in short umwandeln, "springt" er zum minimalen Wert (-32768). Ebenso "springt" das Subtrahieren von 1 vom minimalen short-Wert (-32768) und das Umwandeln zurück in short zum maximalen Wert (32767).

Dieses Verhalten ist wichtig zu beachten, wenn Sie mit Ganzzahltypen fester Größe wie short arbeiten. Seien Sie immer bewusst um den Bereich des Datentyps, um unerwartete Ergebnisse aufgrund von Überlauf oder Unterlauf zu vermeiden.

Zusammenfassung

In diesem Lab haben wir uns mit dem short-Datentyp in Java beschäftigt und verstanden, dass es sich um einen 16-Bit vorzeichenbehafteten Zweierkomplement-Typ handelt, dessen Bereich von -32.768 bis 32.767 reicht. Wir haben untersucht, wie man short-Variablen deklariert und initialisiert, und über ein einfaches Java-Programm die maximalen und minimalen Werte, die dieser Datentyp aufnehmen kann, demonstriert. Dieser grundlegende Schritt ist entscheidend, um potenzielle Überlauf- oder Unterlauffehlern zu vermeiden, wenn man mit Ganzzahlwerten innerhalb dieses Bereichs arbeitet.