Java Operatoren meistern: Typen, Syntax und praktische Beispiele

Java Operatoren

In diesem Tutorial lernen Sie die verschiedenen Arten von Operatoren in Java, ihre Syntax und wie Sie sie anhand von Beispielen verwenden.

Operatoren sind Symbole, die Operationen auf Variablen und Werte ausführen. Zum Beispiel ist + ein Operator für Addition, während * ein Operator für Multiplikation ist.

Operatoren in Java lassen sich in 6 Typen klassifizieren:

1. Arithmetische Operatoren
2. Zuweisungsoperatoren
3. Relationale Operatoren
4. Logische Operatoren
5. Unäre Operatoren
6. Bitweise Operatoren

---

1. Java Arithmetische Operatoren

Arithmetische Operatoren werden verwendet, um arithmetische Operationen auf Variablen und Daten auszuführen. Zum Beispiel:

a + b;

Hier wird der +-Operator verwendet, um zwei Variablen a und b zu addieren. Ebenso gibt es verschiedene andere arithmetische Operatoren in Java.

Operator	Operation
+	Addition
-	Subtraktion
*	Multiplikation
/	Division
%	Modulo-Operation (Rest nach Division)

Beispiel 1: Arithmetische Operatoren

class Main {
    public static void main(String[] args) {
        // Variablen deklarieren
        int a = 12, b = 5;
        // Additionsoperator
        System.out.println("a + b = " + (a + b));
        // Subtraktionsoperator
        System.out.println("a - b = " + (a - b));
        // Multiplikationsoperator
        System.out.println("a * b = " + (a * b));
        // Divisionsoperator
        System.out.println("a / b = " + (a / b));
        // Modulo-Operator
        System.out.println("a % b = " + (a % b));
    }
}

Ausgabe

a + b = 17
a - b = 7
a * b = 60
a / b = 2
a % b = 2

Im obigen Beispiel haben wir die Operatoren +, - und * verwendet, um Addition, Subtraktion und Multiplikation zu berechnen.

/ Divisionsoperator

Beachten Sie die Operation a / b in unserem Programm. Der /-Operator ist der Divisionsoperator.

Wenn wir den Divisionsoperator mit zwei Ganzzahlen verwenden, wird der resultierende Quotient ebenfalls eine Ganzzahl sein. Und wenn einer der Operanden eine Gleitkommazahl ist, wird das Ergebnis ebenfalls ein Gleitkommawert sein.

In Java: (9 / 2) ist 4
(9.0 / 2) ist 4.5
(9 / 2.0) ist 4.5
(9.0 / 2.0) ist 4.5

% Modulo-Operator

Der Modulo-Operator % berechnet den Rest. Wenn a = 7 durch b = 4 geteilt wird, ist der Rest 3.

Hinweis: Der %-Operator wird hauptsächlich mit Ganzzahlen verwendet.

---

2. Java Zuweisungsoperatoren

Zuweisungsoperatoren werden in Java verwendet, um Werte Variablen zuzuweisen. Zum Beispiel:

int age;
age = 5;

Hier ist = der Zuweisungsoperator. Er weist den Wert auf seiner rechten Seite der Variablen auf seiner linken Seite zu. Das heißt, 5 wird der Variable age zugewiesen.

Sehen wir uns weitere in Java verfügbare Zuweisungsoperatoren an.

Operator	Beispiel	Entspricht
=	a = b;	a = b;
+=	a += b;	a = a + b;
-=	a -= b;	a = a - b;
*=	a *= b;	a = a * b;
/=	a /= b;	a = a / b;
%=	a %= b;	a = a % b;

Beispiel 2: Zuweisungsoperatoren

class Main {
    public static void main(String[] args) {
        // Variablen erstellen
        int a = 4;
        int var;
        // Wert mit = zuweisen
        var = a;
        System.out.println("var mit =: " + var);
        // Wert mit += zuweisen
        var += a;
        System.out.println("var mit +=: " + var);
        // Wert mit *= zuweisen
        var *= a;
        System.out.println("var mit *=: " + var);
    }
}

Ausgabe

var mit =: 4
var mit +=: 8
var mit *=: 32

---

3. Java Relationale Operatoren

