So verwendest du Inkrement & Dekrement Operatoren im Java Programm
In diesem Beitrag geht es um Java Operatoren.
Ich möchte dir gern zwei neue Operatoren vorstellen.
Diese nennen sich Inkrement und Dekrement.
Ja was heißt das?
Inkrementieren bedeutet eine schrittweise Erhöhung einer Zahl.
Und dementsprechend bedeutet Dekrementieren: Die schrittweise Verminderung einer Zahl.
Wozu brauchst du das?
Stell dir vor. Du bekommst eine Liste mit Namen oder mit Autos oder etwas Ähnlichen.
Es ist eigentlich egal.
Auf dieser Liste werden sämtliche Namen geführt.
Jetzt möchtest du wissen, wie viele Namen eigentlich auf dieser Liste sind.
Also würdest du ein Java Programm schreiben, welches diese zählt.
Deine Java Anweisungen würden in Etwa so etwas machen:
- Fang ganz oben an. Und merke dir die Zahl eins. Denn hier ist der erste Name der Liste.
- Falls unter dem ersten Namen noch ein zweiter Name auftaucht, zähle diesen ebenfalls. Und merke dir dann die Zahl zwei.
- Das Ganze sollst, du liebes Java Programm machen, bis der letzte Name der Liste gezählt wurde.
- Und dann gib mir den Zählwert zurück.
Du brauchst also Java Operatoren, welche bei jedem neuen Durchlauf sich schrittweise erhöhen.
Und diese Operatoren sind dann Inkrement und als Gegenstück das Dekrement.
Und wie funktioniert es nun?
Inhalt
Java bietet dir zwei Operatoren an
Der Inkrement Operator besteht aus zwei Pluszeichen.
Im Code würde dies so aussehen:
public class Inkrement {
public static void main(String[] args) {
int i = 2;
i++;//Durch die Inkrementierung wird die Java Variable um eins erhöht
System.out.println(i);
}
}
Klicke auf „Run“ und schau, was passiert.
- Die Variable wurde angelegt bzw. deklariert.
- Danach wurde ihr java-intern der Wert zwei zugewiesen.
- Durch die Inkrementierung wird schließlich der Wert auf drei erhöht.
- Und dieser wird dann über die println()-Anweisung auf der Konsole ausgegeben.
Die umgekehrte Variante vollzieht Java durch den Dekrement Operator
Es ist fast logisch.
Das Dekrementieren vollzieht du durch zwei Minuszeichen.
Und das wäre der Code dazu.
public class Inkrement {
public static void main(String[] args) {
int i = 2;
i++;//Durch die Inkrementierung wird die Java Variable um eins erhöht
System.out.println("Nach der Inkrementierung: " +i);
i--;// Durch das Dekrement wird diese Java Variable um eins verringert
System.out.println("Nach der Dekrementierung: "+i);
}
}
Um das ganze besser zu verdeutlichen, habe ich die Bildschirmausgaben mit Erklärungen verknüpft.
Du siehst auch dies funktioniert.
So…Das war es fast schon.
Dennoch solltest du auf Folgendes achten.
Inkrement und Dekrement funktionieren nur bei echten Java Variablen
Du kannst es nicht mit reinen Zahlen vollziehen.
Du musst immer zuerst richtige Java Variablen anlegen.
Das bedeutet:
Die Anweisung 5++; führt zu einem Fehler.
Schau dir dieses Bild einmal an.
Du siehst, dass Eclipse dir sofort die Fehlermeldung „Invalid argument to operator“ zurück gibt.
Also lege immer zuerst deine Java Variablen an
und erst dann, wendest du den Inkrement und Dekrement Operatoren auf diesen an.
Sowohl der Dekrement- als auch der Inkrement Operator können in Java als präfix oder postfix geführt werden
Was heißt das?
Du kannst i++; als auch ++i; schreiben.
Wo liegt der Unterschied?
public class Inkrement {
public static void main(String[] args) {
int i = 2;
int n = 2;
i++;//Java Operatoren Inkrement als postfix
System.out.println("Nach der Inkrementierung postfix: " +i);
++n;// Java Operatoren Inkrement als präfix
System.out.println("Nach der Inkrementierung präfix: " +n);
}
}
Übernimm bitte den Code und klicke auf „Run“.
Was passiert?
Ja das Ergebnis ist beiden Fällen (i und n) gleich…. Und zwar jeweils 3.
Aber warum werden jetzt zwei Möglichkeiten durch Java angeboten?
Ganz einfach.
Im Falle einer präfixen Erhöhung oder Verminderung der Variablen, findet diese sofort statt und wird sofort zurückgeben.
Im zweiten Fall, einer postfixen Erhöhung, wird diese Erhöhung erst später gespeichert.
Deutlich wird das Ganze, wenn du die Anweisung zur Inkrementierung oder Dekrementierung direkt einbindest.
Schau dir noch diesen Code dazu an.
Ich vollziehe die Inkrementierung direkt in der println() Anweisung.
public class Inkrement {
public static void main(String[] args) {
int i = 2;
int n = 2;
System.out.println("Nach der Inkrementierung präfix: " + (++i));
System.out.println("Nach der Inkrementierung postfix: "+ (n++));
}
}
Wenn du jetzt auf „Run“ klickst, siehst du den Unterschied.
Im ersten Fall, bei der präfixen Anwendung, wird i =3 zurückgeben.
Und im zweiten Fall, bei der postfixen Inkrementierung, wird n =2 zurückgeben.
Der Unterschied ist jetzt klar, oder?
Aber wichtig ist noch zu sagen.
N ist auch im zweiten Fall auf drei erhöht wurden.
Innerhalb der println() Anweisung ist n=2.
Aber nachdem diese ausgführt wurde, ist n=3.
Und auch hierzu noch der Code:
public class Inkrement {
public static void main(String[] args) {
int i = 2;
int n = 2;
System.out.println("Nach der Inkrementierung präfix: " + (++i));
System.out.println("Nach der Inkrementierung postfix: "+ (n++));
System.out.println(n); //Zum Test für n
}
}
Na, wieso versuchst du die ganze Postfix- und Präfix-Geschichte nicht einmal selbst aus?
Schreibe doch das kleine Programm einmal um.
Und zwar für den Dekrement Operator.
Da funktioniert das Ganze ebenfalls.
Bevor ich es vergesse….
Diese Java Operatoren kannst du für alle Variablentypen anwenden
Bisher habe ich dir dies lediglich bei lokalen Variablen gezeigt.
Du kannst das Ganze natürlich auch für Instanz- und Klassenvariablen anwenden.
Und so könnte dein Java Code dazu aussehen:
public class Inkrement {
int n = 2; //Instanzvariable der Java Klasse Inkrement
static int a =2; //Klassenvariable der Klasse Inkrement
public static void main(String[] args) {
int i = 2; //lokale Variable der main Methode
Inkrement objektEins = new Inkrement(); //Neues Objekt um die Instanzvariable aufzurufen
System.out.println("Die lokale Variable hat jetzt den Wert " + (++i)); //Erhöhung der lokalen Variable
System.out.println("Die Instanzvariable hat jetzt den Wert "+ (++objektEins.n)); //Erhöhung der Instanzvariablen
System.out.println("Die Klassenvariable hat jetzt den Wert "+(++a));//Erhöhung der Klassenvariablen
}
}
Zusammenfassung:
- Für die schrittweise Erhöhung und Verminderung von Variablen, bietet dir Java zwei Operatoren an.
- Der Inkrement Operator erhöht den Wert der Variablen jeweils um eins.
- Der Dekrement Operator vermindert den Wert der Variablen um jeweils eins.
- Beide Operatoren werden oftmals in Schleifen als Zähler eingesetzt.
Über den Autor
