Operatoren sind Symbole, die ein oder zwei Operanden verbinden. Hier ist eine Übersicht über die grundlegenden arithmetischen Operatoren in den Programmierung:

result = 5 + 3; // 8

result = 13 - 8; // 5

result = 3 * 9; // 27

result = 8 / 4; // 2

result = 5 % 2; // 1

Division

Du kennst das Symbol / als Operator für die "geteilt durch" Operation. Was du noch nicht weist, ist, dass es zwei unterschiedliche Divisionen gibt: die ganzzahlige Division und die Gleitkommazahlen-Division. Beide verwenden das gleiche Symbol /. Bei der ganzzahligen Division haben wir zwei Resultate:

• das Ergebnis der Division
• den Rest (Modulo).

Ganzzahlige Division & Gleikommazahlen-Division

Sehen wir uns das im Beispiel an. Hier haben wir eine ganzzahlige Division:

println(5 / 2); // Ausgabe: 2 

Wie entscheidet Processing, ob eine ganzzahlige Division verwendet wird, oder die Gleitkomma-Division? Die Regel lautet: Wenn beide Operanden (5 und 2) vom Typ int sind, dann verwende die ganzzahlige Division. Das Ergebnis wird in diesem Fall als Ganzzahl ausgegeben.

Hier haben wir ein Beispiel für eine Gleitkomma-Division:

println(5.0 / 2); // Ausgabe: 2.5 

Nun haben wir eine Gleitkommazahl als Ergebnis. Achte darauf, dass bei komplexeren Rechnungen nicht immer offensichtlich ist, von welchem Typ die jeweiligen Operanden sind. Du musst dir genau überlegen, in welcher Reihenfolge gerechnet wird und welchen Typ die Operanden zu dem Zeitpunkt haben, wo der Divisions-Operator an der Reihe ist:

println(2.5 + 5 / 2 + 5.0); 

Bekommst du hier eine 10.0 oder eine 9.5? Versuche dir zuerst klarzumachen, was herauskommt. Probier es dann in Processing aus.

Modulo-Operator

Wir haben gelernt, dass Processing eine ganzzahlige Division durchführt, wenn zwei Integer-Werte die Operanden sind. Das Resultat einer ganzzahligen Division hat zwei Bestandteile: den Ganzzahlquotient und den Rest.

5 / 2 ergibt 2 (Quotient) mit Rest 1
7 / 5 ergibt 1 (Quotient) mit Rest 2

Mathematisch ist das wie folgt definiert:

x / y ergibt Quotient q mit Rest 
x = q * y + r

Der Modulo-Operator % gibt dir für eine ganzzahlige Division den Rest zurück:

println(5 % 2); // Ausgabe: 1
println(7 % 5); // Ausgabe: 2

Der Modulo-Operator erlaubt es dir zu testen, ob eine Zahl gerade oder ungerade ist, denn wenn man eine gerade Zahl durch 2 teilt, ist der Rest gleich Null:

int zahl = 7;

if (zahl % 2 == 0) {
   println("gerade");
} else {
   println("ungerade");
}

Ein Grund, warum der Modulo-Operator in der Informatik und insbesondere im Bereich Animation so interessant ist, ist seine Ring-Eigenschaft. Dazu sehen wir uns an, was passiert, wenn man sich den Rest von einer Zahlenreihe (0, 1, 2, 3, ...) mit einer festen Zahl (z.B. 3) ansieht:

0 % 3 = 0
1 % 3 = 1
2 % 3 = 2
3 % 3 = 0
4 % 3 = 1
5 % 3 = 2
6 % 3 = 0
7 % 3 = 1
8 % 3 = 2
...

Fällt dir etwas auf? Richtig. Obwohl der erste Operand immer größer wird, bewegt sich das Ergebnis der Modulo-Operation immer im Bereich 0 bis 2.

Allgemein bewegt sich bei einer Restoperation mit der Zahl N das Resultat immer im Bereich von 0 bis N-1.

Das ist sehr nützlich bei Animationen:

int x = 0;

void draw() {
   background(255);
   int y = x % 100;
   ellipse(y, 50, 20, 20);
   x = x +1;
}

Obwohl x immer größer wird, bleibt y im Bereich 0 bis 99, so dass der Ball immer von links nach rechts im sichtbaren Bereich fliegt.

Additions-Zuweisung

Was machst du, wenn du so eine Erhöhung hast?

x = x + 2;

Ganz einfach: Du nutzt die Additions-Zuweisung:

x += 2;

