Java-sammensatte operatører

1. Oversigt

I denne vejledning ser vi på Java-sammensatte operatører, deres typer og hvordan Java vurderer dem.

Vi forklarer også, hvordan implicit casting fungerer.

2. Sammensatte tildelingsoperatører

En tildelingsoperatør er en binær operator, der tildeler resultatet af højre side til variablen på venstre side. Den enkleste er “=” opgaveoperatør:

int x = 5;

Denne erklæring erklærer en ny variabel x, tildeler x værdien af 5 og vender tilbage 5.

Compound Assignment Operators er en kortere måde at anvende en aritmetisk eller bitvis operation på og tildele værdien af ​​operationen til variablen på venstre side.

For eksempel er følgende to multiplikationsangivelser ækvivalente, hvilket betyder -en og b vil have den samme værdi:

int a = 3, b = 3, c = -2; a = a * c; // Enkel tildelingsoperator b * = c; // Sammensat tildelingsoperatør

Det er vigtigt at bemærke, at variablen til venstre for en sammensat tildelingsoperatør allerede skal deklareres. Med andre ord, sammensatte operatører kan ikke bruges til at erklære en ny variabel.

Ligesom tildelingsoperatoren “=” returnerer sammensatte operatorer det tildelte resultat af udtrykket:

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

Begge x og y holder værdien 3.

Opgaven (x + = 2) gør to ting: for det første tilføjer den 2 til værdien af ​​variablen x, som bliver 3; for det andet returnerer den værdien af ​​opgaven, som også er 3.

3. Typer af sammensatte tildelingsoperatører

Java understøtter 11 sammensatte tildelingsoperatører. Vi kan gruppere disse i aritmetiske og bitvise operatorer.

Lad os gennemgå de aritmetiske operatorer og de operationer, de udfører:

  • Forøgelse: +=
  • Nedbrydning: -=
  • Multiplikation: *=
  • Division: /=
  • Modulus: %=

Derefter har vi også de bitvise operatorer:

  • OG binært: &=
  • Eksklusiv ELLER, binær: ^=
  • Inklusiv OR, binær: |=
  • Venstre skift, binær: <<=
  • Right Shift, binær: >>=
  • Skift højre nulfyldning: >>>=

Lad os se på et par eksempler på disse operationer:

// Enkel tildeling int x = 5; // x er 5 // Forøgelse x + = 5; // x er 10 // Dekrementering x - = 2; // x er 8 // Multiplikation x * = 2; // x er 16 // Modulus x% = 3; // x er 1 // binær OG x & = 4; // x er 0 // Binær eksklusiv ELLER x ^ = 4; // x er 4 // inklusive binær ELLER x | = 8; // x er 12

Som vi kan se her, er syntaksen for at bruge disse operatorer konsekvent.

4. Evaluering af sammensatte tildelingsoperationer

Der er to måder, hvorpå Java evaluerer sammensatte operationer.

Først, når den venstre operand ikke er en matrix, så vil Java i rækkefølge:

  1. Kontroller, at operanden er en deklareret variabel
  2. Gem værdien af ​​den venstre operand
  3. Evaluer den højre operand
  4. Udfør den binære operation som angivet af den sammensatte operatør
  5. Konverter resultatet af den binære operation til typen af ​​den venstre variabel (implicit casting)
  6. Tildel det konverterede resultat til den venstre variabel

Næste, når den venstre operand er en matrix, trinene til at følge er lidt forskellige:

  1. Bekræft matrixudtrykket på venstre side og kast et NullPointerException eller ArrayIndexOutOfBoundsException hvis det er forkert
  2. Gem array-elementet i indekset
  3. Evaluer den højre operand
  4. Kontroller, om den valgte array-komponent er en primitiv type eller referencetype, og fortsæt derefter med de samme trin som den første liste, som om den venstre operand er en variabel.

Hvis et hvilket som helst trin i evalueringen mislykkes, fortsætter Java ikke med at udføre følgende trin.

Lad os give nogle eksempler relateret til evalueringen af ​​disse operationer til et array-element:

int [] tal = null; // Forsøger inkrementeringsnumre [2] + = 5;

Som vi kunne forvente, vil dette kaste et NullPointerException.

Men hvis vi tildeler matrixen en indledende værdi:

int [] tal = {0, 1}; // Forsøger inkrementeringsnumre [2] + = 5;

Vi ville slippe af med NullPointerException, men vi får stadig en ArrayIndexOutOfBoundsException, da det anvendte indeks ikke er korrekt.

Hvis vi løser det, afsluttes operationen med succes:

int [] tal = {0, 1}; // Forøgelsesnumre [1] + = 5; // x er nu 6

Endelig blev x variabel vil være 6 i slutningen af ​​opgaven.

5. Implicit støbning

En af grundene til, at sammensatte operatører er nyttige, er, at de ikke kun giver en kortere måde til operationer, men også implicit støbte variabler.

Formelt et sammensat tildelingsekspression af formularen:

E1 op = E2

svarer til:

E1 - (T) (E1 op E2)

hvor T er typen af E1.

Lad os overveje følgende eksempel:

langt tal = 10; int i = antal; i = i * antal; // Kompilerer ikke

Lad os gennemgå, hvorfor den sidste linje ikke kompileres.

Java fremmer automatisk mindre datatyper til større datatyper, når de er sammen i en operation, men kaster en fejl, når du prøver at konvertere fra større til mindre typer.

Så først, jeg vil blive forfremmet til lang og så vil multiplikationen give resultatet 10L. Det lange resultat ville blive tildelt jeg, som er en int, og dette vil kaste en fejl.

Dette kunne løses med en eksplicit rollebesætning:

i = (int) i * antal;

Java-sammensatte tildelingsoperatører er perfekte i dette tilfælde, fordi de udfører en implicit casting:

i * = antal;

Denne erklæring fungerer fint og kaster multiplikationsresultatet til int og tildele værdien til variablen i venstre side, jeg.

6. Konklusion

I denne artikel kiggede vi på sammensatte operatører i Java ved at give nogle eksempler og forskellige typer af dem. Vi forklarede, hvordan Java evaluerer disse operationer.

Endelig gennemgik vi også implicit casting, en af ​​grundene til at disse stenografiske operatører er nyttige.

Som altid kan alle kodestykker, der er nævnt i denne artikel, findes i vores GitHub-lager.


$config[zx-auto] not found$config[zx-overlay] not found