Variablen und Operatoren in Java

Einführung

In diesem Lab werden wir grundlegende Konzepte der Java-Programmierung erkunden: Variablen und Operatoren. Wir werden lernen, wie man verschiedene Typen von Variablen deklariert, einige primitive Datentypen versteht und mit verschiedenen Operatoren und Ausdrücken arbeitet. Diese praktische Erfahrung wird Anfängern in der Java-Programmierung eine solide Grundlage bieten.

Skills Graph

Variablen und Datentypen verstehen

Variablen sind benannte Speicherorte, die in der Programmierung Werte enthalten. Java bietet mehrere primitive Datentypen, die jeweils für die Speicherung bestimmter Werttypen ausgelegt sind. Lassen Sie uns diese Konzepte anhand praktischer Beispiele erkunden.

Zunächst erstellen wir eine Java-Datei, um die Deklaration und Verwendung von Variablen zu demonstrieren. Im WebIDE (das ähnlich wie VS Code ist) erstellen Sie eine neue Datei mit dem Namen VariableDemo.java. Sie können dies tun, indem Sie im Dateiexplorer-Bereich mit der rechten Maustaste klicken, "Neue Datei" auswählen und den Dateinamen eingeben.

Kopieren Sie den folgenden Code und fügen Sie ihn in die Datei ein:

public class VariableDemo {
    public static void main(String[] args) {
        // Declaring and initializing variables of different types
        byte smallNumber = 127;
        short mediumNumber = 32000;
        int largeNumber = 2000000000;
        long veryLargeNumber = 9000000000000000000L;
        float decimalNumber = 3.14f;
        double preciseDecimal = 3.14159265359;
        char singleCharacter = 'A';
        boolean isJavaFun = true;

        // Printing the values
        System.out.println("byte: " + smallNumber);
        System.out.println("short: " + mediumNumber);
        System.out.println("int: " + largeNumber);
        System.out.println("long: " + veryLargeNumber);
        System.out.println("float: " + decimalNumber);
        System.out.println("double: " + preciseDecimal);
        System.out.println("char: " + singleCharacter);
        System.out.println("boolean: " + isJavaFun);
    }
}

Lassen Sie uns diesen Code zur besseren Verständnis aufschlüsseln:

1. Wir beginnen mit der Deklaration einer Klasse namens VariableDemo. In Java muss jedes Programm mindestens eine Klasse haben.

2. Innerhalb der Klasse haben wir die main-Methode. Dies ist der Einstiegspunkt unseres Java-Programms, an dem die Ausführung beginnt.

3. Anschließend deklarieren und initialisieren wir Variablen verschiedener primitiver Datentypen:

   • byte: Wird für sehr kleine Ganzzahlwerte (-128 bis 127) verwendet
   • short: Wird für kleine Ganzzahlwerte (-32.768 bis 32.767) verwendet
   • int: Wird für Ganzzahlwerte (etwa -2 Milliarden bis 2 Milliarden) verwendet
   • long: Wird für sehr große Ganzzahlwerte (etwa -9 Quintillion bis 9 Quintillion) verwendet
   • float: Wird für Dezimalzahlen (einfache Genauigkeit) verwendet
   • double: Wird für Dezimalzahlen mit höherer Genauigkeit verwendet
   • char: Wird für einzelne Zeichen verwendet
   • boolean: Wird für Wahrheitswerte (true/false) verwendet

4. Beachten Sie das L-Suffix für den long-Wert und das f-Suffix für den float-Wert. Diese sind erforderlich, um Java mitzuteilen, dass diese Literale als long bzw. float behandelt werden sollen.

5. Schließlich geben wir jeden Variablenwert mit System.out.println() aus. Der +-Operator wird hier zur Stringverkettung verwendet, um die beschreibende Zeichenkette mit dem Variablenwert zu verbinden.

Jetzt lassen Sie uns dieses Programm ausführen. Im WebIDE öffnen Sie den Terminalbereich und führen Sie den folgenden Befehl aus:

javac VariableDemo.java
java VariableDemo

Sie sollten in der Konsolenausgabe eine Ausgabe ähnlich wie diese sehen:

byte: 127
short: 32000
int: 2000000000
long: 9000000000000000000
float: 3.14
double: 3.14159265359
char: A
boolean: true

