Wie man prüft, ob eine Bedingung in Java wahr ist

Einführung

In diesem Lab lernen Sie, wie Sie in Java überprüfen können, ob eine Bedingung wahr ist, indem Sie bedingte Ausdrücke verwenden. Dieses grundlegende Programmierkonzept ermöglicht es Ihren Programmen, Entscheidungen zu treffen und sich je nach verschiedenen Situationen unterschiedlich zu verhalten. Sie beginnen damit, einen einfachen bedingten Ausdruck mit einer if-Anweisung zu schreiben, um Code nur auszuführen, wenn eine bestimmte Bedingung erfüllt ist.

Basierend auf diesen Grundlagen werden Sie dann untersuchen, wie Sie Bedingungen mithilfe von Variablen testen können, wodurch Ihre Programme dynamischer werden. Abschließend lernen Sie, wie Sie komplexere Bedingungen behandeln können, damit Ihre Java-Anwendungen anspruchsvolle Entscheidungen treffen können.

Schreiben Sie einen einfachen bedingten Ausdruck

In diesem Schritt lernen wir über bedingte Ausdrücke in Java. Bedingte Ausdrücke ermöglichen es Ihrem Programm, Entscheidungen auf der Grundlage bestimmter Bedingungen zu treffen. Dies ist ein grundlegendes Konzept in der Programmierung, das es Ihren Programmen ermöglicht, sich je nach Situation unterschiedlich zu verhalten.

Stellen Sie sich das so vor: "WENN es regnet, DANN nimm einen Regenschirm." Die Bedingung ist "es regnet", und die Aktion ist "nimm einen Regenschirm". In Java verwenden wir if-Anweisungen, um dies zu erreichen.

Beginnen wir damit, eine neue Java-Datei zu erstellen.

Öffnen Sie den Datei-Explorer auf der linken Seite der WebIDE.
Klicken Sie mit der rechten Maustaste im Verzeichnis ~/project und wählen Sie "Neue Datei".
Benennen Sie die neue Datei ConditionalExample.java.

Jetzt schreiben wir etwas Code in diese Datei. Kopieren Sie den folgenden Code und fügen Sie ihn in die Datei ConditionalExample.java ein:

public class ConditionalExample {
    public static void main(String[] args) {
        int number = 10;

        if (number > 5) {
            System.out.println("The number is greater than 5.");
        }
    }
}

Lassen Sie uns diesen Code analysieren:

public class ConditionalExample: Dies deklariert unsere Klasse, die mit dem Dateinamen übereinstimmt.
public static void main(String[] args): Dies ist die Hauptmethode, in der die Ausführung unseres Programms beginnt.
int number = 10;: Dies deklariert eine Ganzzahlvariable namens number und weist ihr den Wert 10 zu.
if (number > 5): Dies ist die if-Anweisung. Die Bedingung ist number > 5. Der Code innerhalb der geschweiften Klammern {} wird nur ausgeführt, wenn diese Bedingung wahr ist.
System.out.println("The number is greater than 5.");: Diese Zeile gibt die Nachricht in die Konsole aus, wenn die Bedingung number > 5 wahr ist.

Da number den Wert 10 hat und 10 tatsächlich größer als 5 ist, ist die Bedingung number > 5 wahr. Daher sollte die Nachricht "The number is greater than 5." ausgegeben werden.

Speichern Sie die Datei ConditionalExample.java (Strg+S oder Cmd+S).
Öffnen Sie das Terminal unten in der WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Wenn nicht, geben Sie cd ~/project ein und drücken Sie die Eingabetaste.
Kompilieren Sie die Java-Datei mit dem Befehl javac:
```
javac ConditionalExample.java
```
Wenn keine Fehler auftreten, erstellt dieser Befehl eine Datei namens ConditionalExample.class.
Führen Sie das kompilierte Java-Programm mit dem Befehl java aus:
```
java ConditionalExample
```

Sie sollten die folgende Ausgabe sehen:

The number is greater than 5.

Dies bestätigt, dass unser einfacher bedingter Ausdruck wie erwartet funktioniert hat. Im nächsten Schritt werden wir untersuchen, wie wir Variablen in unseren Bedingungen verwenden können.

