streamalism.org

1. Áttekintés

Ebben az oktatóanyagban megvizsgáljuk a Java összetett operátorokat, azok típusait és a Java értékelését.

Azt is elmagyarázzuk, hogy az implicit casting hogyan működik.

2. Összetett hozzárendelés operátorok

A hozzárendelés operátor egy bináris operátor, amely a jobb oldali eredményt hozzárendeli a bal oldali változóhoz. A legegyszerűbb az “=” hozzárendelés operátor:

int x = 5;

Ez az utasítás új változót deklarál x, kijelöli x az értéke 5 és visszatér 5.

Az összetett hozzárendelés operátorai rövidebb módszerek számtani vagy bitenkénti műveletek alkalmazására, és a művelet értékének a bal oldali változóhoz való hozzárendelésére.

Például a következő két szorzási utasítás ekvivalens, azaz a és b ugyanaz lesz az értéke:

int a = 3, b = 3, c = -2; a = a * c; // Egyszerű hozzárendelési operátor b * = c; // Összetett hozzárendelés operátor

Fontos megjegyezni, hogy az összetett hozzárendelés operátor bal oldalán található változót már deklarálni kell. Más szavakkal, összetett operátorok nem használhatók új változó deklarálásához.

Az „=” hozzárendelés operátorhoz hasonlóan az összetett operátorok is visszaadják a kifejezés hozzárendelt eredményét:

hosszú x = 1; hosszú y = (x + = 2);

Mindkét x és y meg fogja tartani az értéket 3.

A megbízás (x + = 2) két dolgot tesz: először hozzáad 2-t a változó értékéhez x, ami válik 3; másodszor a hozzárendelés értékét adja vissza, ami szintén 3.

3. Az összetett hozzárendelés operátorainak típusai

A Java 11 összetett hozzárendelési operátort támogat. Ezeket csoportosíthatjuk aritmetikai és bitenkénti operátorokra.

Menjünk át az aritmetikai operátorokon és az általuk végzett műveleteken:

• Növekmény: +=
• Csökkentés: -=
• Szorzás: *=
• Osztály: /=
• Modulus: %=

Ezután megvan a bitenkénti operátor is:

• ÉS, bináris: &=
• Exkluzív VAGY, bináris: ^=
• Beleértve OR, bináris: |=
• Bal váltás, bináris: <<=
• Jobb váltás, bináris: >>=
• Váltás jobbra nulla kitöltés: >>>=

Nézzünk meg néhány példát ezekre a műveletekre:

// Egyszerű hozzárendelés int x = 5; x értéke 5 // növekmény x + = 5; x 10 = dekrementáció x - = 2; x értéke 8 // szorzás x * = 2; x értéke 16 Modulus x% = 3; x értéke 1 bináris ÉS x & = 4; x értéke 0 // bináris kizárólagos OR x ^ = 4; x értéke 4 Bináris OR vagy x | = 8; x x 12

Amint itt láthatjuk, az ezen operátorok használatának szintaxisa következetes.

4. Az összetett hozzárendelési műveletek értékelése

A Java kétféleképpen értékeli az összetett műveleteket.

Első, amikor a bal oldali operandus nem tömb, akkor a Java sorrendben:

1. Ellenőrizze, hogy az operandus deklarált változó-e
2. Mentse el a bal oldali operandus értékét
3. Értékelje a jobb oldali operandust
4. Végezze el a bináris műveletet az összetett operátor által megadott módon
5. Konvertálja a bináris művelet eredményét a bal oldali változó típusára (implicit casting)
6. Rendelje hozzá az átalakított eredményt a bal oldali változóhoz

Következő, amikor a bal oldali operandus tömb, a követendő lépések kissé eltérnek:

1. Ellenőrizze a tömb kifejezést a bal oldalon, és dobja el a NullPointerException vagy ArrayIndexOutOfBoundsException ha helytelen
2. Mentse el a tömb elemet az indexben
3. Értékelje a jobb oldali operandust
4. Ellenőrizze, hogy a kiválasztott tömbösszetevő primitív vagy referencia típusú-e, majd folytassa az első listával megegyező lépésekkel, mintha a bal oldali operandus változó lenne.

Ha az értékelés bármelyik lépése sikertelen, a Java nem folytatja a következő lépéseket.

Adjunk néhány példát ezen műveletek kiértékeléséhez egy tömb elemhez:

int [] számok = null; // Inkrementációs számok kipróbálása [2] + = 5;

Ahogy számítottunk rá, ez a NullPointerException.

Ha azonban a tömbhöz kezdeti értéket rendelünk:

int [] számok = {0, 1}; // Inkrementációs számok kipróbálása [2] + = 5;

Megszabadulnánk a NullPointerException, de akkor is kapnánk egy ArrayIndexOutOfBoundsException, mivel az alkalmazott index nem megfelelő.

Ha ezt kijavítjuk, a művelet sikeresen befejeződik:

int [] számok = {0, 1}; Növekményszámok [1] + = 5; x x most 6

Végül a x változó lesz 6 a megbízás végén.

5. Implicit casting

Az összetett operátorok egyik oka annak, hogy nem csak rövidebb utat biztosítanak a műveletekhez, hanem implicit módon leadják a változókat is.

Formálisan a forma összetett hozzárendelési kifejezése:

E1 op = E2

egyenértékű:

E1 - (T) (E1 op E2)

hol T a típusa E1.

Vizsgáljuk meg a következő példát:

hosszú szám = 10; int i = szám; i = i * szám; // Nem fordít

Nézzük át, miért nem áll össze az utolsó sor.

A Java automatikusan elősegíti a kisebb adattípusok nagyobbakat, amikor együtt vannak egy művelet során, de hibát dob, amikor nagyobbról kisebbre konvertál.

Tehát először én előléptetik hosszú és akkor a szorzás adja az eredményt 10L. A hosszú eredményt hozzárendelnék én, ami egy int, és ez hibát vet.

Ezt meg lehet oldani egy kifejezett szereplőgárdával:

i = (int) i * szám;

A Java összetett hozzárendelés operátorai ebben az esetben tökéletesek, mert implicit castingot hajtanak végre:

i * = szám;

Ez az állítás remekül működik, és a szorzási eredményt a következőre adja int és hozzárendeljük az értéket a bal oldali változóhoz, én.

6. Következtetés

Ebben a cikkben az összetett operátorokat vizsgáltuk a Java-ban, néhány példát és különféle típusokat megadva. Elmagyaráztuk, hogyan értékeli a Java ezeket a műveleteket.

Végül áttekintettük az implicit castingot is, amely egyik oka annak, hogy ezek a gyorsírási operátorok hasznosak.

Mint mindig, a cikkben említett összes kódrészlet megtalálható a GitHub-adattárunkban.