Eine der grundlegendsten Einsatzmöglichkeiten von Computern ist die Durchführung mathematischer Operationen. Java bietet als Computersprache auch einen umfangreichen Satz an Operatoren zur Manipulation von Variablen. Wir können Operatoren in die folgenden Gruppen einteilen:
Arithmetische Operatoren werden in mathematischen Ausdrücken verwendet und funktionieren auf die gleiche Weise wie in der Mathematik. Die folgende Tabelle listet alle arithmetischen Operatoren auf.
Das Beispiel in der Tabelle geht davon aus, dass die Ganzzahlvariable A den Wert 10 und die Variable B den Wert 20 hat:
Operator | beschreiben | Beispiel |
---|---|---|
+ | Addition – die Werte auf beiden Seiten des Additionsoperators | A + B entspricht 30 |
- | Subtraktion – linker Operand minus rechter Operand | A – B entspricht -10 |
* | Multiplikation – Multipliziert die Werte auf beiden Seiten des Operators | A * B entspricht 200 |
/ | Division – dividiert den linken Operanden durch den rechten Operanden | B/A entspricht 2 |
% | Modulo – der Rest des linken Operanden dividiert durch den rechten Operanden | B%A ist gleich 0 |
++ | Inkrement – erhöht den Wert des Operanden um 1 | B++ oder ++B entspricht 21 |
-- | Dekrementieren – verringert den Wert des Operanden um 1 | B-- oder --B entspricht 19 |
Obwohl beide sich selbst erhöhen (ihre Operationsergebnisse sind gleich B+1), gibt es immer noch Unterschiede zwischen B++ und ++B. ++B ist ein L-Wert und kann direkt an Ort und Stelle betrieben werden (kann als + direkt verstanden werden). Variable B).1) B++ ist ein R-Wert. Bei der Arbeit im Compiler wird zuerst eine temporäre Variable erstellt, und dann wird die temporäre Variable zur Berechnung von +1 verwendet und dann B zugewiesen.
Daher wird im folgenden Beispielcode beim Drucken von d++ festgestellt, dass das Ergebnis nicht +1 ist (zu diesem Zeitpunkt wird die Variable d gedruckt und die temporäre Variable von d bearbeitet), sondern das im nächsten angezeigte Ergebnis Die gedruckte Anweisung ist wieder +1. Das Endergebnis (der Wert der temporären Variablen wird der Variablen d zugewiesen). Das Ergebnis des Druckens von ++d ist direkt +1.
Das folgende einfache Beispielprogramm demonstriert arithmetische Operatoren. Kopieren Sie das folgende Java-Programm, fügen Sie es ein und speichern Sie es als Test.java-Datei. Kompilieren Sie dann das Programm und führen Sie es aus:
public class Test { public static void main(String args[]) { int a = 10; int b = 20; int c = 25; int d = 25; System.out.println("a + b = " + (a + b) ); System.out.println("a - b = " + (a - b) ); System.out.println("a * b = " + (a * b) ); System.out.println("b / a = " + (b / a) ); System.out.println("b % a = " + (b % a) ); System.out.println("c % a = " + (c % a) ); System.out.println("a++ = " + (a++) ); System.out.println("a-- = " + (a--) ); // 查看d++ 与++d 的不同System.out.println("d++ = " + (d++) ); System.out.println("d = " + d); System.out.println("++d = " + (++d) ); } }
Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5 a++ = 10 a-- = 11 d++ = 25 d =26 ++d = 27
Die folgende Tabelle zeigt die von Java unterstützten Vergleichsoperatoren
Die Beispiel-Ganzzahlvariable A in der Tabelle hat einen Wert von 10 und Variable B hat einen Wert von 20:
Operator | beschreiben | Beispiel |
---|---|---|
== | Überprüft, ob die Werte der beiden Operanden gleich sind. Wenn ja, ist die Bedingung wahr. | (A == B) ist falsch (nicht wahr). |
!= | Überprüft, ob die Werte zweier Operanden gleich sind. Wenn die Werte nicht gleich sind, ist die Bedingung wahr. | (A != B) ist wahr. |
> | Prüft, ob der Wert des linken Operanden größer ist als der Wert des rechten Operanden. Wenn ja, wird die Bedingung wahr. | (A>B) ist nicht wahr. |
< | Prüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A < B) ist wahr. |
>= | Prüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A>=B) ist falsch. |
<= | Prüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A <= B) ist wahr. |
Das folgende einfache Beispielprogramm demonstriert relationale Operatoren. Kopieren Sie das folgende Java-Programm, fügen Sie es ein und speichern Sie es als Test.java-Datei. Kompilieren Sie dann das Programm und führen Sie es aus:
public class Test { public static void main(String args[]) { int a = 10; int b = 20; System.out.println("a == b = " + (a == b) ); System.out.println("a != b = " + (a != b) ); System.out.println("a > b = " + (a > b) ); System.out.println("a < b = " + (a < b) ); System.out.println("b >= a = " + (b >= a) ); System.out.println("b <= a = " + (b <= a) ); } }
Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
Java definiert bitweise Operatoren, die für Ganzzahltypen (int), lange Ganzzahlen (long), kurze Ganzzahlen (short), Zeichentypen (char) und Bytetypen (byte) gelten.
Bitweise Operatoren bearbeiten alle Bits und arbeiten bitweise. Angenommen, a = 60 und b = 13; ihre binäre Formatdarstellung wird wie folgt sein:
A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A | B = 0011 1101 A ^ B = 0011 0001 ~A= 1100 0011
Die folgende Tabelle listet die Grundoperationen bitweiser Operatoren auf, wobei davon ausgegangen wird, dass die Ganzzahlvariable A einen Wert von 60 und die Variable B einen Wert von 13 hat:
Operator | beschreiben | Beispiel |
---|---|---|
& | Beim bitweisen UND-Operator ist das Ergebnis genau dann 1, wenn ein bestimmtes Bit beider Operanden ungleich 0 ist. | (A&B), erhalte 12, also 0000 1100 |
| | Bitweiser ODER-Operator: Solange ein bestimmtes Bit der beiden Operanden nicht 0 ist, ist das Ergebnis 1. | (A | B) erhält 61, also 0011 1101 |
^ | Bitweiser XOR-Operator: Wenn ein bestimmtes Bit der beiden Operanden unterschiedlich ist, ist das Ergebnisbit 1. | (A^B) ergibt 49, also 0011 0001 |
~ | Der bitweise Komplementoperator dreht jedes Bit des Operanden um. | (~A) erhält -61, also 1100 0011 |
<< | Bitweiser Linksverschiebungsoperator. Der linke Operand wird um die vom rechten Operanden angegebene Anzahl von Bits nach links verschoben. | Ein << 2 ergibt 240, also 1111 0000 |
>> | Bitweiser Rechtsverschiebungsoperator. Der linke Operand wird bitweise um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben. | A >> 2 ergibt 15, also 1111 |
>>> | Bitweiser Rechtsverschiebungsoperator zum Auffüllen von Nullen. Der Wert des linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben und die resultierenden Leerstellen werden mit Nullen aufgefüllt. | A>>>2 erhält 15, also 0000 1111 |
Das folgende einfache Beispielprogramm demonstriert bitweise Operatoren. Kopieren Sie das folgende Java-Programm, fügen Sie es ein und speichern Sie es als Test.java-Datei. Kompilieren Sie dann das Programm und führen Sie es aus:
public class Test { public static void main(String args[]) { int a = 60; /* 60 = 0011 1100 */ int b = 13; /* 13 = 0000 1101 */ int c = 0; c = a & b; /* 12 = 0000 1100 */ System.out.println("a & b = " + c ); c = a | b; /* 61 = 0011 1101 */ System.out.println("a | b = " + c ); c = a ^ b; /* 49 = 0011 0001 */ System.out.println("a ^ b = " + c ); c = ~a; /*-61 = 1100 0011 */ System.out.println("~a = " + c ); c = a << 2; /* 240 = 1111 0000 */ System.out.println("a << 2 = " + c ); c = a >> 2; /* 215 = 1111 */ System.out.println("a >> 2 = " + c ); c = a >>> 2; /* 215 = 0000 1111 */ System.out.println("a >>> 2 = " + c ); } }
Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
a & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a << 2 = 240 a >> 2 = 15 a >>> 2 = 15
In der folgenden Tabelle sind die Grundoperationen logischer Operatoren aufgeführt, wobei davon ausgegangen wird, dass die boolesche Variable A wahr und die Variable B falsch ist
Operator | beschreiben | Beispiel |
---|---|---|
&& | Wird als logischer UND-Operator bezeichnet. Eine Bedingung ist genau dann wahr, wenn beide Operanden wahr sind. | (A && B) ist falsch. |
|. | | Wird als logischer ODER-Operator bezeichnet. Die Bedingung ist wahr, wenn einer der beiden Operanden wahr ist. | (A | | B) ist wahr. |
! | Wird als logischer NOT-Operator bezeichnet. Wird verwendet, um den logischen Zustand des Operanden umzukehren. Wenn die Bedingung wahr ist, erhält der logische NOT-Operator den Wert „falsch“. | ! (A && B) ist wahr. |
Das folgende einfache Beispielprogramm demonstriert logische Operatoren. Kopieren Sie das folgende Java-Programm, fügen Sie es ein und speichern Sie es als Test.java-Datei. Kompilieren Sie dann das Programm und führen Sie es aus:
public class Test { public static void main(String args[]) { boolean a = true; boolean b = false; System.out.println("a && b = " + (a&&b)); System.out.println("a || b = " + (a||b) ); System.out.println("!(a && b) = " + !(a && b)); } }
Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
a && b = false a || b = true !(a && b) = true
Die folgenden Zuweisungsoperatoren werden von der Java-Sprache unterstützt:
Operator | beschreiben | Beispiel |
---|---|---|
= | Einfacher Zuweisungsoperator, der den Wert des rechten Operanden dem linken Operanden zuweist | C = A + B weist C den durch A + B erhaltenen Wert zu |
+ = | Additionszuweisungsoperator, der den linken Operanden und den rechten Operanden addiert und den Wert dem linken Operanden zuweist | C + = A ist äquivalent zu C = C + A |
-= | Subtraktions- und Zuweisungsoperator, der den linken Operanden vom rechten Operanden subtrahiert und den Wert dem linken Operanden zuweist | C - = A ist äquivalent zu C = C - A |
* = | Der Multiplikations- und Zuweisungsoperator, der den linken Operanden mit dem rechten Operanden multipliziert und den Wert dem linken Operanden zuweist | C * = A ist äquivalent zu C = C * A |
/ = | Der Divisions- und Zuweisungsoperator dividiert den linken Operanden und den rechten Operanden und weist den Wert dem linken Operanden zu. | C / = A ist äquivalent zu C = C / A |
(%)= | Modulo- und Zuweisungsoperator, der den linken und rechten Operanden moduliert und den Wert dem linken Operanden zuweist | C%=A ist äquivalent zu C=C%A |
<< = | Zuweisungsoperator für die linke Schicht | C << = 2 ist äquivalent zu C = C << 2 |
>> = | Rechtsverschiebungszuweisungsoperator | C >> = 2 ist äquivalent zu C = C >> 2 |
&= | Bitweiser AND-Zuweisungsoperator | C&=2 ist äquivalent zu C=C&2 |
^ = | Bitweiser XOR-Zuweisungsoperator | C^=2 entspricht C=C^2 |
|. = | Bitweiser ODER-Zuweisungsoperator | C|=2 ist äquivalent zu C=C|2 |
Das folgende einfache Beispielprogramm demonstriert den Zuweisungsoperator. Kopieren Sie das folgende Java-Programm, fügen Sie es ein und speichern Sie es als Test.java-Datei. Kompilieren Sie dann das Programm und führen Sie es aus:
public class Test { public static void main(String args[]) { int a = 10; int b = 20; int c = 0; c = a + b; System.out.println("c = a + b = " + c ); c += a ; System.out.println("c += a = " + c ); c -= a ; System.out.println("c -= a = " + c ); c *= a ; System.out.println("c *= a = " + c ); a = 10; c = 15; c /= a ; System.out.println("c /= a = " + c ); a = 10; c = 15; c %= a ; System.out.println("c %= a = " + c ); c <<= 2 ; System.out.println("c <<= 2 = " + c ); c >>= 2 ; System.out.println("c >>= 2 = " + c ); c >>= 2 ; System.out.println("c >>= a = " + c ); c &= a ; System.out.println("c &= a= " + c ); c ^= a ; System.out.println("c ^= a= " + c ); c |= a ; System.out.println("c |= a= " + c ); } }
Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
c = a + b = 30 c += a = 40 c -= a = 30 c *= a = 300 c /= a = 1 c %= a = 5 c <<= 2 = 20 c >>= 2 = 5 c >>= 2 = 1 c &= a = 0 c ^= a = 10 c |= a = 10
Bedingte Operatoren werden auch als ternäre Operatoren bezeichnet. Dieser Operator verfügt über drei Operanden und muss den Wert eines booleschen Ausdrucks auswerten. Der Hauptzweck dieses Operators besteht darin, zu entscheiden, welcher Wert der Variablen zugewiesen werden soll.
variable x = (expression) ? value if true : value if false
public class Test { public static void main(String args[]){ int a , b; a = 10; b = (a == 1) ? 20: 30; System.out.println( "Value of b is : " + b ); b = (a == 10) ? 20: 30; System.out.println( "Value of b is : " + b ); } }
Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
Value of b is : 30 Value of b is : 20
Dieser Operator wird verwendet, um Objektinstanzen zu bearbeiten und zu prüfen, ob das Objekt von einem bestimmten Typ ist (Klassentyp oder Schnittstellentyp).
Der Instanzoperator wird im folgenden Format verwendet:
( Object reference variable ) instanceof (class/interface type)
Wenn das Objekt, auf das die Variable auf der linken Seite des Operators zeigt, ein Objekt der Klasse oder Schnittstelle (Klasse/Schnittstelle) auf der rechten Seite des Operators ist, ist das Ergebnis wahr.
Hier ist ein Beispiel:
String name = 'James'; boolean result = name instanceof String; // 由于name是String类型,所以返回真
Dieser Operator gibt weiterhin true zurück, wenn die verglichenen Objekte mit dem rechten Typ kompatibel sind.
Schauen Sie sich das folgende Beispiel an:
class Vehicle {} public class Car extends Vehicle { public static void main(String args[]){ Vehicle a = new Car(); boolean result = a instanceof Car; System.out.println( result); } }
Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
true
Wenn in einem Ausdruck mehrere Operatoren vorkommen, welcher steht zuerst? Dabei geht es um die Frage der Bedienerpriorität. In einem Ausdruck mit mehreren Operatoren führen unterschiedliche Operatorprioritäten zu sehr unterschiedlichen Endergebnissen.
Beispiel: (1+3) + (3+2)*2, wenn dieser Ausdruck anhand des Pluszeichens als höchste Priorität berechnet wird, lautet die Antwort 18, und wenn das Multiplikationszeichen die höchste Priorität hat, lautet die Antwort 14.
Ein weiteres Beispiel: x = 7 + 3 * 2; hier erhält x 13, nicht 20, da der Multiplikationsoperator eine höhere Priorität hat als der Additionsoperator, also wird 3 * 2 zuerst berechnet, um 6 zu erhalten, und dann wird 7 addiert.
Die Operatoren mit der höchsten Priorität in der folgenden Tabelle stehen oben in der Tabelle, und die Operatoren mit der niedrigsten Priorität stehen unten in der Tabelle.
Kategorie | Operator | Relevanz |
---|---|---|
Suffix | () [] . (Punktoperator) | von links nach rechts |
ein Yuan | + + -! ~ | von rechts nach links |
multiplikativ | */% | von links nach rechts |
Additivität | + - | von links nach rechts |
Schicht | >> >>> << | von links nach rechts |
Beziehung | >> = << = | von links nach rechts |
gleich | == != | von links nach rechts |
Bitweises UND | & | von links nach rechts |
Bitweises XOR | ^ | von links nach rechts |
Bitweises ODER | | | von links nach rechts |
logisches UND | && | von links nach rechts |
logisch oder | |. | | von links nach rechts |
Zustand | ? : | von rechts nach links |
Abtretung | = + = - = * = / =%= >> = << =&= ^ = | | von rechts nach links |
Komma | , | von links nach rechts |