Du denkst vielleicht: Naja, soviel Schreibarbeit hab ich hier nicht gespart! Schau mal:

ziemlichLangerVariablennameMitExtras += 2;

Schon praktisch. Diese Art der Zuweisung gibt's auch in anderen Geschmacksrichtungen:

x -= 3; // x = x - 3
x *= 5; // x = x * 5
x /= 2; // x = x / 2

Tipp: Wie merkst du dir , ob es jetzt "+=" oder "=+" heißt? Überleg dir, dass "x =+ 2" von Processing gelesen würde wie "x = +2", d.h. das Plus-Zeichen wird der Zahl zugeordnet und x daher nicht um 2 erhöht, sondern auf 2 gesetzt.

Increment und Decrement

Inkrement-Operator

Eine nützliche Kurzform für folgende Operation (x sei eine int-Variable)

x = x + 1;

ist die folgende Zeile

x++;

Das bedeutet, dass der Inhalt der Variable x um 1 erhöht wird. Das "++" nennt man einen Operator, und zwar den Inkrement-Operator.

Dekrement-Operator

Passend dazu gibt es einen Operator zum Runterzählen:

x--;

Dieser sog. Dekrement-Operator reduziert den Wert von x um 1.

Ausführungsreihenfolge

Du kannst den Inkrement-Operator nicht nur allein auf einer Zeile ausführen, sondern auch in Befehle oder Rechnungen einbetten.

Beispiel 1:

int foo = 5;
println(foo++);

Beispiel 2:

int boo = 10;
int goo = 100 + boo++;

Was passiert hier? Wir haben hier zwei Vorgänge, die wir unterscheiden müssen:

1. Verwendung/Substitution der Variable, d.h. die Variable wird durch ihren aktuellen Wert ersetzt
2. Inkrementierung, d.h. der Wert der Variable wird um eins erhöht.

Jetzt wird offenbar, dass es eine große Rolle spielt, ob erst (1.) oder (2.) durchgeführt wird! Wenn du Beispiel 1 ausführst, siehst du:

5

Der Wert der Variable foo ist aber 6. Das liegt daran, dass beim Einsetzen (1.) der alte Wert 5 verwendet wurde. Im Anschluss wurde dann die Variable foo erst um eins auf 6 erhöht (2.).

Verstehst du dann auch Beispiel 2? Probiere es aus und überlege, warum das Ergebnis so ist, wie es ist. Insbesondere verstehst du jetzt auch, warum der folgende Anfängerfehler so gravierend ist:

int x = 0;
x = x++; 

Hier passiert folgendes:

1. x wird eingesetzt, d.h. dort steht x = 0, aber dies wird noch nicht umgesetzt
2. x wird um eins erhöht, d.h. x hat jetzt den Wert eins
3. die gesamte Zeile, also x = 0, wird jetzt erst ausgeführt, d.h. x wird auf 0 gesetzt

Im Endeffekt bleibt x also immer Null.

Unterschied ++i und i++: Prefix und Postfix

Jetzt kann man sich vorstellen, dass man diese Reihenfolge umkehren möchte:

• (b) Inkrementierung, d.h. der Wert der Variable wird um eins erhöht.
• (a) Verwendung/Substitution der Variable, d.h. die Variable wird durch ihren aktuellen Wert ersetzt

Das heißt, du möchtest erst die Variable erhöhen (b) und dann den neuen Wert einsetzen (a). Dies erreichst mit der Formulierung

++i

Sehen wir uns die Beispiele an, um uns davon zu überzeugen, dass das funktioniert:

Beispiel 1:

int foo = 5;
println(++foo);

6

Beispiel 2:

int boo = 10;
int goo = 100 + ++boo;

111

Diese Unterscheidung wird auch jeweils als Prefix bzw. Profix bezeichnet. "fix" steht in diesem Fall dafür, dass der Variablenwert verändert, also "gefixed" wird.

• Prefix bedeutet somit, dass der Variablenwert geändert wird, bevor die Variable verwendet wird. Beispiel: ++foo.
• Postfix bedeutet somit, dass der Variablenwert geändert wird, nachdem die Variable verwendet wurde. Beispiel: foo++.

Rangfolge und Klammern

Auch in der Programmierung haben Operatoren eine gewisse Rangfolge, die festlegt, in welcher Reihenfolge sie verwendet werden. Aus dem Mathematik-Unterricht kennst du bestimmt die Regel "Punkt vor Strich", die besagt, dass Multiplikation/Division vor Addition/Subtraktion kommt. Solche bzw. dieselben und noch ein paar weitere Regeln gelten in der Programmierung auch. Die musst du (noch) nicht alle kennen. Für den Moment reicht es, dass du weißt, dass z.B. "Punkt vor Strich" auch in der Programmierung gilt.

