Java-Verbundoperatoren

1. Übersicht

In diesem Tutorial werden wir uns die zusammengesetzten Java-Operatoren, ihre Typen und deren Bewertung durch Java ansehen.

Wir werden auch erklären, wie implizites Casting funktioniert.

2. Compound Assignment Operators

Ein Zuweisungsoperator ist ein binärer Operator, der das Ergebnis der rechten Seite der Variablen auf der linken Seite zuweist. Am einfachsten ist der Zuweisungsoperator "=" :

int x = 5;

Diese Anweisung deklariert eine neue Variable x , weist x den Wert 5 zu und gibt 5 zurück .

Zusammengesetzte Zuweisungsoperatoren sind eine kürzere Möglichkeit, eine arithmetische oder bitweise Operation anzuwenden und den Wert der Operation der Variablen auf der linken Seite zuzuweisen.

Beispielsweise sind die folgenden zwei Multiplikationsanweisungen äquivalent, was bedeutet, dass a und b denselben Wert haben:

int a = 3, b = 3, c = -2; a = a * c; // Simple assignment operator b *= c; // Compound assignment operator

Es ist wichtig zu beachten, dass die Variable auf der linken Seite eines zusammengesetzten Zuweisungsoperators bereits deklariert sein muss. Mit anderen Worten, zusammengesetzte Operatoren können nicht zum Deklarieren einer neuen Variablen verwendet werden.

Wie der Zuweisungsoperator "=" geben zusammengesetzte Operatoren das zugewiesene Ergebnis des Ausdrucks zurück:

long x = 1; long y = (x+=2);

Sowohl x als auch y halten den Wert 3 .

Die Zuweisung (x + = 2) bewirkt zwei Dinge: Erstens addiert sie 2 zum Wert der Variablen x , die zu 3 wird; Zweitens wird der Wert der Zuweisung zurückgegeben, der ebenfalls 3 beträgt .

3. Arten von Verbindungszuweisungsoperatoren

Java unterstützt 11 zusammengesetzte Zuweisungsoperatoren. Wir können diese in arithmetische und bitweise Operatoren gruppieren.

Lassen Sie uns die arithmetischen Operatoren und die von ihnen ausgeführten Operationen durchgehen:

  • Inkrementierung: + =
  • Dekrementierung: - =
  • Multiplikation: * =
  • Abteilung: / =
  • Modul: % =

Dann haben wir auch die bitweisen Operatoren:

  • UND, binär: & =
  • Exklusives ODER, binär: ^ =
  • Inklusive ODER, binär: | =
  • Linksverschiebung, binär: << =
  • Rechtsverschiebung, binär: >> =
  • Verschieben Sie die Nullfüllung nach rechts: >>> =

Schauen wir uns einige Beispiele für diese Operationen an:

// Simple assignment int x = 5; // x is 5 // Incrementation x += 5; // x is 10 // Decrementation x -= 2; // x is 8 // Multiplication x *= 2; // x is 16 // Modulus x %= 3; // x is 1 // Binary AND x &= 4; // x is 0 // Binary exclusive OR x ^= 4; // x is 4 // Binary inclusive OR x |= 8; // x is 12

Wie wir hier sehen können, ist die Syntax zur Verwendung dieser Operatoren konsistent.

4. Bewertung der Zuweisungsvorgänge für Verbindungen

Es gibt zwei Möglichkeiten, wie Java die zusammengesetzten Operationen auswertet.

Erstens, wenn der linke Operand kein Array ist, wird Java in der folgenden Reihenfolge:

  1. Stellen Sie sicher, dass der Operand eine deklarierte Variable ist
  2. Speichern Sie den Wert des linken Operanden
  3. Bewerten Sie den rechten Operanden
  4. Führen Sie die binäre Operation wie vom zusammengesetzten Operator angegeben aus
  5. Konvertieren Sie das Ergebnis der Binäroperation in den Typ der linken Variablen (implizites Casting).
  6. Weisen Sie das konvertierte Ergebnis der linken Variablen zu

Als nächstes , wenn der linke Operand ist ein Array, die Schritte sind etwas anders zu folgen:

  1. Überprüfen Sie den Array-Ausdruck auf der linken Seite und lösen Sie eine NullPointerException oder ArrayIndexOutOfBoundsException aus, wenn dies nicht korrekt ist
  2. Speichern Sie das Array-Element im Index
  3. Bewerten Sie den rechten Operanden
  4. Überprüfen Sie, ob die ausgewählte Array-Komponente ein primitiver Typ oder ein Referenztyp ist, und fahren Sie dann mit denselben Schritten wie in der ersten Liste fort, als ob der linke Operand eine Variable wäre.

Wenn ein Schritt der Evaluierung fehlschlägt, führt Java die folgenden Schritte nicht weiter aus.

Geben wir einige Beispiele für die Auswertung dieser Operationen für ein Array-Element:

int[] numbers = null; // Trying Incrementation numbers[2] += 5;

Wie zu erwarten, wird dadurch eine NullPointerException ausgelöst .

Wenn wir dem Array jedoch einen Anfangswert zuweisen:

int[] numbers = {0, 1}; // Trying Incrementation numbers[2] += 5;

Wir würden die NullPointerException loswerden , aber wir würden immer noch eine ArrayIndexOutOfBoundsException bekommen , da der verwendete Index nicht korrekt ist.

Wenn wir das beheben, wird der Vorgang erfolgreich abgeschlossen:

int[] numbers = {0, 1}; // Incrementation numbers[1] += 5; // x is now 6

Schließlich ist die x- Variable am Ende der Zuweisung 6 .

5. Implizites Casting

Einer der Gründe, warum zusammengesetzte Operatoren nützlich sind, besteht darin, dass sie nicht nur eine kürzere Möglichkeit für Operationen bieten, sondern auch implizit Variablen umwandeln.

Formal ein zusammengesetzter Zuweisungsausdruck des Formulars:

E1 op = E2

ist äquivalent zu:

E1 - (T) (E1 op E2)

wobei T der Typ von E1 ist .

Let’s consider the following example:

long number = 10; int i = number; i = i * number; // Does not compile

Let’s review why the last line won’t compile.

Java automatically promotes smaller data types to larger data ones, when they are together in an operation, but will throw an error when trying to convert from larger to smaller types.

So, first, i will be promoted to long and then the multiplication will give the result 10L. The long result would be assigned to i, which is an int, and this will throw an error.

This could be fixed with an explicit cast:

i = (int) i * number;

Java compound assignment operators are perfect in this case because they do an implicit casting:

i *= number;

Diese Anweisung funktioniert nur gut, das Multiplikationsergebnis an Gießen int und den Wert auf der linken Seite Variablen zugewiesen wird , i .

6. Fazit

In diesem Artikel haben wir uns zusammengesetzte Operatoren in Java angesehen und einige Beispiele und verschiedene Arten von Operatoren angegeben. Wir haben erklärt, wie Java diese Operationen bewertet.

Schließlich haben wir auch das implizite Casting überprüft, einer der Gründe, warum diese Kurzschriftoperatoren nützlich sind.

Wie immer finden Sie alle in diesem Artikel erwähnten Codefragmente in unserem GitHub-Repository.