Diese Ausgabe zeigt die Werte jeder Variablen, die wir deklariert und initialisiert haben. Nehmen Sie sich einen Moment Zeit, um zu überprüfen, ob jeder ausgegebene Wert mit dem übereinstimmt, was wir im Code zugewiesen haben.

Arbeiten mit arithmetischen Operatoren

Arithmetische Operatoren in Java ermöglichen es uns, mathematische Berechnungen durchzuführen. Lassen Sie uns eine neue Datei erstellen, um diese Operatoren zu demonstrieren.

Im WebIDE erstellen Sie eine neue Datei mit dem Namen ArithmeticDemo.java. Kopieren Sie den folgenden Code und fügen Sie ihn ein:

public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

        System.out.println("Addition: " + (a + b));
        System.out.println("Subtraction: " + (a - b));
        System.out.println("Multiplication: " + (a * b));
        System.out.println("Division: " + (a / b));
        System.out.println("Modulus: " + (a % b));

        // Increment and decrement
        int c = 5;
        System.out.println("c before increment: " + c);
        System.out.println("c after increment: " + (++c));
        System.out.println("c after decrement: " + (--c));
    }
}

Lassen Sie uns diesen Code aufschlüsseln:

1. Wir deklarieren zwei Ganzzahlvariablen, a und b, und weisen ihnen die Werte 10 bzw. 3 zu.

2. Anschließend führen wir verschiedene arithmetische Operationen aus:

   • Addition (+): Addiert zwei Zahlen
   • Subtraktion (-): Subtrahiert den rechten Operanden vom linken Operanden
   • Multiplikation (*): Multipliziert zwei Zahlen
   • Division (/): Teilt den linken Operanden durch den rechten Operanden
   • Modulo (%): Gibt den Rest zurück, wenn der linke Operand durch den rechten Operanden geteilt wird

3. Wir demonstrieren auch die Inkrement- (++) und Dekrement- (--) Operatoren:

   • ++c erhöht den Wert von c um 1, bevor er in der Expression verwendet wird
   • --c verringert den Wert von c um 1, bevor er in der Expression verwendet wird

Führen Sie dieses Programm im WebIDE aus. Sie sollten eine Ausgabe ähnlich wie diese sehen:

Addition: 13
Subtraction: 7
Multiplication: 30
Division: 3
Modulus: 1
c before increment: 5
c after increment: 6
c after decrement: 5

Beachten Sie, dass bei der Division von Ganzzahlen (a / b) Java eine Ganzzahldivision durchführt und jeglichen Dezimalteil abschneidet. Deshalb ergibt 10 / 3 3 und nicht 3,33333....

Beobachten Sie auch, wie die Inkrement- und Dekrementoperatoren den Wert von c beeinflussen. Das Verständnis dieser Operatoren ist für viele Programmieraufgaben von entscheidender Bedeutung, insbesondere wenn Sie mit Schleifen arbeiten.

Verständnis von bitweisen Operatoren

Bitweise Operatoren in Java ermöglichen die Manipulation einzelner Bits in Ganzzahltypen. Diese Operatoren werden in der alltäglichen Programmierung weniger häufig verwendet, sind aber in bestimmten Szenarien von entscheidender Bedeutung, beispielsweise beim Umgang mit Binärdaten oder bei der Optimierung bestimmter Algorithmen.

Im WebIDE erstellen Sie eine neue Datei mit dem Namen BitwiseDemo.java. Kopieren Sie den folgenden Code und fügen Sie ihn ein:

public class BitwiseDemo {
    public static void main(String[] args) {
        int a = 60;  // 60 = 0011 1100 in binary
        int b = 13;  // 13 = 0000 1101 in binary

        System.out.println("a & b = " + (a & b));   // AND
        System.out.println("a | b = " + (a | b));   // OR
        System.out.println("a ^ b = " + (a ^ b));   // XOR
        System.out.println("~a = " + (~a));         // NOT
        System.out.println("a << 2 = " + (a << 2)); // Left Shift
        System.out.println("a >> 2 = " + (a >> 2)); // Right Shift
    }
}

Lassen Sie uns diese bitweisen Operationen aufschlüsseln:

1. UND (&): Gibt 1 zurück, wenn beide Bits 1 sind, sonst 0.

   • 60 & 13 = 0011 1100 & 0000 1101 = 0000 1100 (12 im Dezimalsystem)

