Aritmetiske operatører i Java | Forklart

Operatørene er byggesteinene til ethvert programmeringsspråk og så i Java også. Aritmetiske operatører utfører få grunnleggende matematiske beregninger på variabler/verdier. Operasjonene inkluderer tillegg, subtraksjon, divisjon, multiplikasjon, divisjon og å finne resten. Denne artikkelen gir arbeid og bruk av aritmetiske operatører i Java.

Hvordan aritmetiske operatører jobber i Java

Denne delen gir en liste over aritmetiske operatører støttet av Java, og operatørens arbeid er også beskrevet.

Tillegg (+): Denne operatøren viser resultatet av å legge til to eller flere to variabler/verdier. Følgende syntaks beskriver tilleggsoperasjonen:

A+B;

Subtraksjon(-): Subtraksjon av to eller mer enn to operander støttes av (-) operatør i java. Følgende syntaks hjelper til med å bruke denne operatøren:

A-B;

Multiplikasjon (*): For å multiplisere verdier/variabler, praktiseres denne aritmetiske operatøren i Java. Du kan følge syntaksen nedenfor for å utføre multiplikasjon

a*b;

Inndeling(/): Denne operatøren lar deg multiplisere flere verdier/variabler i Java og returnerer kvotienten som er oppnådd etter avdeling. For å bruke denne operatøren, må du følge syntaksen nedenfor:

a/b;

Modul (%): En moduloperatør i Java returnerer resten av to verdier/variabler etter avdeling. Syntaksen som er skrevet nedenfor praktiseres ved hjelp av denne operatøren:

a%b;

Hvordan forrang fungerer innen aritmetiske operatører

Prioriteten er en avgjørende faktor som operatørens arbeid er avhengig av. For forrang kan de aritmetiske operatørene deles inn i to kategorier kalt et additive og multiplikative tilsetningsstoff. De multiplikative operatørene inkluderer *, / og % mens additivoperatøren bare inkluderer +og og -.

Hvis flere aritmetiske operatører brukes i et enkelt uttrykk, har de multiplikative operatørene høyere forrang enn additive operatører.

Hvordan bruke aritmetiske operatører i Java

Denne delen gir bruken av hver aritmetiske operatør for å utføre de tilknyttede operasjonene.

Legge til to verdier: Java -koden gitt nedenfor viser anvendelsen av + operatør på to heltallvariabler.

pakke newpack;
offentlig klasse Arithop
public static void main (String [] args)
// erklære variabler
int x = 4, y = 7, sum;
// legge til x og y
sum = x+y;
// Skrive ut summen
System.ute.println (sum);

Koden er beskrevet som gitt nedenfor:

• erklærer tre variabler
• Bruk tilleggsoperatøren til å legge til x og y. Lagrer deretter svaret i sumvariabel
• skriver ut sum variabel

Utgangen fra koden er nevnt nedenfor:

Subtraksjon(-): Som diskutert tidligere, viser subtraksjonsoperatøren resultatet etter å ha trukket en verdi fra en annen. Følgende Java -kode viser bruken av subtraksjonsoperatør:

pakke newpack;
offentlig klasse Arithop
public static void main (String [] args)
// erklære variabler
int x = 11, y = 17, sub;
// Trekker fra X fra Y
sub = y-x;
// Skrive ut svaret
System.ute.println (sub);

Ovennevnte kode trekker fra X og lagrer svaret i variabel under. Til slutt, verdien av under er trykt. Utgangen kan observeres i følgende bilde:

Multiplikasjon (*): Java -koden skrevet nedenfor multipliserer to variabler og returnerer resultatet.

pakke newpack;
offentlig klasse Arithop
public static void main (String [] args)
// erklære variabler
int x = 4, y = 7, mul;
// multipliserer x og y
mul = x*y;
// Skrive ut svaret
System.ute.Println (mul);

Ovennevnte kode erklærer to variabler og multipliserer disse variablene. Videre lagres resultatet i en navngitt variabel Mul og er også trykt.

Inndeling(/): For å øve på dette praktiseres følgende Java -kode ved hjelp av divisjonsoperatøren.

pakke newpack;
offentlig klasse Arithop
public static void main (String [] args)
// erklære variabler
int x = 4, y = 7, div;
// deler x og y
div = y/x;
// Skrive ut svaret
System.ute.println (div);

Den ovennevnte koden erklærer X og Y og deler dem deretter og lagrer svaret i div variabel. Til slutt div Variabel skrives ut som det kan sees i utgangen vist nedenfor:

Modul (%): En moduloperatør praktiseres å få resten av de to variablene som blir delt. Vi har utført følgende kode for å bruke Modulus -operatøren i Java.

pakke newpack;
offentlig klasse Arithop
public static void main (String [] args)
// erklære variabler
int x = 3, y = 11, modu;
// deler x og y
modu = y%x;
// Skrive ut svaret
System.ute.println (modu);

Utgangen fra ovennevnte kode er gitt nedenfor:

Bruke forskjellige aritmetiske operatører i et enkelt uttrykk

Frem til nå har vi diskutert aritmetiske operatører individuelt. Her vil vi presentere et Java -program som viser anvendelsen av forskjellige aritmetiske operatører i et enkelt Java -uttrykk.

pakke newpack;
offentlig klasse Arithop
public static void main (String [] args)
// erklære variabler
int a = 3, b = 11, c = 7, examp1, examp2;
// Bruke +, - og /
examp1 = (b/a)+(c-a)+(b-c);
// Bruke *, +, -og %
examp2 = (b%c)+(a*c)-(c%a);
// Skrive ut svarene
System.ute.println (Examp1);
System.ute.println (Examp2);

Koden er forklart nedenfor:

• erklærer fem variabler
• bruker +, - og / operatørene på A-, B- og C -variabler, mens svaret er lagret i Examp1
• Bruker operatørene *, +, -og % på A-, B- og C -variabler, og svaret er lagret i Examp2
• de Examp1 og Examp2 Variabler skrives ut

Utgangen vises på bildet nedenfor:

Konklusjon

Aritmetiske operatører hjelper til med å utføre flere matematiske operasjoner som tillegg, subtraksjon, divisjon, multiplikasjon, etc. Denne artikkelen gir arbeid fra flere aritmetiske operatører støttet av Java. De aritmetiske operatørene er ytterligere kategorisert i additive og multiplikative aritmetiske operatører. Presedensen til multiplikative operatører er større enn forsetningen til additive operatører. Ulike eksempler i dette innlegget demonstrerer bruken av aritmetiske operatører hver for seg og i et enkelt uttrykk også.