Detaillierte Erklärung von Betreibern und Verwendung in Java

Im vorherigen Inhalt habe ich gelernt, wie man Variablen definiert und initialisiert. Der Zweck der Definition von Variablen besteht darin, Daten zu manipulieren. Die Java -Sprache bietet uns Code -Symbole, die speziell zum Betrieb dieser Daten verwendet werden, die gemeinsam als "Operatoren" bezeichnet werden.

Nach der Verwendung von Operatoren können wir sie in die folgenden Kategorien einteilen:

Arithmetische Operatoren

Zuordnungsbetreiber

Selbsterrück- und Selbstverstärkungsoperatoren

Logische Operatoren

Relationale Operatoren

Bitbetreiber

Machen Sie sich keine Sorgen, es sind nur Symbole, die uns helfen, die Betriebsdaten zu verarbeiten. Im Folgenden werden Codebeispiele verwendet, um die Verwendung dieser Bediener nacheinander zu veranschaulichen.

1. Arithmetische Operatoren

Arithmetische Operatoren sind arithmetische Operationen zum Hinzufügen, Subtrahieren, Multiplizieren, Teilen und Nehmen von numerischen Variablen:

Hinzufügen: +
reduzieren:-
nehmen:*
entfernen:/
Guthaben nehmen: %

 öffentliche Klasse OperatorsDemo {public static void main (String [] args) {int num1 = 100; int num2 = 20; // system.out.println ("num1 + num2:" + (num1 + num2)); // system.out.println ("num1 - num2:" + (num1 - num2)); // multiplizieren system.out.println ("num1 * num2:" + (num1 * num2)); // Discount System.out.println ("num1 / num2:" + (num1 / num2)); // das verbleibende System erhalten. }}

Ausgangsergebnis:

 Num1 + Num2: 120NUM1 - Num2: 80NUM1 * Num2: 2000NUM1 / Num2: 5NUM1 % Num2: 0

2. Zuweisungsoperator

Wie die meisten Programmiersprachen verwendet Java den Operator '=', um Zuweisungsvorgänge auszuführen. Dieser Vorgang weist der Variablen links rechts das Berechnungsergebnis rechts (als RValue bezeichnet) zu. Zu den Zuordnungsbetreibern in Java gehören:

= (num2 = num1)
+= (num2 += num1 äquivalent num2 = num2 +num1)
-= (num2 -= num1 äquivalent num2 = num2 -num1)
*= (num2 *= num1 äquivalent num2 = num2 *num1)
/= (num2 /= num1 äquivalent num2 = num2 /num1)
%= (Num2 %= Num1 äquivalent Num2 = Num2 %Num1)

 öffentliche Klasse OperatorsDemo {public static void main (String [] args) {int num1 = 10; int num2 = 20; Num2 = Num1; System.out.println ("= Ausgabe:"+num2); Num2 += Num1; System.out.println ("+= Ausgabe:"+num2); Num2 -= Num1; System.out.println ("-= Ausgabe:"+num2); Num2 *= num1; System.out.println ("*= Ausgabe:"+num2); Num2 /= Num1; System.out.println ("/= output:"+num2); Num2 %= Num1; System.out.println ("%= output:"+num2); }}

Ergebnisse Ausgabe:

 = Ausgabe: 10+= Ausgabe: 20- = Ausgabe: 10*= Ausgabe: 100/= Ausgabe: 10%= Ausgabe: 0

3.. Selbsterlierungs- und Selbstverstärkungsoperatoren

Die Operatoren selbst zu erstellen und selbstverlorter nur mit einer Variablen und dem Wert der variablen Änderungen.

Num ++ (äquivalent num = num+ 1) nimmt von selbst zu, hauptsächlich für numerische Variablen und addiert 1 zum Wert seiner eigenen Variablen.
Num -(äquivalente num = num -1) Selbstdeduktiv, hauptsächlich auf numerische Variablen abzielen, subtrahieren Sie den Wert der Körpervariablen um 1.

 öffentliche Klasse OperatorsDemo {public static void main (String [] args) {int num1 = 100; int num2 = 200; Num1 ++; Num2--; System.out.println ("num1 ++ ist:"+num1); System.out.println ("Num2-- IS:"+num2); }}

Ergebnisse Ausgabe:

 Num1 ++ ist: 101num2-- IS: 199

4. Logische Operatoren

Logische Operatoren werden, wie der Name schon sagt, für logische Urteile verwendet. Das Ergebnis der Operation ist ein Wert des Booleschen Typs, dh wahr oder falsch. Logische einheitliche Operatoren haben

B1 && B2: Wenn sowohl B1 als auch B2 wahr sind, wird B1 && B2 wahr zurückgeben, ansonsten falsch

B1 || B2: Wenn sowohl B1 als auch B2 falsch sind, wird falsch zurückgegeben, andernfalls wird True zurückgegeben.

! B1: Gibt den gegenüber B1 entgegengesetzten Wert zurück, wenn B1 falsch ist, zurück. Wenn B1 wahr ist, geben Sie false zurück

 öffentliche Klasse OperatorsDemo {public static void main (String [] args) {boolean b1 = true; boolean b2 = falsch; System.out.println ("B1 && b2:" + (b1 && b2)); System.out.println ("B1 || B2:" + (B1 || B2)); System.out.println ("! (B1 && b2):" +! (B1 && b2)); }}

Ausgangsergebnis:

 B1 && B2: Falschb1 || B2: Richtig! (B1 && b2): wahr

Logischer Kurzschluss:

In Java unterstützen logische Operatoren Kurzschlussoperationen, und sobald der Wert des gesamten Ausdrucks klar ausgedrückt werden kann, müssen wir den Rest des Ausdrucks nicht berechnen. Zum Beispiel müssen wir beurteilen, dass ein Objekt nicht leer ist und dass der Rückgabewert seiner Methode nicht leer ist, damit wir ein solches Urteil fällen können:

 if (Object! = null && object.somefunction ()!

Wenn das Objekt leer ist, gibt das erste Teil des Ausdrucksobjekts! Der Compiler optimiert diesen Teil des Vorgangs automatisch und führt das Objekt nicht aus.

5. Relationale Operatoren

Wird verwendet, um die Größe von zwei variablen Daten zu vergleichen, den Wert des Booleschen, dh wahr oder falsch, zurückzusetzen

Zu den relationalen Betreibern gehören:

'==' und '! =' sind für alle Arten von Werten und Objekten geeignet (d. H. Primitive Typvariablen und Referenztypvariablen).

'>', '<', '> =' und '<=' gelten nicht für Werte von Booleschen Typen, da sie nur wahr oder falsch sind und größer als und weniger als keine praktische Bedeutung haben.

 öffentliche Klasse OperatorsDemo {public static void main (String [] args) {int num1 = 10; int num2 = 50; if (num1 == num2) {System.out.println ("num1 und num2 sind gleich"); } else {System.out.println ("Num1 und Num2 sind nicht gleich"); } if (num1! = num2) {System.out.println ("num1 und num2 sind nicht gleich"); } else {System.out.println ("Num1 und Num2 sind nicht gleich"); } else {System.out.println ("Num1 und Num2 sind nicht gleich"); } Equal ");} if (num1> num2) {System.out.println (" num1 ist größer als num2 ");} else {system.out.println (" num1 ist nicht größer als num2 ");} if (num1> = num2) {System.println (" num1 ist größer als "num2"). Weniger als num2 ");} if (num1 <num2) {System.out.println (" num1 ist weniger als num2 ");} if (num1 <num2) {System.out.println (" num1 ist weniger als num2 ");} else {system.println (" num1 ist nicht weniger als weniger als weniger als 22). System.out.println ("Num1 ist weniger als oder gleich Num2");

Ausgangsergebnis:

 NUM1 und Num2 sind nicht gleichnumm und num2 sind nicht gleichnum1 ist nicht größer als num2num1 ist kleiner als num2num1 ist kleiner als Num2num1 ist kleiner oder gleich Num2

6. Bitoperator

Das vom Bitoperator abzielte Betriebsobjekt ist binäre "Bits", die auf Ganzzahltypen (INT), Long, Short, Charaktertyp (Zeichen) und Byte (Byte) und andere Typen angewendet werden können. Während des Betriebs wird das entsprechende Bit (0 oder 1) im booleschen algebraischen Betrieb oder im beweglichen Betrieb durchgeführt.

Die Beschreibung der Computerlogik ist etwas dunkel, und wir können Beispiele verwenden, um klarer zu verstehen, wie Bitbetreiber Berechnungen durchführen. Angenommen, wenn x gleich 60 ist; y ist gleich 13; Ihre binären Darstellungen und die Ergebnisse von Bitoperationen sind wie folgt:

 x = 0011 1100y = 0000 1101 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Beachten Sie den Unterschied zwischen >> und >>>:

Right Shift Operator >> Wenn der Wert des Vorgangs positiv ist, wird 0 in die hohe Position eingefügt. Wenn der Wert negativ ist, wird 1 in die hohe Position eingefügt;

Bewegen Sie sich rechts, um den Null -Operator zu füllen >>> und 0 an der hohen Position einfügen, unabhängig von positiv oder negativ.

> Wenn Sie die Bit -Operation nicht verstehen, überspringen Sie ihn zuerst. Wenn es tatsächlich verwendet wird, können Sie es erneut studieren.

7. Operator Priorität

Die Priorität des Bedieners bestimmt die Gruppierung von Begriffen in einem Ausdruck. Es wirkt sich aus, wie ein Ausdruck bewertet wird. Ein bestimmter Betreiber hat eine höhere Priorität als andere Betreiber.

Zum Beispiel: Der Multiplikationsoperator hat eine höhere Priorität als der Additionsbetreiber, und der Ausdruck 1 + 5 * 6. Gemäß der Priorität des Bedieners berechnet der Compiler zuerst 5 * 6, berechnet dann 30 + 1 und erhalten schließlich das Ergebnis 31.

Die Priorität verschiedener Betreiber ist von groß bis klein:

 ., (), [] Monokular +(von rechts nach links kombiniert), monokular - (rechts nach links kombiniert), ++, -, ~,!*, /,% +(Links nach rechts kombiniert), - (links nach rechts kombiniert) >>, <<, >>> <, <=,> ==,!

Mach dir keine Sorgen um eine so komplexe Prioritätsliste. In den meisten Fällen ist der Ausdruck selbst leicht vorrangig. Beispielsweise muss der Zuordnungsvorgang die niedrigste Priorität haben. In Fällen, in denen die Priorität nicht klar ist, können wir die Priorität so ändern, wie wir es möchten. Daher müssen sich die Priorität des Bedieners nicht zu sehr erinnern.

8. Andere Betreiber

Drei-Wege-Bediener:

Der bedingte Operator in Java ist ein ternärer Operator, und seine Form lautet wie folgt:

 BooleanExpression? valuewhentue: valuewhenfalse

Wenn der boolesche Expressionswert wahr ist, ist der Wert des Ausdrucks der Wert von Valuewhentue, ansonsten der Wert des Werts whenFalse.

Wenn wir beispielsweise den Absolutwert von X berechnen möchten, können wir ihn über den folgenden Code implementieren:

 if (x> = 0) {y = x;} else {y = -x;}

Durch den ternären Operator benötigen Sie nur eine Anweisung y = x> = 0? x: -x; Um es zu vervollständigen, was prägnanter ist.

Typ Conversion Operator:

Wir verwenden in vielen Fällen die Typumwandlung. Zu den geeigneten Zeiten wandelt Java den Datentyp automatisch gemäß dem Datentyp in einen anderen um. Wenn wir beispielsweise der Float -Variablen einen Ganzzahlwert zuweisen, konvertiert der Compiler INT in Float und zuordnet ihn der Variablen zu.

In vielen Fällen kann Java jedoch nicht feststellen, ob wir die Typumwandlung durchführen müssen. Zu diesem Zeitpunkt benötigen wir Typ -Conversion -Operatoren, mit denen wir explizit Typkonvertierungen durchführen können, z. B.:

 int a = 10; lang b = (lang) a; lang c = (lang) 100;

Wir können sowohl Variablen als auch Konstanten konvertieren.

Bei der Durchführung der Typumwandlung von Gleitkomma-Zahlen müssen wir auf das Problem der Kürzung achten. Wenn wir konvertieren 10.9: (int) 10.9, ist der Wert nicht um 11, sondern 10 abgerundet, sondern 10