So überprüfen Sie, ob ein boolescher Ausdruck in Java gültig ist

JavaJavaBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab werden Sie lernen, wie Sie überprüfen können, ob ein boolescher Ausdruck in Java gültig ist. Wir beginnen damit, einfache boolesche Ausdrücke mit Vergleichsoperatoren auszuwerten.

Als Nächstes werden Sie untersuchen, wie Sie zusammengesetzte boolesche Ausdrücke verarbeiten können, indem Sie einfache Ausdrücke mit logischen Operatoren kombinieren. Schließlich werden Sie lernen, wie Sie Fehler identifizieren und abfangen können, die beim Arbeiten mit ungültigen booleschen Ausdrücken in Ihrem Java-Code auftreten können.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java/BasicSyntaxGroup -.-> java/data_types("Data Types") java/BasicSyntaxGroup -.-> java/operators("Operators") java/BasicSyntaxGroup -.-> java/booleans("Booleans") java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/exceptions("Exceptions") subgraph Lab Skills java/data_types -.-> lab-559930{{"So überprüfen Sie, ob ein boolescher Ausdruck in Java gültig ist"}} java/operators -.-> lab-559930{{"So überprüfen Sie, ob ein boolescher Ausdruck in Java gültig ist"}} java/booleans -.-> lab-559930{{"So überprüfen Sie, ob ein boolescher Ausdruck in Java gültig ist"}} java/if_else -.-> lab-559930{{"So überprüfen Sie, ob ein boolescher Ausdruck in Java gültig ist"}} java/exceptions -.-> lab-559930{{"So überprüfen Sie, ob ein boolescher Ausdruck in Java gültig ist"}} end

Auswertung einfacher boolescher Ausdrücke

In diesem Schritt werden wir uns mit booleschen Ausdrücken in Java befassen und lernen, wie man einfache Ausdrücke auswertet. Boolesche Ausdrücke sind in der Programmierung von grundlegender Bedeutung, da sie es uns ermöglichen, Entscheidungen zu treffen, basierend darauf, ob eine Bedingung wahr oder falsch ist.

Ein boolescher Ausdruck ist eine Aussage, die entweder zu true (wahr) oder false (falsch) ausgewertet wird. In Java verwenden wir Vergleichsoperatoren, um diese Ausdrücke zu erstellen. Hier sind einige häufige Vergleichsoperatoren:

  • ==: Gleich
  • !=: Ungleich
  • >: Größer als
  • <: Kleiner als
  • >=: Größer als oder gleich
  • <=: Kleiner als oder gleich

Lassen Sie uns ein einfaches Java-Programm erstellen, um einige boolesche Ausdrücke auszuwerten.

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

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

    public class HelloJava {
        public static void main(String[] args) {
            int x = 10;
            int y = 20;
    
            boolean isEqual = (x == y);
            boolean isNotEqual = (x != y);
            boolean isGreater = (x > y);
            boolean isLess = (x < y);
            boolean isGreaterOrEqual = (x >= y);
            boolean isLessOrEqual = (x <= y);
    
            System.out.println("Is x equal to y? " + isEqual);
            System.out.println("Is x not equal to y? " + isNotEqual);
            System.out.println("Is x greater than y? " + isGreater);
            System.out.println("Is x less than y? " + isLess);
            System.out.println("Is x greater than or equal to y? " + isGreaterOrEqual);
            System.out.println("Is x less than or equal to y? " + isLessOrEqual);
        }
    }

    In diesem Code:

    • Wir deklarieren zwei Ganzzahlvariablen, x und y.
    • Wir erstellen mehrere boolesche Variablen (isEqual, isNotEqual usw.) und weisen jedem das Ergebnis eines booleschen Ausdrucks zu.
    • Wir verwenden System.out.println, um die Ergebnisse dieser booleschen Ausdrücke auszugeben.
  3. Speichern Sie die Datei (Strg+S oder Cmd+S).

  4. Kompilieren Sie das Programm, indem Sie den folgenden Befehl im Terminal ausführen:

    javac HelloJava.java

    Wenn keine Fehler auftreten, wird eine Datei HelloJava.class erstellt.

  5. Führen Sie das kompilierte Programm aus:

    java HelloJava

    Sie sollten die Ausgabe sehen, die die Ergebnisse jedes booleschen Ausdrucks anzeigt.

    Is x equal to y? false
    Is x not equal to y? true
    Is x greater than y? false
    Is x less than y? true
    Is x greater than or equal to y? false
    Is x less than or equal to y? true

Sie haben erfolgreich einfache boolesche Ausdrücke in Java ausgewertet! Das Verständnis, wie man Werte vergleicht und ein true- oder false-Ergebnis erhält, ist entscheidend für die Steuerung des Programmablaufs.

