Wie man prüft, ob eine Zahl in Java positiv ist

Einführung

In diesem Lab werden Sie lernen, wie Sie in Java prüfen können, ob eine Zahl positiv ist. Wir beginnen damit, ein einfaches Programm zu schreiben, das eine Zahl mit Null vergleicht, indem es grundlegende bedingte Anweisungen verwendet.

Anschließend erweitern Sie Ihr Wissen, um sowohl mit Ganzzahl- (integer) als auch mit Gleitkommazahl-Datentypen (double) zu testen und zu verstehen, wie Sie verschiedene numerische Darstellungen behandeln können. Abschließend werden wir untersuchen, wie Sie Randfälle behandeln können, wobei wir uns speziell darauf konzentrieren, wie Sie den Fall korrekt identifizieren und verwalten können, in dem die Zahl Null ist.

Zahl mit Null vergleichen

In diesem Schritt werden wir ein einfaches Java-Programm schreiben, um eine Zahl mit Null zu vergleichen. Dies wird Sie mit grundlegenden bedingten Anweisungen in Java vertraut machen, insbesondere mit der if-Anweisung. Bedingte Anweisungen ermöglichen es Ihrem Programm, Entscheidungen auf der Grundlage bestimmter Bedingungen zu treffen.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Verzeichnis befinden. Öffnen Sie das Terminal unten im WebIDE und geben Sie den folgenden Befehl ein, dann drücken Sie die Eingabetaste:
```
cd ~/project
```
Dadurch wird sichergestellt, dass Sie sich im Verzeichnis ~/project befinden, in dem wir unsere Java-Datei erstellen werden.
Jetzt erstellen wir eine neue Java-Datei mit dem Namen CompareNumber.java. Sie können dies tun, indem Sie mit der rechten Maustaste im Dateiexplorer links klicken, "Neue Datei" auswählen und CompareNumber.java eingeben. Alternativ können Sie das Terminal verwenden:
```
touch CompareNumber.java
```
Öffnen Sie die Datei CompareNumber.java im Code-Editor, indem Sie darauf im Dateiexplorer klicken.
Kopieren und fügen Sie den folgenden Java-Code in den Editor ein:
```
public class CompareNumber {
    public static void main(String[] args) {
        int number = 10; // Wir werden diese Zahl mit Null vergleichen

        if (number > 0) {
            System.out.println("The number is positive.");
        }
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- int number = 10;: Diese Zeile deklariert eine Variable namens number vom Typ int (Ganzzahl) und weist ihr den Wert 10 zu. Variablen werden verwendet, um Daten in Ihrem Programm zu speichern.
- if (number > 0): Dies ist eine if-Anweisung. Sie prüft, ob die Bedingung in den Klammern (number > 0) wahr ist. Wenn die Bedingung wahr ist, wird der Code in den geschweiften Klammern {} danach ausgeführt.
- System.out.println("The number is positive.");: Diese Zeile wird nur ausgeführt, wenn die number größer als 0 ist.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt kompilieren wir das Java-Programm mit dem javac-Befehl im Terminal:
```
javac CompareNumber.java
```
Wenn keine Fehler auftreten, wird eine Datei CompareNumber.class im Verzeichnis ~/project erstellt.
Abschließend führen wir das kompilierte Programm mit dem java-Befehl aus:
```
java CompareNumber
```
Da die Variable number auf 10 gesetzt ist (was größer als 0 ist), sollten Sie die folgende Ausgabe sehen:
```
The number is positive.
```

Sie haben erfolgreich ein Java-Programm geschrieben und ausgeführt, das eine if-Anweisung verwendet, um eine Zahl mit Null zu vergleichen. Im nächsten Schritt werden wir dieses Programm erweitern, um verschiedene Fälle zu behandeln.

Test mit Ganzzahl (Integer) und Fließkommazahl (Double)

Im vorherigen Schritt haben wir eine Ganzzahl (integer) mit Null verglichen. Java unterstützt verschiedene Zahlentypen, darunter Ganzzahlen (whole numbers) und Gleitkommazahlen (Zahlen mit Dezimalpunkten). In diesem Schritt werden wir unser Programm ändern, um sowohl mit Ganzzahl- (integer) als auch mit Gleitkommazahl-Datentypen (double) zu testen und die else-Anweisung einführen, um den Fall zu behandeln, in dem die Zahl nicht positiv ist.

Öffnen Sie die Datei CompareNumber.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.
Ändern Sie den Code, um einen else-Block hinzuzufügen. Ersetzen Sie den vorhandenen Code durch den folgenden:
```
public class CompareNumber {
    public static void main(String[] args) {
        int number = -5; // Testen wir mit einer negativen Ganzzahl

        if (number > 0) {
            System.out.println("The number is positive.");
        } else {
            System.out.println("The number is not positive.");
        }
    }
}
```
Hier ist, was neu ist:
- int number = -5;: Wir haben den Wert von number auf -5 geändert, um die else-Bedingung zu testen.
- else { ... }: Der else-Block wird ausgeführt, wenn die Bedingung in der vorhergehenden if-Anweisung falsch ist. In diesem Fall, wenn number > 0 falsch ist, wird der Code im else-Block ausgeführt.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac CompareNumber.java
```
Führen Sie das kompilierte Programm aus:
```
java CompareNumber
```
Da number -5 ist, ist die if-Bedingung (-5 > 0) falsch, daher wird der else-Block ausgeführt. Sie sollten die Ausgabe sehen:
```
The number is not positive.
```

Jetzt testen wir mit einer double-Zahl (einer Gleitkommazahl). Ändern Sie den Code erneut:

