Unäre Operatoren inkrementieren und dekrementieren in Java

Unäre Operatoren

Unäre Operatoren sind solche Operatoren in Java, die nur einen einzigen Operanden benötigen , um eine Funktion auszuführen. Sie funktionieren nach dem gleichen Prinzip wie unäre Operationen in der Mathematik. Sie können beispielsweise unäre Operatoren verwenden, um einen positiven oder negativen Wert darzustellen, einen Wert um 1 zu erhöhen, einen Wert um 1 zu verringern oder einen Wert zu negieren.

• +x (positiver Wert)
• -x (negativer Wert)
• ++x (Inkrementierungsvorgang)
• --x (Dekrementierungsvorgang)
• !x (Negation)

Arten unärer Operatoren

Es gibt 5 Arten der unären Operatoren

1. Unäres Plus

Es stellt einen positiven Wert wie +x = x oder +5 = 5 dar.

2. Unäres Minus

Es stellt einen negativen Wert wie -x = -x oder -5 = -5 dar.

3. Erhöhen Sie den unären Operator

Es erhöht den Wert um 1, wobei ++x = x+1.

4. Dekrementieren Sie den unären Operator

Es verringert den Wert um 1, wobei --x = x-1.

5. Logisches Komplement

Es invertiert logischerweise den Wert eines booleschen Werts, z. B. wenn x = wahr ist, dann ist !x falsch.

Inkrementoperator (++)

Der Inkrementoperator (++) (auch bekannt als unärer Inkrementoperator) wird in Java verwendet, um den Wert einer Variablen um 1 zu erhöhen. Da es sich um einen Typ eines unären Operators handelt, kann er mit einem einzelnen Operanden verwendet werden.

Syntax

Die Syntax für den Inkrementoperator besteht aus einem Paar Additionszeichen, d. h. Der Operator kann entweder vor oder nach der Variablen angewendet werden. Beide haben die gleiche Schrittweite von 1. Sie haben jedoch beide unterschiedliche Verwendungszwecke und können in die folgenden Typen kategorisiert werden.

• Vorinkrement-Operator
• Post-Inkrement-Operator

Beispiel

public class IncrementOperator {

	public static void main(String[] args) {

		int variable = 15;
		System.out.println("Original value of the variable = " + variable);

		// after using increment operator
		variable++; 	 //  increments 1, variable = 16
		System.out.println("variable++ = " + variable);

		++variable;		//  increments 1, variable = 17
		System.out.println("++variable = " + variable);
	}
}

Ausgang

Vorinkrement-Operator (++x;)

Wenn der Inkrementoperator (++) wie ein Präfix (++x) vor der Variablen angegeben wird, spricht man von einem Vorinkrementoperator. In diesem Fall wird der Wert der Variablen zunächst um 1 erhöht und anschließend werden weitere Berechnungen durchgeführt.

Beispiel

public class PreIncrementOperator {

	public static void main(String[] args) {

		int variable = 5;
		System.out.println("Original value of the variable = " + variable);

		// using pre-increment operator
		int preIncrement = ++variable;

		System.out.println("variable = " + variable);
		System.out.println("preIncrement = " + preIncrement);
		System.out.println("++preIncrement = " + ++preIncrement);
	}
}

Ausgang

Post-Inkrement-Operator (x++;)

Wenn der Inkrementoperator (++) nach der Variablen wie ein Postfix (x++) angegeben wird, wird er als Postinkrementoperator bezeichnet. In diesem Fall wird für die Berechnungen der ursprüngliche Wert der Variablen (ohne Inkrement) verwendet und anschließend um 1 erhöht.

Beispiel

public class PostIncrementOperator {

	public static void main(String[] args) {

		int variable = 100;
		System.out.println("Original value of the variable = " + variable);

		// using post-increment operator
		int postIncrement = variable++; // postIncrement = 100, variable = 101

		System.out.println("postIncrement = " + postIncrement);
		System.out.println("variable = " + variable + "\n");

            // postIncrement = 101
		System.out.println("postIncrement++ = " + postIncrement++);
            // postIncrement = 102
		System.out.println("postIncrement++ = " + postIncrement++);
            // postIncrement = 103
		System.out.println("postIncrement++ = " + postIncrement++);

		System.out.println("\npostIncrement = " + postIncrement);
	}
}

Ausgang

Dekrementoperator (--)

Dekrement wird, wie der Name schon sagt, verwendet, um den Wert einer Variablen um 1 zu reduzieren. Da es sich ebenfalls um einen unären Operatortyp handelt, kann es mit einem einzelnen Operanden verwendet werden.

Syntax

Die Syntax für den Dekrementoperator besteht aus einem Paar negativer Vorzeichen, d. h. Ebenso wie der Inkrementoperator kann auch der Dekrementoperator (--) vor und nach der Variablen angewendet werden. Beide führen zum gleichen Dekrement von 1. Sie haben beide unterschiedliche Verwendungszwecke und können in die weiteren Typen divergiert werden.

• Pre-Dekrement-Operator
• Post-Dekrement-Operator

Vordekrement-Operator (--x;)

Wenn der Dekrementoperator (--) wie ein Präfix (--x) vor der Variablen steht, spricht man von einem Prädekrementoperator. In diesem Fall wird der Wert der Variablen zunächst um 1 dekrementiert und dann werden andere Berechnungen durchgeführt.

Beispiel

public class PreDecrementOperator {

	public static void main(String[] args) {

		int variable = 11;
		System.out.println("Original value of the variable = " + variable);

		// using preDecrement operator
		int preDecrement = --variable;

            // variable = 10
		System.out.println("variable = " + variable);
            // preDecrement = 10
		System.out.println("preDecrement = " + preDecrement);
            // preDecrement = 9
		System.out.println("--preDecrement = " + --preDecrement);  	}
}

Ausgang

Post-Dekrement-Operator (x--;)

Wenn der Dekrementoperator (--) nach der Variablen wie ein Postfix (x--) erwähnt wird, spricht man von einem Postdekrementoperator. In diesem Fall wird der ursprüngliche Wert der Variablen (ohne Dekrement) für die Berechnungen verwendet und dann um 1 dekrementiert.

Beispiel

public class PostDecrementOperator {

	public static void main(String[] args) {

		int variable = 75;
		System.out.println("Original value of the variable = " + variable);

		// using postDecrement operator
            // postDecrement = 75, variable = 74
		int postDecrement = variable--;
		System.out.println("postDecrement = " + postDecrement);
		System.out.println("variable = " + variable + "\n");
		// postDecrement = 74
		System.out.println("postDecrement-- = " + postDecrement--);
            // postDecrement = 73
		System.out.println("postDecrement-- = " + postDecrement--);
            // postDecrement = 72
		System.out.println("postDecrement-- = " + postDecrement--);

		System.out.println("\npostDecrement = " + postDecrement);
	}
}

Abschluss

Wir hoffen, dass Sie am Ende dieses Beitrags mit den unären Inkrementierungs- und Dekrementierungsoperatoren in Java vertraut sind. Sie werden ermutigt, die Grenzfälle und andere Übungsaufgaben bei CodeGym zu üben, um sich Ihrer Fähigkeiten sicher zu sein. Um das Gelernte zu vertiefen, empfehlen wir Ihnen, sich eine Videolektion aus unserem Java-Kurs anzusehen

Viel Glück und viel Spaß beim Lernen!