Umgang mit zusammengesetzten Ausdrücken

In diesem Schritt werden wir lernen, wie man einfache boolesche Ausdrücke mit logischen Operatoren kombiniert, um komplexere Ausdrücke zu erstellen. Diese werden zusammengesetzte Ausdrücke genannt und ermöglichen es uns, mehrere Bedingungen gleichzeitig zu prüfen.

Java bietet die folgenden logischen Operatoren:

  • &&: Logisches UND. Der Ausdruck ist nur dann true (wahr), wenn beide Bedingungen true sind.
  • ||: Logisches ODER. Der Ausdruck ist true, wenn mindestens eine der Bedingungen true ist.
  • !: Logisches NICHT. Dieser Operator kehrt den booleschen Wert eines Ausdrucks um. Wenn ein Ausdruck true ist, macht ! ihn false, und umgekehrt.

Lassen Sie uns unser HelloJava.java-Programm ändern, um diese logischen Operatoren zu verwenden.

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

  2. Ersetzen Sie den aktuellen Code durch folgenden:

    public class HelloJava {
        public static void main(String[] args) {
            int age = 25;
            int score = 85;
            boolean isStudent = true;
    
            // Using Logical AND (&&)
            boolean isEligibleForDiscount = (age > 18 && isStudent);
            System.out.println("Is eligible for student discount? " + isEligibleForDiscount);
    
            // Using Logical OR (||)
            boolean passedExam = (score >= 70 || age < 18);
            System.out.println("Passed the exam? " + passedExam);
    
            // Using Logical NOT (!)
            boolean isNotStudent = !isStudent;
            System.out.println("Is not a student? " + isNotStudent);
    
            // Combining multiple operators
            boolean complexCondition = (age > 20 && score > 80 || !isStudent);
            System.out.println("Complex condition result: " + complexCondition);
        }
    }

    In diesem aktualisierten Code:

    • Wir führen neue Variablen age, score und isStudent ein.
    • Wir verwenden &&, um zu prüfen, ob jemand für einen Studentenrabatt berechtigt ist (älter als 18 UND Student).
    • Wir verwenden ||, um zu prüfen, ob jemand eine Prüfung bestanden hat (Punktzahl 70 oder höher ODER jünger als 18).
    • Wir verwenden !, um den booleschen Wert von isStudent zu negieren.
    • Wir zeigen ein Beispiel für die Kombination von &&, || und ! in einem einzigen Ausdruck.
  3. Speichern Sie die Datei (Strg+S oder Cmd+S).

  4. Kompilieren Sie das Programm im Terminal:

    javac HelloJava.java

    Stellen Sie sicher, dass keine Kompilierungsfehler auftreten.

  5. Führen Sie das kompilierte Programm aus:

    java HelloJava

    Beobachten Sie die Ausgabe, die die Ergebnisse der zusammengesetzten booleschen Ausdrücke anzeigt.

    Is eligible for student discount? true
    Passed the exam? true
    Is not a student? false
    Complex condition result: true

Sie haben nun gelernt, wie man zusammengesetzte boolesche Ausdrücke mit den logischen Operatoren UND (&&), ODER (||) und NICHT (!) erstellt und auswertet. Dies ermöglicht es Ihnen, komplexere Bedingungen in Ihren Java-Programmen zu erstellen.

Erkennen von Fehlern bei ungültigen Ausdrücken

In diesem Schritt werden wir untersuchen, was passiert, wenn wir versuchen, Ausdrücke auszuwerten, die in Java nicht gültig sind, und wie der Compiler uns hilft, diese Fehler zu erkennen. Das Verständnis gängiger Fehler ist ein wichtiger Teil des Lernens jeder Programmiersprache.

Java ist eine stark typisierte Sprache, was bedeutet, dass der Datentyp von Bedeutung ist. Boolesche Ausdrücke erfordern speziell Operanden, die verglichen oder zu einem booleschen Wert ausgewertet werden können. Das Versuch, inkompatible Datentypen in einem booleschen Ausdruck zu verwenden, führt zu einem Kompilierungsfehler.