public class CompareNumber {
    public static void main(String[] args) {
        double decimalNumber = 3.14; // Testen wir mit einer positiven Gleitkommazahl

        if (decimalNumber > 0) {
            System.out.println("The number is positive.");
        } else {
            System.out.println("The number is not positive.");
        }
    }
}

Wir haben den Variablentyp auf double geändert und ihm einen Dezimalwert zugewiesen.

Speichern Sie die Datei.
Kompilieren Sie das Programm:
```
javac CompareNumber.java
```
Führen Sie das Programm aus:
```
java CompareNumber
```
Da decimalNumber 3.14 ist (was größer als 0 ist), wird die if-Bedingung wahr sein, und Sie sollten die Ausgabe sehen:
```
The number is positive.
```

Sie haben jetzt gesehen, wie Sie die else-Anweisung verwenden und wie der Vergleich sowohl mit Ganzzahl- als auch mit Gleitkommazahl-Datentypen funktioniert. Im nächsten Schritt werden wir den speziellen Fall behandeln, in dem die Zahl genau Null ist.

Randfälle wie Null behandeln

In den vorherigen Schritten haben wir positive und nicht-positive Zahlen behandelt. Allerdings haben wir den Fall, dass die Zahl genau Null ist, noch nicht speziell betrachtet. Beim Programmieren ist es wichtig, diese "Randfälle" (edge cases) zu behandeln, um sicherzustellen, dass Ihr Programm in allen Situationen korrekt funktioniert. In diesem Schritt werden wir die else if-Anweisung verwenden, um eine spezielle Prüfung auf die Zahl Null hinzuzufügen.

Öffnen Sie die Datei CompareNumber.java im WebIDE-Editor.
Ändern Sie den Code, um einen else if-Block hinzuzufügen, um auf die Zahl Null zu prüfen. Ersetzen Sie den vorhandenen Code durch den folgenden:
```
public class CompareNumber {
    public static void main(String[] args) {
        int number = 0; // Testen wir mit der Zahl Null

        if (number > 0) {
            System.out.println("The number is positive.");
        } else if (number == 0) {
            System.out.println("The number is zero.");
        } else {
            System.out.println("The number is negative.");
        }
    }
}
```
Schauen wir uns die Änderungen an:
- int number = 0;: Wir setzen die Variable number auf 0, um die neue Bedingung zu testen.
- else if (number == 0): Dies ist eine else if-Anweisung. Sie wird nur geprüft, wenn die vorherige if-Bedingung (number > 0) falsch ist. Die Bedingung number == 0 prüft, ob der Wert von number genau gleich 0 ist. Beachten Sie das doppelte Gleichheitszeichen (==) für den Vergleich, da ein einzelnes Gleichheitszeichen (=) für die Zuweisung verwendet wird.
- System.out.println("The number is zero.");: Diese Zeile wird ausgeführt, wenn die Variable number genau 0 ist.
- Der letzte else-Block behandelt jetzt speziell den Fall, dass die Zahl weder positiv noch Null ist, was bedeutet, dass sie negativ sein muss.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac CompareNumber.java
```
Führen Sie das kompilierte Programm aus:
```
java CompareNumber
```
Da die Variable number 0 ist, ist die erste if-Bedingung (0 > 0) falsch. Die else if-Bedingung (0 == 0) ist wahr, daher wird ihr Block ausgeführt. Sie sollten die Ausgabe sehen:
```
The number is zero.
```

Jetzt testen wir erneut mit einer negativen Zahl. Ändern Sie den Wert von number auf -10:

public class CompareNumber {
    public static void main(String[] args) {
        int number = -10; // Testen wir mit einer negativen Zahl

        if (number > 0) {
            System.out.println("The number is positive.");
        } else if (number == 0) {
            System.out.println("The number is zero.");
        } else {
            System.out.println("The number is negative.");
        }
    }
}

Speichern Sie die Datei.
Kompilieren Sie das Programm:
```
javac CompareNumber.java
```
Führen Sie das Programm aus:
```
java CompareNumber
```
Da die Variable number -10 ist, ist die if-Bedingung (-10 > 0) falsch, und die else if-Bedingung (-10 == 0) ist ebenfalls falsch. Daher wird der letzte else-Block ausgeführt, und Sie sollten die Ausgabe sehen:
```
The number is negative.
```

Sie haben jetzt erfolgreich die if-, else if- und else-Anweisungen verwendet, um eine Zahl mit Null zu vergleichen und zu bestimmen, ob sie positiv, negativ oder Null ist. Dies ist ein grundlegendes Muster für Entscheidungen in Ihren Java-Programmen.

Zusammenfassung

In diesem Lab (Praktikum) haben wir zunächst gelernt, wie man die Entwicklungsumgebung einrichtet, indem man in das richtige Verzeichnis wechselt und eine neue Java-Datei erstellt. Anschließend haben wir das grundlegende Konzept der bedingten Anweisungen (conditional statements) in Java mit der if-Anweisung eingeführt. Indem wir ein einfaches Programm geschrieben haben, haben wir gelernt, wie man eine Ganzzahlvariable (integer variable) deklariert, ihr einen Wert zuweist und den >-Operator innerhalb einer if-Bedingung verwendet, um zu prüfen, ob die Zahl größer als Null ist. Wir haben gesehen, wie der Codeblock innerhalb der if-Anweisung nur ausgeführt wird, wenn die Bedingung wahr ist, und so gezeigt, wie man eine Nachricht ausgibt, die anzeigt, dass die Zahl positiv ist.