Wie schreibt man Operatoren in Java?

In Java gibt es verschiedene Arten von Operatoren, die für unterschiedliche Zwecke verwendet werden. Hier sind einige der wichtigsten Kategorien und Beispiele für deren Verwendung:

1. **Arithmetische Operatoren**:
- Addition: `+`
- Subtraktion: `-`
- Multiplikation: `*`
- Division: `/`
- Modulo (Rest): `%`

```java
int a = 10;
int b = 5;
int sum = a + b; // 15
int difference = a - b; // 5
int product = a * b; // 50
int quotient = a / b; // 2
int remainder = a % b; // 0
```

2. **Vergleichsoperatoren**:
- Gleich: `==`
- Ungleich: `!=`
- Größer als: `>`
- Kleiner als: `<`
- Größer oder gleich: `>=`
- Kleiner oder gleich: `<=`

```java
int x = 10;
int y = 20;
boolean isEqual = (x == y); // false
boolean isNotEqual = (x != y); // true
boolean isGreater = (x > y); // false
boolean isLess = (x < y); // true
```

3. **Logische Operatoren**:
- UND: `&&`
- ODER: `||`
- NICHT: `!`

```java
boolean a = true;
boolean b = false;
boolean andResult = a && b; //
boolean orResult = a || b; // true
boolean notResult = !a; // false
```

4. **Zuweisungsoperatoren**:
- Zuweisung: `=`
- Addiere und weise zu: `+=`
- Subtrahiere und weise zu: `-=`
- Multipliziere und weise zu: `*=`
- Dividiere und weise zu: `/=`
- Modulo und weise zu: `%=`

```java
int num = 10;
num += 5; // num ist jetzt 15
num -= 3; // num ist jetzt 12
num *= 2; // num ist jetzt 24
num /= 4; // num ist jetzt 6
num %= 5; // num ist jetzt 1
```

5. **Inkrement- und Dekrementoperatoren**:
- Inkrement: `++`
- Dekrement: `--`

```java
int i = 0;
i++; // i ist jetzt 1
i--; // i ist jetzt 0
```

6. **Bitweise Operatoren**:
- UND: `&`
- ODER: `|`
- XOR: `^`
- NICHT: `~`
- Linksverschiebung: `<<`
- Rechtsverschiebung: `>>`
- Unsigned Rechtsverschiebung: `>>>`

```java
int p = 5; // 0101 in binär
int q = 3; // 0011 in binär
int andResult = p & q; // 0001 in binär, 1 in dezimal
int orResult = p | q; // 0111 in binär, 7 in dezimal
int xorResult = p ^ q; // 0110 in binär, 6 in dezimal
int notResult = ~p; // 1010 in binär (Zweierkomplement), -6 in dezimal
int leftShift = p << 1; // 1010 in binär, 10 in dezimal
int rightShift = p >> 1; // 0010 in binär, 2 in dezimal
int unsignedRightShift = p >>> 1; // 0010 in binär, 2 in dezimal
```

Diese Operatoren sind grundlegende Werkzeuge in Java und werden häufig in der Programmierung verwendet.