Operator - Versionsgeschichte

Thomas: Die Seite wurde neu angelegt: „== Einführung == Java kennt eine Vielzahl von arithmetischen, logischen, und relationalen Operatoren. Es folgen einige gängige Operatoren. Bis auf wenige Ausnahmen sollten alle Operatoren und das, was sie leisten, aus der Schule bekannt sein. == Arithmetische Operatoren == {| class="wikitable center" style="text-align:left" ! Operator ! Beschreibung ! Kurzbeispiel |- | style="width: 5%" | + | style="width:50%" | Addition ||
2025-09-30T08:31:42Z

Die Seite wurde neu angelegt: „== Einführung == Java kennt eine Vielzahl von arithmetischen, logischen, und relationalen Operatoren. Es folgen einige gängige Operatoren. Bis auf wenige Ausnahmen sollten alle Operatoren und das, was sie leisten, aus der Schule bekannt sein. == Arithmetische Operatoren == {| class="wikitable center" style="text-align:left" ! Operator ! Beschreibung ! Kurzbeispiel |- | style="width: 5%" | + | style="width:50%" | Addition || <syntaxhighlight lang=…“

Neue Seite
== Einführung ==
[[Java]] kennt eine Vielzahl von arithmetischen, logischen, und relationalen Operatoren. Es folgen einige gängige Operatoren. Bis auf wenige Ausnahmen sollten alle Operatoren und das, was sie leisten, aus der Schule bekannt sein.

== Arithmetische Operatoren ==
{| class="wikitable center" style="text-align:left"
! Operator
! Beschreibung
! Kurzbeispiel
|-
| style="width: 5%" | +
| style="width:50%" | Addition || <syntaxhighlight lang="java" inline>int antwort = 40 + 2;</syntaxhighlight>
|-
|| - || Subtraktion || <syntaxhighlight lang="java" inline>int antwort = 48 - 6;</syntaxhighlight>
|-
|| * || Multiplikation || <syntaxhighlight lang="java" inline>int antwort = 2 * 21;</syntaxhighlight>
|-
|| / || Division || <syntaxhighlight lang="java" inline>int antwort = 84 / 2;</syntaxhighlight>
|-
|| % || Teilerrest, Modulo-Operation, errechnet den Rest einer Division || <syntaxhighlight lang="java" inline>int antwort = 99 % 57;</syntaxhighlight>
|-
||+ || positives Vorzeichen, in der Regel überflüssig || <syntaxhighlight lang="java" inline>int j = +3;</syntaxhighlight>
|-
|| - || negatives Vorzeichen || <syntaxhighlight lang="java" inline>int minusJ = -j;</syntaxhighlight>
|-
|}

Für zwei besonders in [[Schleife|Schleifen]] häufig anzutreffende Berechnungen gibt es eine abkürzende Schreibweise.
{| class="wikitable center" style="text-align:left"
! Operator
! Beschreibung
! Kurzbeispiel
|-
| style="width: 5%"| ++
| style="width:50%"| Postinkrement, Addiert 1 zu einer numerischen Variablen || <syntaxhighlight lang="java" inline>x++;</syntaxhighlight>
|-
|| ++ || Preinkrement, Addiert 1 zu einer numerischen Variablen || <syntaxhighlight lang="java" inline>++x;</syntaxhighlight>
|-
|| -- || Postdekrement, Subtrahiert 1 von einer numerischen Variablen || <syntaxhighlight lang="java" inline>x--;</syntaxhighlight>
|-
|| -- || Predekrement, Subtrahiert 1 von einer numerischen Variablen || <syntaxhighlight lang="java" inline>--x;</syntaxhighlight>
|-
|}

Post- und Pre-Operatoren verhalten sich bezüglich ihrer Berechnung absolut gleich, der Unterschied ist der Zeitpunkt, wann die Operation ausgeführt wird. Zum Tragen kommt das bei Zuweisungen:

<syntaxhighlight lang="java">
i = 1;
a = ++i; // i = 2 und a = 2 (erst hochzählen, dann zuweisen)

i = 1;
b = i++; // i = 2 und b = 1 (erst zuweisen, dann hochzählen)
</syntaxhighlight>

== Operatoren für Vergleiche ==
Das Ergebnis dieser Operationen ist aus der Menge <code>true</code>, <code>false</code>:

{| class="wikitable center" style="text-align:left"
! Operator
! Beschreibung
! Kurzbeispiel
|-
| style="width: 5%" | ==
| style="width:50%" | gleich || <syntaxhighlight lang="java" inline> 3 == 3 </syntaxhighlight>
|-
|| != || ungleich || <syntaxhighlight lang="java" inline> 4 != 3 </syntaxhighlight>
|-
|| > || größer als || <syntaxhighlight lang="java" inline> 4 > 3 </syntaxhighlight>
|-
|| < || kleiner als || <syntaxhighlight lang="java" inline> -4 < -3 </syntaxhighlight>
|-
|| >= || größer als oder gleich || <syntaxhighlight lang="java" inline> 3 >= 3 </syntaxhighlight>
|-
||<= || kleiner als oder gleich || <syntaxhighlight lang="java" inline> -4 <= 4 </syntaxhighlight>
|-
|}

== Boolesche Operatoren ==
{| class="wikitable center" style="text-align:left"
! Operator
! Beschreibung
! Kurzbeispiel
|-
| style="width: 5%" | !
| style="width:50%" | Negation, invertiert den Ausdruck || <syntaxhighlight lang="java" inline>boolean lügnerSpricht = !wahrheit;</syntaxhighlight>
|-
|| && || Und, <code>true</code>, genau dann wenn alle Argumente <code>true</code> sind || <syntaxhighlight lang="java" inline>boolean krümelmonster = istBlau && magKekse;</syntaxhighlight>
|-
|| <nowiki>||</nowiki> || or <code>true</code>, wenn ''mindestens'' ein Operand <code>true</code> ist || <syntaxhighlight lang="java" inline>boolean machePause = hungrig || durstig;</syntaxhighlight>
|-
|| ^ || Xor <code>true</code> wenn genau ein Operand <code>true</code> ist || <syntaxhighlight lang="java" inline>boolean zustandPhilosoph = denkt ^ ist;</syntaxhighlight>
|-
|}

== Operatoren zur Manipulation von Bits ==
{| class="wikitable center" style="text-align:left"
! Operator
! Beschreibung
! Kurzbeispiel
|-
| style="width: 5%" | ~
| style="width:50%" | (unäre) invertiert alle Bits seines Operanden || <syntaxhighlight lang="java" inline>0b10111011 = ~0b01000100</syntaxhighlight>
|-
|| & || bitweises "und", wenn beide Operanden 1 sind, wird ebenfalls eine 1 produziert, ansonsten eine 0 || <syntaxhighlight lang="java" inline>0b10111011 = 0b10111111 & 0b11111011</syntaxhighlight>
|-
|| <nowiki>|</nowiki> || bitweises "oder", produziert eine 1, sobald einer seiner Operanden eine 1 ist || <syntaxhighlight lang="java" inline>0b10111011 = 0b10001000 | 0b00111011</syntaxhighlight>
|-
|| ^ || bitweises "exklusives oder", wenn beide Operanden den gleichen Wert haben, wird eine 0 produziert, ansonsten eine 1 || <syntaxhighlight lang="java" inline>0b10111011 = 0b10001100 ^ 0b00110111</syntaxhighlight>
|-
|}

{| class="wikitable center" style="text-align:left"
! Operator
! Beschreibung
! Kurzbeispiel
|-
| style="width: 5%" | >>
| style="width:50%" | Arithmetischer Rechtsshift: Rechtsverschiebung, alle Bits des Operanden werden um eine Stelle nach rechts verschoben, stand ganz links eine 1 wird mit einer 1 aufgefüllt, bei 0 wird mit 0 aufgefüllt || <syntaxhighlight lang="java" inline>0b11101110 = 0b10111011 >> 2</syntaxhighlight>
|-
|| >>> || Logischer Rechtsshift: Rechtsverschiebung mit Auffüllung von Nullen || <syntaxhighlight lang="java" inline>0b00101110 = 0b01011101 >>> 1</syntaxhighlight>
|-
|| << || Linksverschiebung, entspricht bei positiven ganzen Zahlen einer Multiplikation mit 2, sofern keine "1" rausgeschoben wird. || <syntaxhighlight lang="java" inline>0b10111010 = 0b01011101 << 1</syntaxhighlight>
|-
|}

== Zuweisungsoperatoren ==
Zu vielen Operatoren aus den vorstehenden Tabellen gehört eine Schreibweise, mit der gleichzeitig zugewiesen werden kann. Damit spart man sich oft etwas Schreibarbeit. Also, statt etwa <syntaxhighlight lang="java" inline>x = x * 7;</syntaxhighlight> zu schreiben kann man etwas verkürzt schreiben: <syntaxhighlight lang="java" inline>x = 7;</syntaxhighlight>.

{| class="wikitable center" style="text-align:left"
! Operator
! Beschreibung
! Kurzbeispiel
|-
| style="width: 5%" | =
| style="width:50%" | einfache Zuweisung || <syntaxhighlight lang="java" inline>int var = 7;</syntaxhighlight>
|-
|| += || Addiert einen Wert zu der angegebenen Variablen ||<syntaxhighlight lang="java" inline>plusZwei += 2;</syntaxhighlight>
|-
|| -= || Subtrahiert einen Wert von der angegebenen Variablen ||<syntaxhighlight lang="java" inline>minusZwei -= 2;</syntaxhighlight>
|-
|| /= || Dividiert die Variable durch den angegebenen Wert und weist ihn zu ||<syntaxhighlight lang="java" inline>viertel /= 4;</syntaxhighlight>
|-
|| = || Multipliziert die Variable mit dem angegebenen Wert und weist ihn zu ||<syntaxhighlight lang="java" inline>vierfach = 4;</syntaxhighlight>
|-
||%= || Ermittelt den Modulo einer Variablen und weist ihn der Variablen zu ||<syntaxhighlight lang="java" inline>restModulo11 %= 11;</syntaxhighlight>
|-
|| &= || "und"-Zuweisung ||<syntaxhighlight lang="java" inline> maskiert &= bitmaske;</syntaxhighlight>
|-
|| <nowiki>|</nowiki>= || "oder"-Zuweisung ||
|-
|| ^= || "exklusives oder"-Zuweisung ||
|-
|| ^= || bitweise "exklusive oder"-Zuweisung ||
|-
|| >>= || Rechtsverschiebungzuweisung ||
|-
|| >>>= || Rechtsverschiebungzuweisung mit Auffüllung von Nullen ||
|-
|| <<= || Linksverschiebungzuweisung || <syntaxhighlight lang="java" inline>achtfach <<= 3;</syntaxhighlight>
|}

== Bedingungsoperator ==
Den einzigen ternären Operator <code>?:</code> stellen wir im [[Java_Standard:_Kontrollstrukturen#Bedingungsoperator | Kapitel Kontrollstrukturen]] vor.

== Konkatenation ==
Zwei <code>String</code>s lassen sich mit "+" aneinanderschreiben, so wie Sie es schon aus früheren <syntaxhighlight lang="java" inline>System.out.println("Hallo" + " Welt" + "!");</syntaxhighlight>-Beispielen kennen.

== Rangfolge von Operatoren ==
Die Rangfolge der Operatoren (engl. "''operator precedence''" oder auch "''precedence rules''") bestimmt in der Regel<ref>siehe nächsten Abschnitt [[Java_Standard:_Operatoren#Fallen|Fallen]]</ref>, in welcher Reihenfolge sie ausgewertet werden. Es geht darum, Klammern zu sparen. Weiß man, dass <code>&&</code> einen höheren Rang als <code>||</code> hat, dann wird der Ausdruck <code>(A && B) || C</code> zu <code>A && B || C</code>. Selbstverständlich ''darf'' man trotzdem Klammern setzen.

Ganz allgemein gilt, dass Ausdrücke von links nach rechts ausgewertet werden. Das gilt nicht für Zuweisungsoperatoren.

In der folgenden Tabelle<ref>Zum Teil entnommen von https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html</ref> werden die Operatoren und ihre Ränge aufgeführt. Je weiter oben ein Operator in der Tabelle auftaucht, desto eher wird er ausgewertet. Operatoren mit dem gleichen Rang (in der gleichen Zeile) werden von links nach rechts ausgewertet.

{| class="wikitable center" style="text-align:left"
! Rangfolge
! Typ
! Operatoren
|-
| style="width: 5%" | 1
| style="width:50%" | Postfix-Operatoren, Postinkrement, Postdekrement || <code>x++</code>, <code>x--</code>
|-
|| 2 || Einstellige (unäre) Operatoren, Vorzeichen || <code>++x</code>, <code>--x</code>, <code>+x</code>, <code>-x</code>, <code>~b</code>, <code>!b</code>
|-
|| 3 || Multiplikation, Teilerrest || <code>ab</code>, <code>a/b</code>, <code>a % b</code>
|-
|| 4 || Addition, Subtraktion || <code>a + b</code>, <code>a - b</code>
|-
|| 5 || Bitverschiebung || <code>d << k</code>, <code>d >> k</code>, <code>d >>> k</code>
|-
|| 6 || Vergleiche || <code>a < b</code>, <code>a > b</code>, <code>a <= b</code>, <code>a >= b</code>, <code>s instanceof S</code>
|-
|| 7 || Gleich, Ungleich || <code>a == b</code>, <code>a != b</code>
|-
|| 8 || UND (Bits) || <code>b & c</code>
|-
|| 9 || Exor (Bits) || <code>b ^ c</code>
|-
|| 10 || ODER (Bits) || <code>b <nowiki>|</nowiki> c</code>
|-
|| 11 || Logisch UND || <code>B && C</code>
|-
|| 12 || Logisch ODER || <code>B <nowiki>||</nowiki> C</code>
|-
|| 13 || Bedingungsoperator || <code>a ? b : c</code>
|-
|| 14 || Zuweisungen || <code>a = b</code>, <code>a += 3</code>, <code>a -= 3</code>, <code>a *= 3</code>, <code>a /= 3</code>, <code>a %= 3</code>, <code>b &= c</code>, <code>b ^= c</code>, <code>b <nowiki>|</nowiki>= c</code>, <code>d <<=k</code>, <code>d >>= k</code>, <code>d >>>= k</code>
|}

<references/>

== Fallen ==
Es gibt zum Glück wenig Fallstricke im Gebrauch von Operatoren. Postfix-Operatoren werden immer zuerst nach dem ''aktuellen'' Wert, den sie haben ausgewertet, erst dann erfolgt die Operation darauf.

Nicht in allen Fällen kann man sich bei Beachtung der Rangfolge Klammern sparen. Versuchen Sie doch einmal, den Ausdruck <syntaxhighlight lang="java" inline>int x = ++y++;</syntaxhighlight> auszuwerten (wobei <code>y</code> vorher deklariert wurde). Trotz der klaren Vorrangregeln lässt sich dieser Ausdruck nicht kompilieren. Gut für alle, die einen solchen Quelltext lesen müssen...

Für weitere schwer zu durchschauende Fallen siehe auch [[Strukturierte_Programmierung#Komplexe_Ausdrücke|Strukturierte Programmierung / Komplexe Ausdrücke]].

== Rechengenauigkeit ==
Beim Rechnen mit zwei Datentypen unterschiedlicher Genauigkeit (z.B. <code>int</code> und <code>long</code>) muss beachtet werden, dass als Ergebnis der "genaue" Datentyp berechnet wird.
long = int + long;
Wird nur ein "ungenauerer" Wert benötigt, so muss das dem Compiler mitgeteilt werden (<code>''cast''</code>).
int = (int) (int + long);
Die Genauigkeit ist hier durch den Zahl gegeben. Ein Datentyp '''int''' kann eine 32-Bit-Ganzzahl darstellen, während der Typ '''long''' 64-Bit-Ganzzahlen aufnehmen kann (= 8 Byte). Deshalb "passt" ein int-Wert problemlos in einen long-Wert. Umgekehrt kann es da schon passieren, dass der long-Wert größer als der größtmögliche int-Wert ausfällt!

<noinclude>{{Navigation_zurückhochvor_buch|
zurücktext=Variablen und Bezeichner|
zurücklink=Java Standard: Variablen und Bezeichner|
hochtext=Java Inhaltsverzeichnis|
hochlink=Java Standard|
vortext=Kontrollstrukturen|
vorlink=Java Standard: Kontrollstrukturen}}
</noinclude>