2. ODER (|): Gibt 1 zurück, wenn mindestens ein Bit 1 ist, sonst 0.

   • 60 | 13 = 0011 1100 | 0000 1101 = 0011 1101 (61 im Dezimalsystem)

3. Exklusiv-ODER (^): Gibt 1 zurück, wenn die Bits unterschiedlich sind, 0, wenn sie gleich sind.

   • 60 ^ 13 = 0011 1100 ^ 0000 1101 = 0011 0001 (49 im Dezimalsystem)

4. NICHT (~): Invertiert alle Bits.

   • ~60 = ~0011 1100 = 1100 0011 (-61 im Dezimalsystem, aufgrund der Zweierkomplement-Darstellung)

5. Linksshift (<<): Verschiebt alle Bits um die angegebene Anzahl von Positionen nach links.

   • 60 << 2 = 0011 1100 << 2 = 1111 0000 (240 im Dezimalsystem)

6. Rechtsshift (>>): Verschiebt alle Bits um die angegebene Anzahl von Positionen nach rechts.

   • 60 >> 2 = 0011 1100 >> 2 = 0000 1111 (15 im Dezimalsystem)

Führen Sie dieses Programm im WebIDE aus. Sie sollten eine Ausgabe ähnlich wie diese sehen:

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15

Das Verständnis von bitweisen Operatoren kann zunächst schwierig sein, aber sie sind für bestimmte Arten von Operationen sehr leistungsstark, insbesondere bei der Arbeit mit Low-Level-Programmierung oder bei der Optimierung von Code für die Leistung.

Erkundung logischer Operatoren

Logische Operatoren in Java werden verwendet, um logische Operationen auf booleschen Werten durchzuführen. Diese Operatoren sind für die Erstellung komplexer Bedingungen in Ihren Programmen unerlässlich.

Im WebIDE erstellen Sie eine neue Datei mit dem Namen LogicalDemo.java. Kopieren Sie den folgenden Code und fügen Sie ihn ein:

public class LogicalDemo {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a && b = " + (a && b)); // Logical AND
        System.out.println("a || b = " + (a || b)); // Logical OR
        System.out.println("!a = " + (!a));         // Logical NOT

        // Short-circuit evaluation
        int x = 5;
        int y = 10;
        System.out.println("x < 0 && y++ > 5 = " + (x < 0 && y++ > 5));
        System.out.println("y after evaluation: " + y);
    }
}

Lassen Sie uns diese logischen Operationen aufschlüsseln:

1. UND (&&): Gibt true zurück, wenn beide Operanden true sind, sonst false.

   • true && false = false

2. ODER (||): Gibt true zurück, wenn mindestens ein Operand true ist, sonst false.

   • true || false = true

3. NICHT (!): Invertiert den booleschen Wert.

   • !true = false

4. Kurzschlussauswertung: In der Expression x < 0 && y++ > 5 wertet Java zunächst x < 0 aus. Da dies false ist, wird der zweite Teil (y++ > 5) nicht ausgewertet, da das Gesamtergebnis unabhängig davon false sein muss. Deshalb bleibt y nach der Auswertung 10.

Führen Sie dieses Programm im WebIDE aus. Sie sollten eine Ausgabe ähnlich wie diese sehen:

a && b = false
a || b = true
!a = false
x < 0 && y++ > 5 = false
y after evaluation: 10

Das Verständnis logischer Operatoren ist für die Erstellung von Bedingungen in Ihren Programmen, beispielsweise in if-Anweisungen oder while-Schleifen, von entscheidender Bedeutung. Das Kurzschlussverhalten von && und || kann auch in bestimmten Situationen zur Optimierung Ihres Codes genutzt werden.

Alles zusammenführen

Nachdem wir verschiedene Arten von Operatoren kennengelernt haben, erstellen wir nun ein einfaches Taschenrechner-Programm, das mehrere Arten von Operatoren verwendet. Dies wird helfen, das Gelernte zu festigen und zu zeigen, wie diese Konzepte in einem praktischen Szenario angewendet werden können.

Im WebIDE erstellen Sie eine neue Datei mit dem Namen SimpleCalculator.java. Kopieren Sie den folgenden Code und fügen Sie ihn ein:

