So prüfen Sie, ob eine Zahl in einem bestimmten Bereich in Java liegt

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob eine Zahl in einem bestimmten Bereich liegt, in Java. Wir werden die grundlegenden Konzepte behandeln, wie man einen numerischen Bereich mithilfe von unteren und oberen Grenzen definiert, logische Operatoren verwendet, um die Bereichsprüfung durchzuführen, und wie man versteht, wie man Grenzwerte in die Bereichsvergleiche einbezieht. Durch praktische Übungen gewinnen Sie praktische Erfahrung bei der Implementierung dieser Techniken in Java-Code.

Bereich mit unterer und oberer Grenze definieren

In diesem Schritt lernen wir, wie man in Java einen numerischen Bereich mithilfe von unterer und oberer Grenze definiert. Das Verständnis, wie man mit Bereichen arbeitet, ist ein grundlegendes Konzept in der Programmierung und ermöglicht es uns, zu prüfen, ob ein Wert innerhalb einer bestimmten Zahlengruppe liegt.

Ein Bereich ist einfach eine Gruppe von Zahlen zwischen einem Startpunkt (der unteren Grenze) und einem Endpunkt (der oberen Grenze). Beispielsweise umfasst der Bereich zwischen 1 und 10 alle Zahlen von 1 bis 10.

Lassen Sie uns ein einfaches Java-Programm erstellen, um einen Bereich zu definieren und damit zu arbeiten.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, falls sie noch nicht geöffnet ist. Wir werden diese Datei für unser neues Programm ändern.
Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:
```
public class HelloJava {
    public static void main(String[] args) {
        // Define the lower and upper bounds of the range
        int lowerBound = 10;
        int upperBound = 50;

        // Print the defined range
        System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- int lowerBound = 10;: Diese Zeile deklariert eine Ganzzahlvariable namens lowerBound und weist ihr den Wert 10 zu. Dies ist unser Startpunkt für den Bereich.
- int upperBound = 50;: Diese Zeile deklariert eine Ganzzahlvariable namens upperBound und weist ihr den Wert 50 zu. Dies ist unser Endpunkt für den Bereich.
- System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");: Diese Zeile gibt eine Nachricht in der Konsole aus, die den definierten Bereich unter Verwendung der Werte von lowerBound und upperBound anzeigt. Das +-Symbol wird verwendet, um Textzeichenketten und Variablenwerte zu kombinieren.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt lassen Sie uns unser geändertes Programm kompilieren. Öffnen Sie das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Führen Sie dann den folgenden Befehl aus:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, war die Kompilierung erfolgreich.
Schließlich lassen Sie uns das Programm ausführen, um die Ausgabe zu sehen. Im Terminal führen Sie aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Defined Range: [10, 50]
```
Dies bestätigt, dass unser Programm die untere und obere Grenze des Bereichs korrekt definiert und ausgegeben hat.

Im nächsten Schritt lernen wir, wie man prüft, ob eine Zahl innerhalb dieses definierten Bereichs liegt, indem man logische Operatoren verwendet.

Logische Operatoren für die Bereichsprüfung verwenden

In diesem Schritt lernen wir, wie man in Java logische Operatoren verwendet, um zu prüfen, ob eine Zahl innerhalb des Bereichs liegt, den wir im vorherigen Schritt definiert haben. Logische Operatoren werden verwendet, um boolesche Ausdrücke (Ausdrücke, die entweder wahr oder falsch sind) zu kombinieren oder zu modifizieren.

Um zu prüfen, ob eine Zahl innerhalb eines Bereichs liegt, der durch eine untere und eine obere Grenze definiert ist, müssen wir zwei Bedingungen prüfen:

Ist die Zahl größer oder gleich der unteren Grenze?
Ist die Zahl kleiner oder gleich der oberen Grenze?

Beide Bedingungen müssen wahr sein, damit die Zahl innerhalb des Bereichs liegt. In Java verwenden wir den logischen UND-Operator (&&), um diese beiden Bedingungen zu kombinieren.

Lassen Sie uns unser HelloJava.java-Programm ändern, um diese Bereichsprüfung einzubeziehen.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ändern Sie die main-Methode, um eine Variable für die zu prüfende Zahl und die Logik für die Bereichsprüfung einzubeziehen. Ersetzen Sie den bestehenden Inhalt der main-Methode durch Folgendes:
```
    public static void main(String[] args) {
        // Define the lower and upper bounds of the range
        int lowerBound = 10;
        int upperBound = 50;

        // Define the number to check
        int numberToCheck = 35;

        // Check if the number is within the range using logical operators
        boolean isInRange = (numberToCheck >= lowerBound) && (numberToCheck <= upperBound);

        // Print the result
        System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");
        System.out.println("Number to Check: " + numberToCheck);
        System.out.println("Is " + numberToCheck + " within the range? " + isInRange);
    }
```
Hier ist, was wir hinzugefügt haben:
- int numberToCheck = 35;: Diese Zeile deklariert eine Ganzzahlvariable numberToCheck und weist ihr den Wert 35 zu. Dies ist die Zahl, die wir gegen unseren Bereich prüfen möchten.
- boolean isInRange = (numberToCheck >= lowerBound) && (numberToCheck <= upperBound);: Dies ist der Kern unserer Bereichsprüfung.
  - numberToCheck >= lowerBound: Dies prüft, ob numberToCheck größer oder gleich lowerBound ist.
  - numberToCheck <= upperBound: Dies prüft, ob numberToCheck kleiner oder gleich upperBound ist.
  - &&: Dies ist der logische UND-Operator. Er gibt nur true zurück, wenn beide die Bedingung auf seiner linken und die Bedingung auf seiner rechten Seite true sind.
  - Das Ergebnis dieses gesamten Ausdrucks (true oder false) wird in einer booleschen Variable namens isInRange gespeichert.
