Java-sammensatte operatører

1. Oversikt

I denne opplæringen vil vi se på Java-sammensatte operatører, deres typer og hvordan Java vurderer dem.

Vi forklarer også hvordan implisitt casting fungerer.

2. Sammensatte oppdragsoperatører

En oppdragsoperatør er en binær operatør som tilordner resultatet av høyre side til variabelen på venstre side. Det enkleste er “=” oppdragsoperatør:

int x = 5;

Denne uttalelsen erklærer en ny variabel x, tildeler x verdien av 5 og kommer tilbake 5.

Compound Assignment Operators er en kortere måte å bruke en aritmetisk eller bitvis operasjon og å tildele verdien av operasjonen til variabelen på venstre side.

For eksempel er følgende to multiplikasjonssetninger ekvivalente, betyr en og b vil ha samme verdi:

int a = 3, b = 3, c = -2; a = a * c; // Enkel oppdragsoperatør b * = c; // Sammensetningsoppdragsoperatør

Det er viktig å merke seg at variabelen til venstre for en sammensatt oppdragsoperatør allerede må være deklarert. Med andre ord, sammensatte operatører kan ikke brukes til å erklære en ny variabel.

I likhet med “=” tildelingsoperatøren, returnerer sammensatte operatører det tildelte resultatet av uttrykket:

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

Både x og y vil holde verdien 3.

Oppgaven (x + = 2) gjør to ting: for det første legger den 2 til verdien av variabelen x, som blir 3; for det andre returnerer den verdien av oppgaven, som også er 3.

3. Typer av sammensatte oppdragsoperatører

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

La oss gå gjennom regneoperatørene og operasjonene de utfører:

  • Inkrementering: +=
  • Dekrementering: -=
  • Multiplikasjon: *=
  • Inndeling: /=
  • Modulus: %=

Så har vi også bitvise operatører:

  • OG, binær: &=
  • Eksklusiv OR, binær: ^=
  • Inkludert ELLER, binær: |=
  • Venstre skift, binær: <<=
  • Right Shift, binær: >>=
  • Skift til høyre null fyll: >>>=

La oss se på noen få eksempler på disse operasjonene:

// Enkel oppgave int x = 5; // x er 5 // inkrementasjon x + = 5; // x er 10 // Dekrementering x - = 2; // x er 8 // Multiplikasjon 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 // Binær inkludert ELLER x | = 8; // x er 12

Som vi kan se her, er syntaksen for å bruke disse operatørene konsekvent.

4. Evaluering av sammensatte tildelinger

Det er to måter Java vurderer sammensatte operasjoner.

Først, når den venstre operanden ikke er en matrise, så vil Java, i rekkefølge:

  1. Kontroller at operanden er en deklarert variabel
  2. Lagre verdien til venstre operand
  3. Evaluer høyre operand
  4. Utfør den binære operasjonen som angitt av den sammensatte operatøren
  5. Konverter resultatet av den binære operasjonen til typen av venstre variabel (implisitt avstøpning)
  6. Tilordne det konverterte resultatet til venstre variabel

Neste, når den venstre operanden er en matrise, trinnene å følge er litt forskjellige:

  1. Bekreft arrayuttrykket på venstre side og kast a NullPointerException eller ArrayIndexOutOfBoundsException hvis det er feil
  2. Lagre matriseelementet i indeksen
  3. Evaluer høyre operand
  4. Sjekk om den valgte matrisekomponenten er en primitiv type eller referansetype, og fortsett deretter med de samme trinnene som den første listen, som om venstre operand er en variabel.

Hvis noen trinn i evalueringen mislykkes, fortsetter Java ikke å utføre følgende trinn.

La oss gi noen eksempler relatert til evaluering av disse operasjonene til et array-element:

int [] tall = null; // Prøver på inkrementasjonstall [2] + = 5;

Som vi forventer, vil dette kaste et NullPointerException.

Men hvis vi tilordner en startverdi til matrisen:

int [] tall = {0, 1}; // Prøver på inkrementasjonstall [2] + = 5;

Vi ville bli kvitt NullPointerException, men vi får fortsatt en ArrayIndexOutOfBoundsException, siden indeksen som brukes ikke er korrekt.

Hvis vi fikser det, blir operasjonen fullført:

int [] tall = {0, 1}; // Inkrementasjonstall [1] + = 5; // x er nå 6

Til slutt, x variabel vil være 6 på slutten av oppgaven.

5. Implisitt avstøpning

En av grunnene til at sammensatte operatører er nyttige er at de ikke bare gir en kortere måte å operere på, men også implisitt støpte variabler.

Formelt sett et sammensatt oppgaveuttrykk av skjemaet:

E1 op = E2

tilsvarer:

E1 - (T) (E1 op E2)

hvor T er typen E1.

La oss se på følgende eksempel:

langt tall = 10; int i = antall; i = i * nummer; // Kompilerer ikke

La oss se på hvorfor den siste linjen ikke kompileres.

Java markedsfører automatisk mindre datatyper til større datatyper når de er sammen i en operasjon, men vil kaste en feil når du prøver å konvertere fra større til mindre typer.

Så først Jeg vil bli forfremmet til lang og da vil multiplikasjonen gi resultatet 10L. Det lange resultatet vil bli tildelt Jeg, som er en int, og dette vil gi en feil.

Dette kan løses med en eksplisitt rollebesetning:

i = (int) i * nummer;

Java sammensatte oppdrag operatører er perfekte i dette tilfellet fordi de gjør en implisitt casting:

i * = antall;

Denne uttalelsen fungerer helt fint, og kaster multiplikasjonsresultatet til int og tilordne verdien til variabelen på venstre side, Jeg.

6. Konklusjon

I denne artikkelen så vi på sammensatte operatører i Java, med noen eksempler og forskjellige typer av dem. Vi forklarte hvordan Java evaluerer disse operasjonene.

Til slutt gjennomgikk vi også implisitt casting, en av grunnene til at disse stenografoperatørene er nyttige.

Som alltid finnes alle kodebitene som er nevnt i denne artikkelen, i GitHub-depotet vårt.


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