Wenn man den Wert einer Variablen um 1 erhöhen oder verringern möchte, dann gibt es verschiedene Möglichkeiten:

int zahl = 1;
zahl = zahl + 1; zahl = zahl - 1;
zahl += 1; zahl -= 1;
zahl++; zahl--;

Uns interessiert die letzte Version – der Increment- und Decrement-Operator.

Diese kann in zwei Versionen anwenden:

zahl++; zahl--;
++zahl; --zahl;

Ich kann ihn vor oder hinter der Variablen platzieren. Doch wo ist da der Unterschied?

Nun, wenn es sich um eine alleinstehende Anweisung – wie in obigem Fall – handelt, dann ist es egal. Interessant wird es, wenn dieser Operator Bestandteil einer zusammengesetzten Anweisung ist.

Increment und Decrement als Bestandteil von Berechnungen

Diese beiden Operatoren dienen nun, wie gesehen dazu, den Wert einer Variablen um eins zu erhöhen oder auch zu reduzieren. Nun können wir auch mehrere Rechenoperationen nacheinander ausführen.

int ergebnis,zahl = 13;
zahl++;
ergebnis = zahl * 3;

Das ist doch viel zu viel Schreibarbeit. Fassen wie die beiden letzten Anweisungen doch zusammen.

ergebnis = zahl++ * 3;

Doch halt: Damit würden wir nicht am Ende für das Ergebnis den Wert 42 speichern, sondern 39 . Wie das?

Hier steht der Increment-Operator nicht alleine in einer Anweisung. Daher ist entscheidend, ob sich dieser vor oder hinter der Variablen befindet. In diesem Fall steht der dahinter. Daher wird die Inkrementierung der Variablen zahl NACH der Mulitplikation vorgenommen.

Um wie im ursprünglichen Fall die beiden Anweisungen (erst Inkrementierung, dann Multiplikation) zusammenzufassen, müssen wir den Operator vor die Variable schreiben:

ergebnis = ++zahl * 3;

Ein weiteres interessantes Detail tritt auf, wenn Increment und Decrement Bestandteil von Methodenaufrufen sind.

Increment  und Decrement bei Methodenaufrufen

Hier soll nun die Änderung des Variablenwertes als Bestandteil des Übergabeparameters angegeben werden.

int main(){
int zahl = 10;
ausgeben(zahl-1);}
void ausgeben(int zahl){
System.out.println("" + zahl);}

Die Methode ausgeben verlangt eine int-Zahl und gibt deren Wert in der Standausgabe aus.

Diese Methode rufen wir in der main() auf. Hier wird zunächst temporär von der Variablen zahl der Wert 1 subtrahiert. (Temporär, weil der Ergebnis dieser Rechnung nicht in einer Variablen der main() gespeichert wird).

Ausgegeben wird hier eine 9. Die Variable zahl hat in der main() aber immer noch den Wert 10 gespeichert.

Wollen wir eine dauerhafte Wertänderung, so können wir auch folgende Anweisung für den Aufruf der Methode ausgeben() schreiben:

ausgeben(zahl = zahl - 1);

Hier wird zunächst die Wertzuweisung ausgeführt, also die Zahl um 1 reduziert und das Ergebnis wiederum in der Variablen zahl gespeichert. Anschließend wird die Methode ausgeben() mit dem Wert von Zahl aufgerufen.

Nun können wir hier für die Reduzierung der Variablen um 1 den Decrement-Operator verwenden.

ausgeben(zahl--);

Doch Obacht, nun wird nicht 9 ausgegeben, sondern 10. Die Variable zahl hat anschließend in der main() den Wert 9, aber an die Methode ausgeben() wird eine 10 übergeben.

Auch hier gilt: der Decrement-Operator wird als Bestandteil einer Anweisung nachrangig ausgeführt, wenn er hinter der Variablenbezeichnung steht.

Möchten wir also, dass auch hier der Wert von 9 ausgeben wird, müssen wir sicherstellen, dass erst die Zahl um 1 reduziert wird, bevor die Methode aufgerufen wird. Dazu schreiben wir den Decrement-Operator vor die Variablenbezeichnung.

ausgeben(--zahl);