Bedingung mit Variablen testen

In diesem Schritt erweitern wir unser Verständnis von bedingten Ausdrücken, indem wir Variablen in den Bedingungen verwenden. Dies macht unsere Programme dynamischer, da das Ergebnis je nach den in den Variablen gespeicherten Werten ändern kann.

Lassen Sie uns die im vorherigen Schritt erstellte Datei ConditionalExample.java ändern.

Öffnen Sie die Datei ConditionalExample.java im WebIDE-Editor.
Ersetzen Sie den vorhandenen Code durch folgenden:

public class ConditionalExample {
    public static void main(String[] args) {
        int temperature = 25;
        boolean isSunny = true;

        if (temperature > 20) {
            System.out.println("It's a warm day.");
        }

        if (isSunny) {
            System.out.println("It's sunny today.");
        }
    }
}

In diesem aktualisierten Code:

Wir haben zwei Variablen: temperature (eine Ganzzahl) und isSunny (ein boolescher Wert, der entweder true oder false sein kann).
Die erste if-Anweisung prüft, ob die Variable temperature größer als 20 ist.
Die zweite if-Anweisung prüft, ob die Variable isSunny den Wert true hat.

Da temperature den Wert 25 hat (was größer als 20 ist) und isSunny den Wert true hat, sollten beide Bedingungen als wahr ausgewertet werden, und beide Nachrichten sollten ausgegeben werden.

Speichern Sie die Datei ConditionalExample.java.
Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie die geänderte Java-Datei:
```
javac ConditionalExample.java
```
Führen Sie das kompilierte Programm aus:
```
java ConditionalExample
```

Sie sollten die folgende Ausgabe sehen:

It's a warm day.
It's sunny today.

Dies zeigt, wie Sie Variablen direkt in Ihren if-Bedingungen verwenden können. Die Ausgabe des Programms ändert sich je nach den aktuellen Werten der Variablen temperature und isSunny.

Jetzt ändern wir die Werte der Variablen, um zu sehen, wie sich die Ausgabe ändert.

Ändern Sie erneut die Datei ConditionalExample.java. Ändern Sie die Werte der Variablen:

public class ConditionalExample {
    public static void main(String[] args) {
        int temperature = 15; // Changed temperature
        boolean isSunny = false; // Changed isSunny

        if (temperature > 20) {
            System.out.println("It's a warm day.");
        }

        if (isSunny) {
            System.out.println("It's sunny today.");
        }
    }
}

Speichern Sie die Datei.
Kompilieren Sie das Programm erneut:
```
javac ConditionalExample.java
```
Führen Sie das Programm aus:
```
java ConditionalExample
```

Diesmal, da temperature den Wert 15 hat (nicht größer als 20) und isSunny den Wert false hat, ist keine der Bedingungen wahr, und Sie sollten keine Ausgabe sehen.

Dies zeigt die Stärke der Verwendung von Variablen in bedingten Anweisungen – das Verhalten des Programms wird durch die Daten bestimmt, die es verarbeitet.

Komplexe Bedingungen verarbeiten

In diesem Schritt lernen wir, wie wir mehrere Bedingungen kombinieren können, um komplexere Entscheidungslogik in unseren Java-Programmen zu erstellen. Hierfür können wir logische Operatoren wie && (UND) und || (ODER) verwenden.

Lassen Sie uns die Datei ConditionalExample.java noch einmal ändern.

Öffnen Sie die Datei ConditionalExample.java im WebIDE-Editor.
Ersetzen Sie den vorhandenen Code durch folgenden:

public class ConditionalExample {
    public static void main(String[] args) {
        int temperature = 25;
        boolean isSunny = true;
        boolean isWeekend = false;

        // Condition using AND (&&)
        if (temperature > 20 && isSunny) {
            System.out.println("It's a warm and sunny day.");
        }

        // Condition using OR (||)
        if (isSunny || isWeekend) {
            System.out.println("It's either sunny or the weekend.");
        }

        // Condition using AND and OR
        if ((temperature > 25 && isSunny) || isWeekend) {
             System.out.println("It's very warm and sunny, or it's the weekend.");
        }
    }
}