Außerdem kannst du - genau wie in der Mathematik - die Reihenfolge durch das setzen von Klammern beeinflussen. So ergeben z.B. folgdende Operationen unterschiedliche Ergebnisse:

int erg1 = 2 + 3 * 2; // ergibt 8
int erg2 = (2 + 3) * 2; // ergibt 10

Hier siehst du die Rangfolge der Operatoren aus diesem Abschnitt:

String-Konketation

Den Operator für die String-Verkettung (auch String-Verkettung) hast du bereits im Abschnitt Datentypen kennengelernt: Das Plus-Zeichen. Wenn du zwei Strings kombinieren möchtest, kannst du das mit diesem Operator tun. Dabei wird der zweite Operand hinten an den ersten Operan hinzugefügt.

String vorname = "Max";
String nachname = "Mustermann";
println(vorname + nachname); // ergibt "MaxMustermann"

Wichtig: Wenn du zwei Strings mithilfe des Plus-Zeichens kombinierst, dann verwendest du den String-Verkettungs-Operator, nicht den Additions-Operator.
Das kann ganz schön verwirrend sein, da beide ja dasselbe Zeichen verwenden. Aber wie entscheidet denn das Programm, welchen Operator es verwendet? Hier gibt es 2 Regeln:

1. Sobald einer der Operanden ein String oder char ist, verwendet das Programm den String-Verkettungs-Operator
2. Bei mehreren unterschiedlichen Operanden muss hierbei auf die Rangfolge der Operatoren geachtet werden.

Schauen wir uns einmal folgendes Beispiel an, welches einen häufigen Anfängerfehler zeigt:

int a = 2;
int b = 3;
String ergebnis = "Die Summe ist " + a + b;

Du wirst erstaunt sein, aber wemm du ergebnis in der Konsole ausgibst, wirst du lesen "Die Summe ist 23". Gehen wir es mal Schritt für Schritt durch - was passiert hier?

1. Substitution: die Variablen werden durch die Werte 2 und 3 ersetzt
2. Verarbeitung/Auswertung: Die Verarbeitung geschieht von links nach rechts. Beim ersten Plus stellt das Programm fest, dass der erste Operand ein String ist, also handelt es sich bei dem Plus um den Operator für die String-Verkettung und er fügt dem ersten String die Zahl 2 hinzu, als wäre sie ein String (obwohl sie eigentlich ein int ist). Beim zweiten Plus liegt derselbe Fall vor: Der erste Operand ist wieder ein String, also String-Verkettung ...
3. Zuweisung: Der String "Die Summe ist 23" wird ergebnis zugewiesen.

Vermeiden können wir das, indem wir Klammern setzen und so die Reihenfolge manipulieren:

int a = 2;
int b = 3;
String ergebnis = "Die Summe ist " + (a + b); // ergibt "Die Summe ist 5"

Durch das Setzen der Klammern wird (a + b) zuerst ausgewertet. Da es sich in beiden Fällen um eine Zahl handelt, wird nun die Addition angewandt. Danach erst wird das Ergebnis von a + b zum String hinzugefügt.

Zusammenfassung

• Operatoren sind Symbole, die ein oder zwei Operanden verbinden
• Die grundlegenden arithmetischen Operatoren sind +, -, *, /, %
• Modulo: Der Operator Modulo (%) liefert bei der Division zweier Zahlen den Rest, z.B. 5 % 2 ergibt 1.
• Additions-Zuweisung: Wird ein Wert mit sich selber und einem weiteren Wert addiert, kann die Schreibweise mithilfe der Additionszuweisung verkürzt werden.
  • Beispiel: x = x + 2 kann auf x += 2 verkürzt werden.
  • Das selbe gilt auch für Subtraktion, Multiplikation und Division.
• Increment & Decrement: Soll ein Wert um 1 erhöht oder verringert werden, kann dies durch die Schreibweise x++ oder x--  bzw. ++x oder --x erfolgen.
• Prefix & Postfix: Bezeichnet zwei unterschiedliche Ausführungsreihenfolgen
  • Prefix: Die Variable wird zuerst geändert, dann verwendet ( z.B. ++x). Der Operator kommt vor dem Operanden.
  • Postfix: Die Variable wird geändert, nachdem sie verwendet wurde (z.B. x++). Der Operator kommt nach dem Operanden.