Thema in Kurzform
Operatoren werden in der Programmierung genutzt, um einzelne Werte miteinander zu verrechnen oder zu vergleichen. Außerdem gibt es logische Operatoren, die auf kombinierte boolesche Ausdrücke angewandt werden und prüfen, ob der Gesamtausdruck true oder false ist.
Zu den mathematischen Operatoren gibt es nicht viel zu sagen. Wir alle kennen sie und haben sie schon bei unseren ersten Programmierschritten in Java ganz intuitiv und selbstverständlich gebraucht. Es sind die vier Grundrechenarten: Addition, Subtraktion, Division, Multiplikation.
Hinzu kommt jetzt noch der Modulo-Operator. Dieser gibt ganz einfach den Rest einer Division zurück:
int a = 5;
int b = 2;
int c = a % b; // c = 1a % b = 1. Das liest man dann so: "5 Modulo 2 ist 1". Denn bei der Division 5 / 2 bleibt der Rest von 1 und eben das ist der Modulo-Wert.
Es gilt beim Einsatz aller Operatoren prinzipiell: Zwischen zwei Operanden a und b steht der Operator (+, -, /, *, %). Das Ergebnis der Operation ist der Wert c.
| Arithmetische Operatoren | |||
|---|---|---|---|
| + | Addition | Zählt die Werte zweier Operanden zusammen | c = a + b; |
| - | Subtraktion | Zieht den Wert des zweiten Operanden vom ersten ab | c = a - b; |
| / | Division | Dividiert Operand a durch Operand b | c = a / b; |
| * | Multiplikation | Zwei Operanden werden miteinander multipliziert | c = a * b; |
| % | Modulo | Liefert den Rest-Wert einer Division | c = a % b; |
Der Zuweisungsoperator = weist Variablen einen Wert zu. Das heißt: Was auf der rechten Seite vom Zuweisungsoperator steht, wird als Wert der Variablen auf der linken Seite zugewiesen. Damit unterscheidet sich dieser Operator grundlegend vom mathematischen = Zeichen für Gleichungen.
Hier ein Beispiel:
int klaro = -100;Die Variable klaro links erhält den Wert von -100, der rechts steht, zugewiesen.
Ok? Gut. Wir gehen weiter und denken uns folgende Situation: Wir möchten den Wert einer Variablen vom Datentyp Integer um, sagen wir... 5 erhöhen. Wir können dann standardmäßig so vorgehen:
int zahl = 3;
zahl = zahl + 5; // 8Kann man so machen. Es geht aber auch eleganter und kürzer, nämlich so:
zahl = 3;
zahl += 5; // 8Wir erledigen exakt dasselbe wie mit zahl = zahl + 5, nur dass wir uns Schreibarbeit sparen (und das sollten wir beim Programmieren immer anstreben). Wir lassen die zu verändernde Variable auf der rechten Seite einfach weg und schreiben stattdessen den gewünschten Operator (in diesem Fall +) vor den Zuweisungsoperator =.
Auch die übrigen arithmetischen Operatoren lassen sich mit dem Zuweisungsoperator = kombinieren. Deshalb heißen sie kombinierte Zuweisungsoperatoren. Es kann alles so einfach sein :-)
Hier die Übersicht der kombinierten Zuweisungsoperatoren:
| Kombinierte Zuweisungsoperatoren | |||
|---|---|---|---|
| += | Additions-Zuweisung | Zählt dem linken Wert den rechten hinzu | a += b; |
| -= | Subtraktions-Zuweisung | Zieht vom linken Wert den Wert des rechten ab | a -= b; |
| /= | Divisions-Zuweisung | Dividiert a durch b und weist das Ergebnis als neuen Wert a zu | a /= b; |
| *= | Multiplikations-Zuweisung | Multipliziert a mit b und weist das Ergebnis als neuen Wert a zu. | a *= b; |
| %= | Modulo-Zuweisung | Macht eine Modulo-Rechnung a % b. Das Ergebnis ist der neue Wert von a | a %= b; |
Praktisch sieht das so aus:
int addition = 5;
int subtraktion = 10;
int multiplikation = 2;
int division = 21;
int modulo = 13;
//kombinierte Zuweisungsoperatoren
addition += 5; // 10
subtraktion -= 8; // 2
multiplikation *= 6; // 12
division /= 7; // 3
modulo %= 10; // 3Da das Hoch- bzw. Runterzählen um jeweils den Wert von 1 in der Programmierung so häufig vorkommt, wurden die beiden Operatoren ++(Inkrement) bzw. -- (Dekrement) geschaffen. Sie werden uns in vielen Programmierprojekten äußerst hilfreich sein und die Arbeit erleichtern. Sie sollten sich die beiden merken!
| Inkrement- und Dekrement-Operatoren | |||
|---|---|---|---|
| ++ | Inkrementieren | Erhöht den Wert einer numerischen Variable um +1 | a++ |
| -- | Dekrementieren | Verringert den Wert einer numerischen Variable um -1 | a-- |
In den Code-Beispielen haben wir das Post-Increment (a++) bzw. Post-Decrement (a--) angewandt.
Im Unterschied dazu gibt es noch die Varianten Pre-Increment (++a) bzw. Pre-Decrement (--a).
Formal unterscheiden sich die Varianten danach, ob die mathematischen Zeichen ++/ -- nach oder vor der Variablen stehen.
Der funktionale Unterschied besteht im Folgenden:
In Aktion sieht das dann so aus:
int zahl = 0;
System.out.println(zahl); // 0
System.out.println(zahl++); // 0 - erst printen, danach erhöhen
System.out.println(zahl); // 1
System.out.println(++zahl); // 2 - erst erhöhen, dann printen| Vergleichsoperatoren | |||
|---|---|---|---|
| > | größer | Liefert true, wenn a größer ist als b | a > b |
| < | kleiner | Liefert true, wenn a kleiner ist als b | a < b |
| >= | größer/gleich | Liefert true, wenn a größer oder gleich groß ist wie b | a >= b |
| <= | kleiner/gleich | Liefert true, wenn a kleiner oder gleich groß ist wie b | a <= b |
| == | gleich zu | Liefert true, wenn a den gleichen Wert hat wie b | a == b |
| != | nicht gleich zu | Liefert true, wenn a nicht den gleichen Wert hat wie b | a != b |
Die Vergleichsoperatoren vergleichen zwei Operanden miteinander und liefern als Ergebnis einen booleschen Wert (true oder false) zurück. Diese Operatoren werden sehr häufig in if-else-Kontrollstrukturen und Schleifen eingesetzt.
Die Operatoren in ein paar Beispielen:
int x = 5, y = 10, z = 5;
System.out.println(x > z); // false
System.out.println(x < y); // true
System.out.println(x >= z); // true
System.out.println(x <= y); // true
System.out.println(x == y); // false
System.out.println(x != y); // trueIn diesen Beispielen haben wir arithmetische Werte miteinander vergleichen. Häufig werden aber auch booleschen Werte gegenübergestellt. Ein Vergleich zweier Booleans läuft natürlich nur mit den beiden Operatoren == und !=. Ein kleines Beispiel:
boolean x = true, y = false;
System.out.println(x == y); // false
System.out.println(x != y); // trueDer erste Vergleich in Zeile 2 will wissen, ob die beiden Variablen x und y den gleichen Wert haben. Da x den Wert true und y den Wert false speichert, haben sie eben nicht den gleichen Wert und deshalb ist das Ergebnis des Vergleichs false.
Im zweiten Vergleich, der mit != nach der Ungleichheit zweier Operanden fragt, und nur dann true liefert, wenn diese nicht gleich sind, wird folgerichtig true auf der Konsole geprinted.
| Logische Operatoren | |||
|---|---|---|---|
| & | UND | Liefert true, wenn beide Operanden true sind | a & b |
| | | ODER | Liefert true, wenn mindestens einer der Operanden true ist | a | b |
| ^ | EXKLUSIV-ODER | Liefert nur dann true, wenn einer(!) der beiden Operanden true ist | a ^ b |
| && | UND (short-circuit) | Liefert true, wenn beide Operanden true sind | a && b |
| || | ODER (short-circuit) | Liefert true, wenn mindestens einer der Operanden true ist | a || b |
| ! | logisches NICHT | Invertiert den Wahrheitswert eines Operanden | !a |
Die logischen Operatoren, wie wir sie in der Tabelle sehen, werden auf boolesche Ausdrücke angewandt.
Die ersten drei (& | und ^) sind ganz einfach zu verstehen. Schauen wir sie uns mal in Aktion an.
Wir erzeugen hierzu zunächst einige Variablen mit booleschen Werten und benutzen dann nacheinander die Operatoren &, | und ^. Dabei platzieren wir die Operatoren, wie gewohnt, zwischen jeweils zwei Variablen (die Operanden). Das Ergebnis der einzelnen Prüfungen wird mit System.out.println auf der Konsole ausgegeben. Hier der Code:
boolean b1 = true,
b2 = false,
b3 = true,
b4 = false;
// UND-Operator
System.out.println(b1 & b3); // true
System.out.println(b1 & b2); // false
// ODER-Operator
System.out.println(b1 | b2); // true
System.out.println(b2 | b4); // false
// EXKLUSIV-ODER Operator
System.out.println(b1 ^ b2); // true
System.out.println(b1 ^ b3); // falseWie wir bei der Anwendung des UND-Operators & sehen, müssen beide Operanden den booleschen Wert true haben, damit true zurückgeleifert wird. Da dies bei den Variablen b1 und b3 so ist, wird als Ergebnis der Operation b1 & b3 in Zeile 7 true zurückgeliefert. Bei der Operation b1 & b2 dagegen sind nicht beide Operanden true - somit wird false zurückgeliefert.
Die Beispiele zum ODER-Operator | zeigen, dass es genügt, wenn einer der beiden Operanden true ist. Deswegen wird in Zeile 8 true geprinted und in Zeile 9 false.
Der EXKLUSIV-ODER-Operator ^ dagegen liefert nur dann true, wenn einer der beiden Operanden true ist. Das sehen wir schön in den Zeilen 15 und 16.
Diese beiden Operatoren verhalten sich sehr ähnlich zu den "normalen" UND- bzw. ODER-Operatoren. Der feine Unterschied liegt in einem entscheidenden Detail:
Nehmen wir z.B. folgenden Fall an:
boolean b1 = true, b2 = false;
boolean c = b2 && b1; // false
boolean d = b1 || b2; // trueb2 && b1: Da bereits nach der Prüfung des ersten Operanden b2 klar ist, dass das Ergebnis der Operation false ist (da b2 false), ist eine zusätzliche Überprüfung von b1 sinnlos. Die Anweisung endet vorzeitig. Die Variable c erhält den Wert false.
b1 || b2: Bereits nach b1 ist klar, dass die Prüfung true ist (da b1 true). Der zweite Operand muss deshalb garnicht erst geprüft werden. Die Anweisung endet vorzeitig. Die Variable d erhält den Wert true.
Warum sollten wir den Unterschied kennen? Ganz einfach: Auf der einen Seite sparen wir Rechenarbeit, wenn Codeteile ausgelassen werden, die das Ergebnis einer angestellten Prüfung ohnehin nicht mehr verändern. Genau aus diesem Grund werden diese Operatoren auch Abkürzungsoperatoren (short-circuit operators) genannt.
Zweitens können wir uns vor einer NullPointerException schützen. Was das bedeutet, sehen wir in einem anderen Kapitel.
Schließlich kann es für die spezifische Code-Verarbeitung sehr wohl einen Unterschied machen, ob wir nun die einfachen oder doppelten Operatoren anwenden. Sehen Sie sich das an:
int x = 0;
boolean b = (x >= 0) || (++x <= 1);
System.out.println(x); // 0Wir setzen in Zeile 2 den Abkürzungsoperator || ein und das bewirkt, dass der zweite Operand (++x <= 1) nicht! ausgeführt wird. Das Ergebnis (true) steht nämlich bereits nach Prüfung des ersten Operanden sicher fest. Somit wird die Variable x nicht um +1 erhöht, bleibt also beim Wert 0.
Etwas anderes geschieht, wenn wir im gleichen Code statt || den einfachen Operator | verwenden:
int x = 0;
boolean b = (x >= 0) | (++x <= 1);
System.out.println(x); // 1Jetzt werden beide Operanden geprüft - und damit wird die Variable x um +1 erhöht.
Wie wir an diesem kleinen Beispiel also sehen, kann sich ein Programm unterschiedlich verhalten - je nach dem, ob wir den einfachen oder doppelten logischen Operator gebrauchen.
Zu guter Letzt kommen wir noch zum "Negationsoperator". Dieser dreht den Wahrheitswert eines booleschen Werts einfach um. Aus true wird false und umgekehrt.
boolean wahrheit = true;
boolean luegner = !wahrheit;
System.out.println(luegner); //falseJava Basics
[Java einrichten] [Variablen] [Primitive Datentypen] [Operatoren] [if else] [switch-case] [Arrays] [Schleifen]
Objektorientierung
[Einstieg] [Variablen ] [Konstruktor] [Methoden] [Rekursion] [Statische Member] [Initializer] [Pass-by-value] [Objektsammlungen] [Objektinteraktion] [Objekte löschen]
Klassenbibliothek
[Allgemeines] [String ] [Math] [Wrapper] [Scanner] [java.util.Arrays] [Date-Time-API]
Vererbung
[Einstieg Vererbung] [Konstruktoren bei Vererbung ] [Der protected Zugriffsmodifikator] [Abstrakte Klassen und Methoden] [Polymorphie in Java] [Typumwandlung] [Die Klasse Object] [Die toString()-Methode] [Objekte vergleichen] [Was ist ein Interface?]