Schauen wir uns die neuen Teile an:

boolean isWeekend = false;: Wir haben eine neue boolesche Variable isWeekend hinzugefügt.
if (temperature > 20 && isSunny): Diese Bedingung verwendet den && (UND)-Operator. Der Code innerhalb der geschweiften Klammern wird nur ausgeführt, wenn beide temperature > 20 wahr ist und isSunny wahr ist.
if (isSunny || isWeekend): Diese Bedingung verwendet den || (ODER)-Operator. Der Code innerhalb der geschweiften Klammern wird ausgeführt, wenn entweder isSunny wahr ist oder isWeekend wahr ist (oder beide).
if ((temperature > 25 && isSunny) || isWeekend): Diese Bedingung kombiniert sowohl && als auch ||. Die Klammern () werden verwendet, um Bedingungen zu gruppieren, ähnlich wie in der Mathematik. Diese Bedingung ist wahr, wenn (temperature > 25 UND isSunny) wahr ist, ODER wenn isWeekend wahr ist.

Angesichts der aktuellen Variablenwerte (temperature = 25, isSunny = true, isWeekend = false):

temperature > 20 && isSunny: (25 > 20) ist wahr, isSunny ist wahr. Wahr && Wahr ist Wahr. Diese Bedingung ist wahr.
isSunny || isWeekend: isSunny ist wahr, isWeekend ist falsch. Wahr || Falsch ist Wahr. Diese Bedingung ist wahr.
(temperature > 25 && isSunny) || isWeekend: (25 > 25) ist falsch, isSunny ist wahr. Falsch && Wahr ist Falsch. Falsch || Falsch ist Falsch. Diese Bedingung ist falsch.

Wir erwarten also, dass die ersten beiden Nachrichten ausgegeben werden, aber nicht die dritte.

Speichern Sie die Datei ConditionalExample.java.
Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie die geänderte Java-Datei:
```
javac ConditionalExample.java
```
Führen Sie das kompilierte Programm aus:
```
java ConditionalExample
```

Sie sollten die folgende Ausgabe sehen:

It's a warm and sunny day.
It's either sunny or the weekend.

Dies bestätigt, dass unsere komplexen Bedingungen mit && und || korrekt funktionierten. Sie können die Werte von temperature, isSunny und isWeekend ändern und das Programm neu kompilieren und ausführen, um zu sehen, wie sich die Ausgabe je nach verschiedenen Kombinationen von Bedingungen ändert.

Das Verständnis, wie man Bedingungen kombiniert, ist entscheidend für das Schreiben von Programmen, die verschiedene Szenarien bewältigen und komplexere Entscheidungen treffen können.

Zusammenfassung

In diesem Lab haben wir zunächst das grundlegende Konzept von bedingten Ausdrücken in Java gelernt. Diese ermöglichen es Programmen, Entscheidungen auf der Grundlage von Bedingungen zu treffen. Wir haben eine einfache Java-Datei namens ConditionalExample.java erstellt und Code geschrieben, der eine grundlegende if-Anweisung demonstriert. Dabei haben wir eine Ganzzahlvariable deklariert und eine if-Anweisung mit einer Bedingung (number > 5) verwendet, um die Ausführung einer Ausgabebefehlszeile zu steuern. Wir haben gelernt, dass der Code innerhalb des if-Blocks nur ausgeführt wird, wenn die angegebene Bedingung als wahr ausgewertet wird.

Anschließend haben wir Bedingungen mithilfe von Variablen getestet, indem wir auf der grundlegenden if-Anweisung aufgebaut haben. Dies beinhaltete die Verwendung von Variablen innerhalb des bedingten Ausdrucks, um den Entscheidungsprozess dynamisch zu gestalten. Schließlich haben wir uns mit der Behandlung komplexer Bedingungen befasst, was wahrscheinlich das Kombinieren mehrerer Bedingungen mithilfe von logischen Operatoren (wie && für UND, || für ODER und ! für NICHT) zur Erstellung einer ausgefeilteren Entscheidungslogik in unseren Java-Programmen beinhaltete.