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 Operatoren1. 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.++x;
x++;
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
Ursprünglicher Wert der Variablen = 15
Variable++ = 16
++Variable = 17
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
Ursprünglicher Wert der Variablen = 5
Variable = 6
preIncrement = 6
++preIncrement = 7
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
Ursprüngliche Variable = 100
postInkrement = 100
Variable = 101
postInkrement++ = 100
postInkrement++ = 101
postInkrement++ = 102
postInkrement = 103
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.--X;
X--;
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
Ursprünglicher Wert der Variablen = 11
Variable = 10
preDecrement = 10
--preDecrement = 9
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);
}
}
Ursprünglicher Wert der Variablen = 75
postDecrement = 75
Variable = 74
postDecrement-- = 75
postDecrement-- = 74
postDecrement-- = 73
postDecrement = 72
GO TO FULL VERSION