Relationale Operatoren werden verwendet, um die Beziehung zwischen zwei Operanden zu prüfen. Zum Beispiel:

// prüfen, ob a kleiner als b ist
a < b;

Hier ist der <-Operator der relationale Operator. Er prüft, ob a kleiner als b ist oder nicht.

Er gibt entweder true oder false zurück.

Operator	Beschreibung	Beispiel
==	Ist Gleich	3 == 5 gibt false
!=	Ist Nicht Gleich	3 != 5 gibt true
>	Größer Als	3 > 5 gibt false
<	Kleiner Als	3 < 5 gibt true
>=	Größer Oder Gleich	3 >= 5 gibt false
<=	Kleiner Oder Gleich	3 <= 5 gibt true

Beispiel 3: Relationale Operatoren

class Main {
    public static void main(String[] args) {
        // Variablen erstellen
        int a = 7, b = 11;
        // Wert von a und b
        System.out.println("a ist " + a + " und b ist " + b);
        // == Operator
        System.out.println(a == b); // false
        // != Operator
        System.out.println(a != b); // true
        // > Operator
        System.out.println(a > b); // false
        // < Operator
        System.out.println(a < b); // true
        // >= Operator
        System.out.println(a >= b); // false
        // <= Operator
        System.out.println(a <= b); // true
    }
}

Hinweis: Relationale Operatoren werden in Entscheidungsfindung und Schleifen verwendet.

---

4. Java Logische Operatoren

Logische Operatoren werden verwendet, um zu prüfen, ob ein Ausdruck true oder false ist. Sie werden in der Entscheidungsfindung verwendet.

Operator	Beispiel	Bedeutung
&& (Logisches UND)	expression1 && expression2	true nur wenn beide expression1 und expression2 true sind
|| (Logisches ODER)	expression1 || expression2	true wenn entweder expression1 oder expression2 true ist
! (Logisches NICHT)	!expression	true wenn expression false ist und umgekehrt

Beispiel 4: Logische Operatoren

class Main {
    public static void main(String[] args) {
        // && Operator
        System.out.println((5 > 3) && (8 > 5)); // true
        System.out.println((5 > 3) && (8 < 5)); // false
        // || Operator
        System.out.println((5 < 3) || (8 > 5)); // true
        System.out.println((5 > 3) || (8 < 5)); // true
        System.out.println((5 < 3) || (8 < 5)); // false
        // ! Operator
        System.out.println(!(5 == 3)); // true
        System.out.println(!(5 > 3)); // false
    }
}

Funktionsweise des Programms

• (5 > 3) && (8 > 5) gibt true zurück, weil sowohl (5 > 3) als auch (8 > 5) true sind.
• (5 > 3) && (8 < 5) gibt false zurück, weil der Ausdruck (8 < 5) false ist.
• (5 < 3) || (8 > 5) gibt true zurück, weil der Ausdruck (8 > 5) true ist.
• (5 > 3) || (8 < 5) gibt true zurück, weil der Ausdruck (5 > 3) true ist.
• (5 < 3) || (8 < 5) gibt false zurück, weil sowohl (5 < 3) als auch (8 < 5) false sind.
• !(5 == 3) gibt true zurück, weil 5 == 3 false ist.
• !(5 > 3) gibt false zurück, weil 5 > 3 true ist.

---

5. Java Unäre Operatoren

Unäre Operatoren werden mit nur einem Operanden verwendet. Zum Beispiel ist ++ ein unärer Operator, der den Wert einer Variable um 1 erhöht. Das heißt, ++5 gibt 6 zurück.

Verschiedene Arten von unären Operatoren sind:

Operator	Bedeutung
+	Unäres Plus: nicht notwendig, da Zahlen ohne es positiv sind
-	Unäres Minus: kehrt das Vorzeichen eines Ausdrucks um
++	Inkrementoperator: erhöht Wert um 1
--	Dekrementoperator: verringert Wert um 1
!	Logischer Komplementoperator: kehrt den Wert eines Booleans um

Inkrement- und Dekrementoperatoren

Java bietet auch Inkrement- und Dekrementoperatoren: ++ und -- jeweils. ++ erhöht den Wert des Operanden um 1, während -- ihn um 1 verringert. Zum Beispiel:

