Java-Operatoren

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 Ergebnisse der Kompilierung und Ausführung der obigen Beispiele sind wie folgt:

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

Bit-Operationen

Java definiert Bit-Operationen, die auf die Integer-Typen (int), Long-Typen (long), Short-Typen (short), Char-Typen (char) und Byte-Typen (byte) und andere Typen angewendet werden.

Bit-Operationen wirken auf alle Bits und führen Operationen bitweise durch. Angenommen, a = 60, 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 zeigt die grundlegenden Operationen der Bit-Operationen, unter der Annahme, dass der Wert der Integer-Variable A 60 und der Wert der Variable B ist 13:

Beispiel

Ein einfaches Beispielprogramm zeigt die Bit-Operationen. Kopieren und fügen Sie den folgenden Java-Code in eine Datei mit dem Namen Test.java und speichern Sie sie, dann kompilieren und ausführen Sie das Programm:

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;　　　　　/*　15　=　1111　*/
　　　　　System.out.println("a >>　2　　= \　+　c );
　　
　　　　　c = a >>>　2;　　　　　/*　15　= 0000　1111　*/
　　　　　System.out.println("a >>>　2　= \　+　c );
　　}
}

Die Ergebnisse der Kompilierung und Ausführung der obigen Beispiele sind wie folgt:

a & b =　12
a | b =　61
a ^ b =　49
~a =　-61
a <<　2　=　240
a >>　2　　=　15
a >>>　2　=　15

Logikoperator

Die folgende Tabelle zeigt die grundlegenden Operationen der Logikoperationen, unter der Annahme, dass die Boolean-Variablen A true und Variable B false sind

Beispiel

Der folgende einfache Beispielprogramm zeigt die Logikoperationen. Kopieren und fügen Sie den folgenden Java-Code in eine Datei namens Test.java und speichern Sie ihn, dann kompilieren und ausführen Sie dieses Programm:

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 Ergebnisse der Kompilierung und Ausführung der obigen Beispiele sind wie folgt:

a && b = false
a || b = true
!(a && b) = true

Kurzschlusslogikoperator

Wenn mit Logikoperationen gearbeitet wird, wird das Ergebnis nur true, wenn beide Operanden true sind, aber wenn der erste Operand false ist, ist das Ergebnis zwangsläufig false, und dann wird nicht mehr der zweite Operand überprüft.

public class LuoJi{}}
　　　　public static void main(String[] args){
　　　　　　　　int a =　5;//Eine Variable definieren;
　　　　　　　　boolean b = (a<4) && (a++<10);
　　　　　　　　System.out.println("Das Ergebnis des Kurzkettengeschaltungsoperators ist "+b);
　　　　　　　　System.out.println("Der Wert von a ist "+a);
　　　　}
}

Laufende Ergebnisse:

Das Ergebnis des Kurzkettengeschaltungsoperators ist false
Das Ergebnis von a ist5

Erklärung:Dieses Programm verwendet den Kurzkettengeschaltungsoperator (&&), der zuerst überprüft, ob a<4 ergeben false, dann muss das Ergebnis von b unbedingt false sein, daher wird der zweite Operator a nicht ausgeführt++<10 entscheidend, daher ist der Wert von a 5。

Zuweisungsoperator

Hier sind die Zuweisungsoperator, die von der Java-Sprache unterstützt werden:

Beispiel

Der folgende einfache Beispielprogramm zeigt den Zuweisungsoperator. Kopieren und fügen Sie den folgenden Java-Programmcode in die Datei AssignmentOperator.java ein und speichern Sie sie, dann kompilieren und ausführen Sie dieses Programm:

class AssignmentOperator {
　　　　public static void main(String[] args) {
　　　　　　　　
　　　　　　　　int number1, number2;
　　　　　　　　
　　　　　　　　//Wird5wird der Variable number zugewiesen1
　　　　　　　　Zahl1　=　5;
　　　　　　　　System.out.println(number1);
　　　　　　　　　　　　　　　　
　　　　　　　　//Die Variable number2wird der Variable number zugewiesen1
　　　　　　　　Zahl2　= number1;
　　　　　　　　System.out.println(number2);
　　　　}
}

Die Ergebnisse der Kompilierung und Ausführung der obigen Beispiele sind wie folgt:

5
5

bedingter Operator（?:）

Der bedingte Operator wird auch als dreifacher Operator bezeichnet. Der Operator hat3eine Operanden und muss den Wert des booleschen Ausdrucks beurteilen. Der Hauptzweck dieses Operators ist es zu bestimmen, welchen Wert der Variable zugewiesen werden soll.

variable x = (expression) ? value if true : value if false

Beispiel

public class Test {
　　　public static void main(String[] args){
　　　　　　int a, b;
　　　　　　a =　10;
　　　　　　//　wenn a gleich　1　gültig, dann wird b　20, andernfalls　30
　　　　　　b = (a ==　1) ?　20 :　30;
　　　　　　System.out.println("Wert von b ist:");　+　　b);
　
　　　　　　//　wenn a gleich　10　gültig, dann wird b　20, andernfalls　30
　　　　　　b = (a ==　10) ?　20 :　30;
　　　　　　System.out.println("Wert von b ist:");　+　b);
　　　}
}

Die Ergebnisse der Kompilierung und Ausführung der obigen Beispiele sind wie folgt:

Wert von b ist:　30
Wert von b ist:　20

instanceof-Operator

Dieser Operator wird verwendet, um Objekte zu operieren und zu überprüfen, ob das Objekt ein bestimmter Typ (Klassentyp oder Interface-Typ) ist.

Der Format der instanceof-Operator ist wie folgt:

(Object reference variable) instanceof (class/interface type)

Wenn das Objekt auf der linken Seite des Operators der Klasse oder des Interfaces (class/wenn ein Objekt eines Interfaces) existiert, dann ist das Ergebnis wahr.

Hier ist ein Beispiel:

String name = "James";
boolean result = name instanceof String;　//　Da name vom Typ String ist, wird true zurückgegeben

Wenn das verglichene Objekt mit der rechten Typenkompatibel ist, gibt der Operator immer noch true zurück.

Sehen 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 Ergebnisse der Kompilierung und Ausführung der obigen Beispiele sind wie folgt:

true

Java-Operator-Priorität

Wenn mehrere Operatoren in einem Ausdruck vorkommen, in welcher Reihenfolge werden sie berechnet? Dies betrifft das Problem der Priorität der Operatoren. Unterschiedliche Prioritäten der Operatoren in einem mehrfachen Ausdruck können erhebliche Unterschiede im Endresultat verursachen.

例如，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。

再如，x = 7 + 3 * 2；这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。

The operators with the highest precedence in the table are at the top, and the ones with the lowest precedence are at the bottom.