Jetzt anmelden...

Name
Passwort
Registrieren

Java Tutorial #4

Java Operatoren einsetzen

Java basiert wie die meisten Programmiersprachen in erster Linie auf einem logischen Zusammenspiel von Variablen, Anweisungen und Operatoren. Um letzteres geht es in diesem Tutorial.

Kommentare [0]

Stefan 10.04.2018

Infos zum Artikel

Kategorie Java
Autor Stefan
Datum 10.04.2018

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.

Arithmetische Operatoren

Zu den am häufigsten vorkommenden 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 = 1

a % 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 multipliziertb c = a * b;
% Modulo Liefert den Rest-Wert einer Division c = a % b;

Zuweisungsoperatoren

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 Variable vom Datentyp Integer um, sagen wir... 5 erhöhen. Wir können dann standardmäßig so vorgehen:

int zahl = 3;
zahl = zahl + 5; // 8

Kann man so machen. Es geht aber auch eleganter und kürzer, nämlich so:

zahl = 3;
zahl += 5; // 8

Wir 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; // 3

Inkrement und Dekrement

Da 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--

Unterschied Post-Increment vs. Pre-Increment

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 Variable stehen.

Der funktionale Unterschied besteht im Folgenden:

  • Bei Post-Increment bzw. Post-Decrement (a++ / a--) wird der Wert von a zuerst benutzt und danach! um 1 erhöht/ verringert.
  • Bei Pre-Decrement bzw. Pre-Decrement (++a/ --a) dagegen wird der Wert von a zuerst erhöht und dann erst verwendet.

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

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); // true

In 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); // true

Der 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 Ungleichheitheit zweier Operanden fragt, und nur dann true liefert, wenn diese nicht gleich sind, wird folgerichtig true auf der Konsole geprinted.

Logische Operatoren

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 Operatoren &, | und ^

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); // false

Wie 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.

Die Abkürzungsoperatoren && und ||

Diese beiden Operatoren verhalten sich sehr ähnlich zu den "normalen" UND- bzw. ODER-Operatoren. Der feine Unterschied liegt in einem entscheidenden Detail:

  • Bei && und || wird der rechte Operand im Gegensatz zu & und | nicht überprüft, wenn das Ergebnis bereits nach der Prüfung des ersten zweifelsfrei feststeht.

Nehmen wir z.B. folgenden Fall an:

boolean b1 = true, b2 = false;

boolean c = b2 && b1; // false
boolean d = b1 || b2; // true
JAVA

b2 && 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 zustzäliche Ü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); // 0

Wir 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); // 1

Jetzt werden beide Operanden geprüft - und damit wird die Variable x um +1 erhöht.

Wir 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.

logisches Nicht !

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); //false

Übungen

einfach

Welchen Wert hat die Variable training am Ende des Codes?

int training;
training = (8+9) % 2;
Lösung ein-/ausblenden

mittel

Welchen Wert haben die folgenden Variablen?

boolean b1 = ! false;
boolean b2 = (3>3) || ((2 == 2) && (1 < 0));
boolean b3 = (35 != 10) & !false;
Lösung ein-/ausblenden

schwer

Was wird am Ende des folgenden Codes auf der Konsole geprinted?
Info: Für diese Aufgabe müssen Sie etwas über Schleifen wissen.

boolean b = false;
boolean b2 = false;

for(int x = 0; x < 10; x++){
    if(x % 2 == 3){
        b = true;
    }
    else {
        b = false;
        b2 = true;
    }
}

boolean b3 = true;
b = (b & b2) || (b == true) ^ (-234 > 234 && b3);

System.out.println(b);
System.out.println(b2);
System.out.println(b3);
Lösung ein-/ausblenden

Kommentar schreiben

Nur angemeldete Benutzer können kommentieren.

Alle Kommentare

Es gibt bislang noch keine Kommentare zu diesem Thema.

Objekte vergleichen

Was ist der Unterschied zwischen == und equals()?

Objekte löschen

Wir wissen, wie wir Objekte erstellen können. Aber wie werden wir sie wieder los?

toString() Methode

Lernen Sie hier, wie Sie die toString() Methode korrekt einsetzen

FALCONBYTE.NET

Handmade with 🖤️

© 2018, 2019 Stefan E. Heller

Impressum | Datenschutz

facebook programmieren lernen twitter programmieren lernen youtube programmieren lernen