Lassen Sie uns absichtlich einen Fehler in unser HelloJava.java-Programm einfügen, um zu sehen, wie der Compiler reagiert.

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

  2. Ändern Sie den Code, um einen ungültigen Vergleich einzuschließen. Beispielsweise versuchen wir, einen booleschen Wert mit einer Ganzzahl zu vergleichen:

    public class HelloJava {
        public static void main(String[] args) {
            int age = 25;
            boolean isStudent = true;
    
            // This line will cause a compilation error
            // boolean invalidComparison = (isStudent == age);
    
            System.out.println("Age: " + age);
            System.out.println("Is student: " + isStudent);
        }
    }

    Wir haben die Zeile, die den Fehler verursachen wird, vorerst auskommentiert, aber wir werden sie im nächsten Schritt wieder einkommentieren. Die auskommentierte Zeile boolean invalidComparison = (isStudent == age); versucht, eine boolean-Variable (isStudent) mit einer int-Variable (age) mithilfe des Gleichheitsoperators (==) zu vergleichen. Java erlaubt diesen direkten Vergleich nicht, da boolean und int verschiedene Datentypen sind, die auf diese Weise nicht sinnvoll verglichen werden können.

  3. Speichern Sie die Datei (Strg+S oder Cmd+S).

  4. Lassen Sie uns nun die Zeile, die den Fehler verursachen wird, einkommentieren. Ändern Sie den Code wie folgt:

    public class HelloJava {
        public static void main(String[] args) {
            int age = 25;
            boolean isStudent = true;
    
            // This line will cause a compilation error
            boolean invalidComparison = (isStudent == age);
    
            System.out.println("Age: " + age);
            System.out.println("Is student: " + isStudent);
            System.out.println("Invalid comparison result: " + invalidComparison);
        }
    }
  5. Speichern Sie die Datei erneut.

  6. Versuchen Sie, das Programm im Terminal zu kompilieren:

    javac HelloJava.java

    Sie sollten eine Fehlermeldung des Java-Compilers sehen. Die genaue Meldung kann je nach Java-Version etwas variieren, aber sie wird auf einen Typfehler oder inkompatible Datentypen hinweisen.

    ~/project/HelloJava.java:7: error: incomparable types: boolean and int
            boolean invalidComparison = (isStudent == age);
                                         ^
    1 error

    Diese Fehlermeldung gibt Ihnen den Dateinamen (HelloJava.java), die Zeilennummer (7) und eine Beschreibung des Fehlers ("incomparable types: boolean and int"). Dies ist der Compiler, der Ihnen hilft, Fehler zu erkennen, bevor Sie das Programm einmal ausführen.

  7. Um den Fehler zu beheben und das Programm wieder kompilierbar zu machen, müssen Sie die ungültige Zeile entfernen oder auskommentieren. Ändern Sie den Code zurück zur Version, in der die Zeile auskommentiert ist:

    public class HelloJava {
        public static void main(String[] args) {
            int age = 25;
            boolean isStudent = true;
    
            // This line will cause a compilation error
            // boolean invalidComparison = (isStudent == age);
    
            System.out.println("Age: " + age);
            System.out.println("Is student: " + isStudent);
        }
    }
  8. Speichern Sie die Datei.

  9. Kompilieren Sie das Programm erneut:

    javac HelloJava.java

    Diesmal sollte die Kompilierung erfolgreich sein, und Sie sollten keine Fehlermeldungen sehen.

Das Verständnis von Kompilierungsfehlern und das Lesen dieser Meldungen ist eine entscheidende Fähigkeit für jeden Programmierer. Der Java-Compiler ist ein leistungsfähiges Werkzeug, das Ihnen hilft, viele gängige Fehler bereits in einem frühen Stadium des Entwicklungsprozesses zu finden.

Zusammenfassung

In diesem Lab haben wir die Grundlagen von booleschen Ausdrücken in Java gelernt. Wir haben zunächst verstanden, was ein boolescher Ausdruck ist und wie er entweder zu true (wahr) oder false (falsch) ausgewertet wird. Anschließend haben wir das Auswerten einfacher boolescher Ausdrücke mit gängigen Vergleichsoperatoren wie ==, !=, >, <, >= und <= geübt. Anhand eines praktischen Beispiels haben wir gesehen, wie man Ganzzahlvariablen deklariert, diese Vergleichsoperatoren anwendet, um boolesche Ausdrücke zu erstellen, und die resultierenden booleschen Werte ausgibt.

Aufbauend auf einfachen Ausdrücken haben wir untersucht, wie man zusammengesetzte boolesche Ausdrücke behandelt, indem man einfache Ausdrücke mit logischen Operatoren wie && (UND), || (ODER) und ! (NICHT) kombiniert. Wir haben gelernt, wie diese Operatoren funktionieren und wie man Klammern verwendet, um die Auswertungsreihenfolge in komplexen Ausdrücken zu steuern. Schließlich haben wir die Wichtigkeit behandelt, potenzielle Fehler zu behandeln, die aus ungültigen booleschen Ausdrücken entstehen können, und verstanden, wie man Probleme erkennt und behebt, die eine korrekte Auswertung eines Ausdrucks verhindern könnten.