int num = 5;
// num um 1 erhöhen
++num;

Hier wird der Wert von num von seinem Anfangswert 5 auf 6 erhöht.

---

Beispiel 5: Inkrement- und Dekrementoperatoren

class Main {
    public static void main(String[] args) {
        // Variablen deklarieren
        int a = 12, b = 12;
        int result1, result2;
        // Originalwert
        System.out.println("Wert von a: " + a);
        // Inkrementoperator
        result1 = ++a;
        System.out.println("Nach Inkrement: " + result1);
        System.out.println("Wert von b: " + b);
        // Dekrementoperator
        result2 = --b;
        System.out.println("Nach Dekrement: " + result2);
    }
}

Ausgabe

Wert von a: 12
Nach Inkrement: 13
Wert von b: 12
Nach Dekrement: 11

Im obigen Programm haben wir die Operatoren ++ und -- als Präfixe (++a, --b) verwendet. Wir können diese Operatoren auch als Postfix (a++, b++) verwenden.

Es gibt einen leichten Unterschied, wenn diese Operatoren als Präfix versus Postfix verwendet werden.

Um mehr über diese Operatoren zu erfahren, besuchen Sie Inkrement- und Dekrementoperatoren.

---

6. Java Bitweise Operatoren

Bitweise Operatoren in Java werden verwendet, um Operationen auf einzelnen Bits auszuführen. Zum Beispiel:

Bitweises Komplement von 35
35 = 00100011 (Im Binärformat)
~ 00100011
________
11011100 = 220 (Im Dezimalformat)

Hier ist ~ ein bitweiser Operator. Er invertiert den Wert jedes Bits (0 zu 1 und 1 zu 0).

Die verschiedenen in Java vorhandenen bitweisen Operatoren sind:

Operator	Beschreibung
~	Bitweises Komplement
<<	Linksverschiebung
>>	Rechtsverschiebung
>>>	Vorzeichenlose Rechtsverschiebung
&	Bitweises UND
^	Bitweises exklusives ODER

Diese Operatoren werden in Java nicht allgemein verwendet. Um mehr zu erfahren, besuchen Sie Java Bitweise und Bit Shift Operatoren.

---

Weitere Operatoren

Neben diesen Operatoren gibt es in Java weitere zusätzliche Operatoren.

Java instanceof Operator

Der instanceof-Operator prüft, ob ein Objekt eine Instanz einer bestimmten Klasse ist. Zum Beispiel:

class Main {
    public static void main(String[] args) {
        String str = "Programiz";
        boolean result;
        // prüft, ob str eine Instanz der
        // String-Klasse ist
        result = str instanceof String;
        System.out.println("Ist str ein Objekt von String? " + result);
    }
}

Ausgabe

Ist str ein Objekt von String? true

Hier ist str eine Instanz der String-Klasse. Daher gibt der instanceof-Operator true zurück. Mehr erfahren unter Java instanceof.

---

Java Ternärer Operator

Der ternäre Operator (bedingter Operator) ist eine Kurzform für die if-then-else-Anweisung. Zum Beispiel:

variable = Ausdruck ? ausdruck1 : ausdruck2

So funktioniert es:

• Wenn der Ausdruck true ist, wird ausdruck1 der variable zugewiesen.
• Wenn der Ausdruck false ist, wird ausdruck2 der variable zugewiesen.

Sehen wir uns ein Beispiel für einen ternären Operator an.

class Java {
    public static void main(String[] args) {
        int februaryDays = 29;
        String result;
        // ternärer Operator
        result = (februaryDays == 28) ? "Kein Schaltjahr" : "Schaltjahr";
        System.out.println(result);
    }
}

Ausgabe

Schaltjahr

Im obigen Beispiel haben wir den ternären Operator verwendet, um zu prüfen, ob das Jahr ein Schaltjahr ist oder nicht. Mehr erfahren unter Java ternärer Operator.

---

Nun, da Sie über Java-Operatoren Bescheid wissen, ist es an der Zeit, die Reihenfolge zu kennen, in der Operatoren ausgewertet werden. Mehr erfahren unter Java Operator Precedence.