- Die System.out.println-Zeilen geben jetzt auch die zu prüfende Zahl und das Ergebnis der Bereichsprüfung aus.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Defined Range: [10, 50]
Number to Check: 35
Is 35 within the range? true
```
Da 35 tatsächlich zwischen 10 und 50 (einschließlich) liegt, gibt das Programm korrekt true aus.

Versuchen Sie, den Wert von numberToCheck auf etwas außerhalb des Bereichs zu ändern (z. B. 5 oder 60) und kompilieren und führen Sie das Programm erneut aus, um zu sehen, wie sich die Ausgabe ändert.

Grenzwerte in den Bereich einbeziehen

Im vorherigen Schritt haben wir die Operatoren >= (größer oder gleich) und <= (kleiner oder gleich) verwendet, um zu prüfen, ob eine Zahl innerhalb eines Bereichs liegt. Diese Operatoren sind von entscheidender Bedeutung, da sie die Grenzwerte (die untere und obere Grenze) in die Bereichsprüfung einbeziehen.

Beispielsweise wird, wenn unser Bereich [10, 50] ist, eine Zahl als innerhalb des Bereichs betrachtet, wenn sie 10, 50 oder eine beliebige Zahl zwischen 10 und 50 ist. Hätten wir stattdessen > (größer als) und < (kleiner als) verwendet, wäre der Bereich (10, 50), was bedeutet, dass 10 und 50 selbst nicht eingeschlossen wären.

Lassen Sie uns dieses Verhalten durch Testen unseres Programms mit den Grenzwerten bestätigen.

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

Wir werden die Bereichsprüfung mit der unteren und der oberen Grenze testen. Ändern Sie die main-Methode, um sowohl lowerBound als auch upperBound als numberToCheck zu testen.

public class HelloJava {
    public static void main(String[] args) {
        // Define the lower and upper bounds of the range
        int lowerBound = 10;
        int upperBound = 50;

        // Test with the lower bound
        int numberToCheck1 = lowerBound;
        boolean isInRange1 = (numberToCheck1 >= lowerBound) && (numberToCheck1 <= upperBound);
        System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");
        System.out.println("Number to Check: " + numberToCheck1);
        System.out.println("Is " + numberToCheck1 + " within the range? " + isInRange1);
        System.out.println("---"); // Separator for clarity

        // Test with the upper bound
        int numberToCheck2 = upperBound;
        boolean isInRange2 = (numberToCheck2 >= lowerBound) && (numberToCheck2 <= upperBound);
        System.out.println("Number to Check: " + numberToCheck2);
        System.out.println("Is " + numberToCheck2 + " within the range? " + isInRange2);
    }
}

Wir haben einen zweiten Testfall hinzugefügt, bei dem numberToCheck2 auf upperBound gesetzt ist.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Defined Range: [10, 50]
Number to Check: 10
Is 10 within the range? true
---
Number to Check: 50
Is 50 within the range? true
```
Wie Sie sehen können, werden sowohl 10 (die untere Grenze) als auch 50 (die obere Grenze) korrekt als innerhalb des Bereichs identifiziert, weil wir die Operatoren >= und <= verwendet haben. Dies bestätigt, dass unsere Bereichsprüfung die Grenzwerte einbezieht.

Es ist wichtig zu verstehen, ob ein Bereich seine Grenzen einschließt (inklusiv) oder ausschließt (exklusiv), wenn Sie Bedingungen in Ihren Programmen definieren. Die Operatoren >= und <= erstellen einen inklusiven Bereich.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java einen numerischen Bereich definiert, indem man untere und obere Grenzen mithilfe von Ganzzahlvariablen festlegt. Wir haben ein einfaches Java-Programm geändert, um diese Grenzen zu deklarieren und den definierten Bereich in der Konsole auszugeben. Dabei haben wir verstanden, wie man Text und Variablenwerte für die Ausgabe kombiniert. Dieser grundlegende Schritt ist von entscheidender Bedeutung, um anschließend zu prüfen, ob eine Zahl innerhalb dieses angegebenen Bereichs liegt.