Skip to main content

So verwendest du Inkrement und Dekrement Operatoren in deinen Java Programmen

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:

  1. Fang ganz oben an. Und merke dir die Zahl eins. Denn hier ist der erste Name der Liste.
  2. Falls unter dem ersten Namen noch ein zweiter Name auftaucht, zähle diesen ebenfalls. Und merke dir dann die Zahl zwei.
  3. Das Ganze sollst, du liebes Java Programm machen, bis der letzte Name der Liste gezählt wurde.
  4. 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?

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.

Java Operatoren Inkrement Dekrement

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.

Na alles klar? 🙂
Wie hat dir der Beitrag gefallen?

Falls du Anregungen und Bemerkungen zu den Java Operatoren hast, dann schreibe mir doch direkt unter diesem Beitrag ein Kommentar.


Ähnliche Beiträge

So kannst du zweidimensionale Java Arrays anlegen und nutzen

Java Arrays zweidimensional

Eines der bedeutendsten Instrumente in der Mathematik ist das Koordinatensystem. Die gedankliche Grundlage dieses Werkzeuges lieferte der französische Naturwissenschaftler und Philosoph Rene Descartes. Man muss sich einmal verdeutlichen, was dies für die damalige Zeit bedeutete. Bisher wurden mathematische Probleme lediglich durch Berechnungen gelöst. Denke an geometrische Figuren, wie Dreiecke und Vierecke. Der Umfang wurde lediglich […]

Nutze das Java Switch Case Statement für komplexe Verzweigungen

Java Switch case

Java switch case statement – was ist das? Wozu brauchst du das? Lass mich anders beginnen… 🙂 In einen meiner früheren Beiträge habe ich schon einmal über bedingte Anweisungen oder Zuweisungen geschrieben. Diese if und else Konstrukte funktionieren eigentlich ganz gut. Aber was ist, wenn du mehrere Parameter abfangen möchtest. Okay ein Beispiel…

So kannst du dein Java Programm mit der main Methode ausführen

Auf zum ersten Java Programm. Vielleicht fragst du dich jetzt gerade: Na, was haben wir denn bisher gemacht? War das etwa kein Java Programm? Wir haben bisher nur eine Klasse „Human“ für ein zuküntfiges Mensch-Objekt erstellt. Diesem Objekt haben wir eine Instanzvariable, namens size (Größe) zugeordnet. Und wir haben eine Instanzmethode, namens grow (wachsen) geschrieben. […]

So nutzt du Methoden aus der Java String Klasse

Java Strings Methoden

In einen der letzten Beiträge haben wir darüber gesprochen, dass Java Strings – Objekte sind. Dass Strings in allen Programmen äußerst häufig vorkommen Und dass sich deshalb Referenzvariablen String-Objekte im String Pool teilen. Das Konzept hinter dem String-Pool ist die Teilung der Ressourcen. Und das bedeutet: Weniger Objekte – mehr Speicher Mehr Speicher – bessere […]

Eine Java Konsoleneingabe machst du über den Scanner

Es wird Zeit für die erste Java Konsoleneingabe. Und diese Eingaben machst du über den Java Scanner. Was ist das? Der Scanner ist eine vorgefertigte Java Klasse, welche Java mit seiner API anbietet. Das heißt du musst nichts selbst erschaffen. Du musst nur wissen, wie du darauf zugreifst. Erst einmal musst du einen Scanner anlegen. […]

3 Möglichkeiten um Vererbung von Java Klassen zu verhindern, zu verbieten oder ausschließen

Java Vererbung verhindern

Die ganze Java Vererbung für bestimmte Klassen ausschließen bzw. verhindern oder verbieten. Was soll das? Für bestimmte Java Klassen soll die Vererbung ausgeschlossen werden. Es soll also verhindert werden, dass Elternklassen – Kindklassen bekommen können. Klingt ein bisschen wie Verhütung, oder? Denn wie auch im echten Leben, können Kinder zu kleinen Tyrannen werden. Sie bedienen […]

So verwendest du die Java Codeblöcke zur Automatisierung

Java Codeblöcke

In diesem Beitrag geht es um den Einsatz von Java Codeblöcken oder Initialisierungsblöcken. Viele Wege führen nach Rom. Oder Alle Wege führen nach Rom. Heißt es in einem alten Sprichwort. Und so ähnlich ist es bei der Java Programmierung. In diesem Beitrag möchte ich dir einen weiteren Weg vorstellen, wie du Variablen eines Java Objektes […]

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]

Achte bei Java Methoden stets auf die Wertübergabe

Java Methoden Wertübergabe

Ich lege gleich los…. Schau dir diesen Code einmal an. Welche Zahl wird wohl auf der Bildschirmanzeige zurückgegeben? public class MethodenWertUebergabe { static int verdoppele (int i){ i=i*2; return i; } public static void main(String[] args) { int i = 2; verdoppele(i); System.out.println(i); } }

Den Java Vererbungsbaum nach dem Ist-Es-Prinzip richtig entwerfen

Java Vererbungsbaum

Vererbungsbaum in Java – klingt erstmal komisch. Dennoch wird dies so bezeichnet. Gemeint sind damit – die einzelnen Hierarchiestufen oder Vererbungsebenen – von der Superklasse bis runter zu den Kindklassen. Wie sieht das nun konkret aus? Vererbung bedeutet: Du definierst einen allgemeinen Typen – zB. Möbel Und dann implementierst du eine Unterklasse, welche die Oberklasse […]

So unterstützen dich Java Vererbungstabellen beim Entwurf

Java Vererbungstabellen

Bei der Java Vererbung gibt es zwei Klassenarten bzw. -stufen. Die Superklassen, welche einen allgemeinen Typen darstellen Und die spezielleren Unterklassen, welche die Superklasse um bestimmte Funktionen erweitern. Jetzt ist dieses ganze „Der-erbt-von-dem-Konzept“ mitunter sehr schwierig darzustellen. Zum Beispiel in einem Werkzeugkoffer. In einem Werkzeugkoffer befinden sich sämtliche Werkzeuge, von Säge bis Bohrmaschine. Wie machst […]