Java-samengestelde operators

1. Overzicht

In deze zelfstudie bekijken we Java-samengestelde operators, hun typen en hoe Java ze evalueert.

We leggen ook uit hoe impliciet casten werkt.

2. Samengestelde toewijzingsoperatoren

Een toewijzingsoperator is een binaire operator die het resultaat van de rechterkant toewijst aan de variabele aan de linkerkant. De eenvoudigste is de “=” toewijzingsoperator:

int x = 5;

Deze verklaring declareert een nieuwe variabele X, wijst toe X de waarde van 5 en keert terug 5.

Samengestelde toewijzingsoperatoren zijn een kortere manier om een rekenkundige of bitsgewijze bewerking toe te passen en om de waarde van de bewerking toe te wijzen aan de variabele aan de linkerkant.

De volgende twee vermenigvuldigingsinstructies zijn bijvoorbeeld equivalent, wat betekent een en b zal dezelfde waarde hebben:

int a = 3, b = 3, c = -2; a = a * c; // Eenvoudige toewijzingsoperator b * = c; // Samengestelde toewijzingsoperator

Het is belangrijk op te merken dat de variabele aan de linkerkant van een samengestelde toewijzingsoperator al moet zijn gedeclareerd. Met andere woorden, samengestelde operatoren kunnen niet worden gebruikt om een nieuwe variabele te declareren.

Net als de toewijzingsoperator "=" retourneren samengestelde operatoren het toegewezen resultaat van de uitdrukking:

lang x = 1; lange y = (x + = 2);

Beide X en y zal de waarde behouden 3.

De opdracht (x + = 2) doet twee dingen: ten eerste voegt het 2 toe aan de waarde van de variabele X, die wordt 3; ten tweede retourneert het de waarde van de toewijzing, wat ook is 3.

3. Soorten samengestelde toewijzingsoperatoren

Java ondersteunt 11 operators voor samengestelde toewijzing. We kunnen deze groeperen in rekenkundige en bitsgewijze operatoren.

Laten we eens kijken naar de rekenkundige operatoren en de bewerkingen die ze uitvoeren:

Ophogen: +=
Decrementatie: -=
Vermenigvuldiging: *=
Divisie: /=
Modulus: %=

Dan hebben we ook de bitsgewijze operatoren:

AND, binair: &=
Exclusief OF, binair: ^=
Inclusief OR, binair: |=
Left Shift, binair: <<=
Right Shift, binair: >>=
Nulvulling naar rechts verschuiven: >>>=

Laten we eens kijken naar een paar voorbeelden van deze bewerkingen:

// Eenvoudige toewijzing int x = 5; // x is 5 // Verhoging x + = 5; // x is 10 // Decrementatie x - = 2; // x is 8 // Vermenigvuldiging x * = 2; // x is 16 // Modulus x% = 3; // x is 1 // Binair EN x & = 4; // x is 0 // Binair exclusief OF x ^ = 4; // x is 4 // Binair inclusief OF x | = 8; // x is 12

Zoals we hier kunnen zien, is de syntaxis om deze operators te gebruiken consistent.

4. Evaluatie van samengestelde toewijzingsoperaties

Er zijn twee manieren waarop Java de samengestelde bewerkingen evalueert.

Eerste, wanneer de linker operand geen array is, dan zal Java, om:

Controleer of de operand een gedeclareerde variabele is
Sla de waarde van de linker operand op
Evalueer de rechter operand
Voer de binaire bewerking uit zoals aangegeven door de samengestelde operator
Converteer het resultaat van de binaire bewerking naar het type van de linker variabele (impliciete casting)
Wijs het geconverteerde resultaat toe aan de linkervariabele

De volgende, als de linker operand een array is, de te volgen stappen zijn een beetje anders:

Controleer de array-uitdrukking aan de linkerkant en gooi een NullPointerException of ArrayIndexOutOfBoundsException als het onjuist is
Sla het array-element op in de index
Evalueer de rechter operand
Controleer of de geselecteerde arraycomponent een primitief type of referentietype is en ga dan verder met dezelfde stappen als de eerste lijst, alsof de linker operand een variabele is.

Als een stap van de evaluatie mislukt, blijft Java de volgende stappen niet uitvoeren.

Laten we enkele voorbeelden geven met betrekking tot de evaluatie van deze bewerkingen voor een array-element:

int [] getallen = null; // Probeer oplopende getallen [2] + = 5;

Zoals we zouden verwachten, zal dit een NullPointerException.

Als we echter een beginwaarde aan de array toewijzen:

int [] nummers = {0, 1}; // Probeer oplopende getallen [2] + = 5;

We zouden de NullPointerException, maar we zouden nog steeds een ArrayIndexOutOfBoundsException, aangezien de gebruikte index niet correct is.

Als we dat oplossen, wordt de bewerking met succes voltooid:

int [] nummers = {0, 1}; // Oplopende getallen [1] + = 5; // x is nu 6

eindelijk, de X variabele zal zijn 6 aan het einde van de opdracht.

5. Impliciet gieten

Een van de redenen waarom samengestelde operatoren nuttig zijn, is dat ze niet alleen een kortere manier bieden voor bewerkingen, maar ook impliciet variabelen casten.

Formeel een uitdrukking van een samengestelde toewijzing van de vorm:

E1 op = E2

is gelijk aan:

E1 - (T) (E1 op E2)

waar T is het type E1.

Laten we eens kijken naar het volgende voorbeeld:

lang getal = 10; int i = nummer; i = i * nummer; // Compileert niet

Laten we eens kijken waarom de laatste regel niet compileert.

Java promoot automatisch kleinere datatypes naar grotere datatypes, wanneer ze samen in een bewerking zijn, maar zal een foutmelding geven bij het converteren van grotere naar kleinere typen.

Dus eerst ik wordt gepromoveerd tot lang en dan geeft de vermenigvuldiging het resultaat 10L. Het lange resultaat zou worden toegewezen aan ik, dat is een int, en dit zal een fout veroorzaken.

Dit kan worden opgelost met een expliciete cast:

i = (int) i * getal;

Operators voor samengestelde toewijzing van Java zijn in dit geval perfect omdat ze een impliciete casting uitvoeren:

i * = nummer;

Deze verklaring werkt prima, waarbij het vermenigvuldigingsresultaat wordt gecast int en het toewijzen van de waarde aan de linkerzijde variabele, ik.

6. Conclusie

In dit artikel hebben we gekeken naar samengestelde operatoren in Java, waarbij we enkele voorbeelden en verschillende typen ervan hebben gegeven. We hebben uitgelegd hoe Java deze bewerkingen evalueert.

Ten slotte hebben we ook de impliciete casting besproken, een van de redenen waarom deze steno-operatoren nuttig zijn.

Zoals altijd zijn alle codefragmenten die in dit artikel worden genoemd, te vinden in onze GitHub-repository.

streamalism.org