public class SimpleCalculator {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        // Arithmetic operations
        System.out.println("Arithmetic Operations:");
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));

        // Bitwise operations
        System.out.println("\nBitwise Operations:");
        System.out.println("a & b = " + (a & b));
        System.out.println("a | b = " + (a | b));
        System.out.println("a ^ b = " + (a ^ b));
        System.out.println("~a = " + (~a));

        // Logical operations
        boolean x = a > b;
        boolean y = a < b;
        System.out.println("\nLogical Operations:");
        System.out.println("x && y = " + (x && y));
        System.out.println("x || y = " + (x || y));
        System.out.println("!x = " + (!x));

        // Combining operations
        System.out.println("\nCombined Operations:");
        System.out.println("(a + b) * 2 = " + ((a + b) * 2));
        System.out.println("(a > b) && (a % b == 0) = " + ((a > b) && (a % b == 0)));
    }
}

Lassen Sie uns diesen Code aufschlüsseln und jeden Teil erklären:

1. Arithmetische Operationen:

   • Wir führen grundlegende arithmetische Operationen (Addition, Subtraktion, Multiplikation, Division und Modulo) auf a und b aus.
   • Diese Operationen demonstrieren, wie die zuvor gelernten arithmetischen Operatoren verwendet werden.

2. Bitweise Operationen:

   • Wir führen bitweise UND-, ODER-, Exklusiv-ODER- und NICHT-Operationen auf a und b aus.
   • Diese Operationen zeigen, wie bitweise Operatoren auf die binären Darstellungen von Ganzzahlen wirken.

3. Logische Operationen:

   • Wir erstellen zwei boolesche Variablen, x und y, basierend auf Vergleichen zwischen a und b.
   • Anschließend demonstrieren wir logische UND-, ODER- und NICHT-Operationen auf diesen booleschen Werten.

4. Kombinierte Operationen:

   • Wir zeigen, wie verschiedene Arten von Operatoren in komplexeren Ausdrücken kombiniert werden können.
   • (a + b) * 2 demonstriert die Verwendung von Klammern zur Steuerung der Ausführungsreihenfolge.
   • (a > b) && (a % b == 0) kombiniert einen Vergleich, eine Modulo-Operation und ein logisches UND.

Führen Sie dieses Programm im WebIDE aus. Sie sollten eine Ausgabe ähnlich wie diese sehen:

Arithmetic Operations:
a + b = 15
a - b = 5
a * b = 50
a / b = 2
a % b = 0

Bitwise Operations:
a & b = 0
a | b = 15
a ^ b = 15
~a = -11

Logical Operations:
x && y = false
x || y = true
!x = false

Combined Operations:
(a + b) * 2 = 30
(a > b) && (a % b == 0) = true

Diese Ausgabe zeigt, wie jeder Typ von Operator funktioniert:

• Die arithmetischen Operationen liefern die erwarteten mathematischen Ergebnisse.
• Die bitweisen Operationen zeigen die Ergebnisse der Manipulation der binären Darstellungen von a und b.
• Die logischen Operationen zeigen, wie boolesche Werte kombiniert werden können.
• Die kombinierten Operationen demonstrieren, wie wir komplexere Ausdrücke unter Verwendung mehrerer Arten von Operatoren erstellen können.

Das Verständnis, wie diese Operatoren kombiniert werden können, ist für das Schreiben komplexerer und effizienterer Java-Programme von entscheidender Bedeutung. Wenn Sie in Ihrer Java-Reise voranschreiten, werden Sie feststellen, dass Sie diese Operatoren in verschiedenen Kombinationen verwenden, um immer komplexere Probleme zu lösen.

Zusammenfassung

In diesem Lab haben wir grundlegende Konzepte der Java-Programmierung kennengelernt: Variablen und Operatoren. Wir haben gelernt, wie man verschiedene Arten von Variablen deklariert und verwendet, einschließlich primitiver Datentypen wie int, boolean und char. Anschließend haben wir uns verschiedenen Operatoren in Java gewidmet:

1. Arithmetische Operatoren für grundlegende mathematische Berechnungen
2. Bitweise Operatoren zur Manipulation einzelner Bits in Ganzzahltypen
3. Logische Operatoren für die Arbeit mit booleschen Werten

Anhand praktischer Beispiele haben wir gesehen, wie diese Operatoren einzeln und in Kombination eingesetzt werden können, um eine Vielzahl von Operationen auszuführen. Wir haben ein einfaches Taschenrechner-Programm erstellt, das die Verwendung mehrerer Arten von Operatoren in einer einzigen Anwendung demonstriert.