Grunnleggende operatører i Java | Forklart

Java har mange operatører som hjelper til med å utføre flere operasjoner på variabler/verdier. Disse operatørene er delt inn i flere typer, og operatørene som utfører like operasjoner er plassert i samme kategori.

For eksempel Java -operatørene som utfører tillegg, subtraksjon, divisjon, multiplikasjon osv. er plassert i den aritmetiske kategorien av operatører. Tilsvarende plasseres operatørene som gir forholdet mellom variabler i den relasjonelle operatørens kategori.

Denne artikkelen viser bruken og anvendeligheten til de grunnleggende operatørene i Java. Så la oss starte.

Hva er de grunnleggende operatørene i Java

Denne delen beskriver funksjonaliteten til grunnleggende operatører i Java.

Oppdragsoperatører

Disse operatørene hjelper til med å tildele verdi til en variabel i Java. Denne tildelingsaksjonen kan utføres ved hjelp av en av følgende operatører:

“=”: Fungerer med to operander og tildeler verdien plassert på høyre side til variabelen skrevet på venstre side.

“+=”: Legger til operander fra begge sider og tildeler deretter verdien til variabelen som er skrevet på venstre side

“-=”: Trekker operand plassert på høyre fra venstre, og tildeler deretter verdien til variabelen som er plassert på venstre side

“*=”: Multipliserer begge operander og tildeler deretter svaret til variabelen på venstre side

“/=”: Rapporter resten ved å dele operandene eller dele venstre operand med en spesifikk verdi.

“%=”: Får resten ved å bruke denne % først, og deretter blir svaret tilordnet variabelen på venstre side.

Følgende syntaks kan følges:

operand1 = operandd2; // Bruke =
operand1 += operand2 // Bruke +=
operand1- = operand2 // Bruke -=
operand1 *= operand2 // Bruke *=
operand1 /= operand2 // Bruke /=
operand1 %= operand2 // Bruke %=

Aritmetiske operatører

Denne kategorien omhandler aritmetiske operasjoner, og følgende operatører er bosatt i denne kategorien.

“+”: brukes til å legge til to variabler/verdier

“-“: gir forskjellen mellom to variabler/verdi

“*”: multipliserer to variabler/verdier

“/”: Brukes til å dele en variabel over en annen, og kvotienten vises i utgangen.

“%”: Rapporter resten () av ​​to variabler/verdier

Syntaksen til disse operatørene er gitt nedenfor, Operand1 og Operand2 refererer til variablene/verdiene. Det observeres at to operander er pålagt å utføre aritmetiske operasjoner.

operand1+operand2; //addisjon
operand1-operand2; //subtraksjon
operand1*operand2; // multiplikasjon
operand1/operand2; //inndeling
operand1%operand2; //rest

Unary -operatører

Denne typen utfører forskjellige operasjoner på en variabel/verdi. Operatørene som er inkludert i denne kategorien er beskrevet nedenfor:

“+”: tildeler positivt tegn til et operand (vanligvis vises ikke positivt tegn som det er valgfritt)

“-“: Endrer tegnet på en operand

“++”: trinn verdien av en operand med 1. Økningsoperatøren kan brukes som postfiks og prefiks

“-“: Verdien av en variabel/verdi reduseres med 1. Som økning kan det også brukes som et prefiks eller postfiks

“!”: Den boolske verdien (True/False) er omvendt ved å bruke denne operatøren

Du kan henvise til syntaksen til disse operatørene som er gitt nedenfor:

+operand; // Unary Plus
-operand; // Unary minus
++operand; // Prefiksøkning
operand ++; // Postfix økning
operand--; // Postfix Decrement
--operand; // prefiks redusering
!operand; // logikk komplement

Logiske operatører

Disse operatørene hjelper til med å utføre logiske operasjoner som og, eller, og ikke. Disse er beskrevet nedenfor:

OG(&&): Dette fungerer på to variabler/verdier, det returnerer sant hvis begge variablene er sanne og usant i andre tilfeller.

Eller (||): Denne operatøren bygger logikk slik at hvis begge verdiene er falske, ville resultatet være usant ellers sant.

IKKE (!): Dette refererer også til unary -kategorien og returnerer falske/sanne resultater

Du kan henvise til følgende syntaks for å bruke logiske operatører:

operand1 && operand2 // logisk og
operand1 || operand2 // logisk eller
!operand // logisk ikke

Bitvis operatører

Denne operatørens klasse tar for seg de binære verdiene, og dermed utføres alle operasjoner bit etter bit. og følgende operatører praktiseres:

“&”: Dette er kjent som binær og det fungerer på samme måte som logisk og men på binære verdier.

“|”: Dette fungerer også på samme mønster som logisk eller, men det utfører operasjonsbit etter bit.

“^”: Dette er kjent som XOR, det returnerer sant hvis begge verdiene er forskjellige og returnerer falske hvis begge verdiene er de samme.

“~”: Denne operatøren endrer biten fra 0 til 1 og 1 til 0

“<<“: Denne venstre skiftoperatøren forskyver antall biter til venstre. Antall biter avgjøres av brukeren, og det kan være et hvilket som helst tall.

“>>”: Høyre skiftoperatørskift fjerner antall biter fra høyre side.

“>>>”: Dette er kjent som usammet høyre skift, og det forskyver antall biter med "0"

Følgende syntaks refererer til bitvis operatørene:

operand1 | operand2; // Bitvis eller
operand1 & operand2; // Bitvis og
operand1 ^ operand2; // Bitvis XOR
~ operand; // Bitvis komplement
operand<operand >> nummer; // Bitvis høyre skift
operand >>> nummer; // bitvis usignert høyre skift

Relasjonelle operatører

Denne kategorien refererer til å relatere mer enn en variabel ved hjelp av spesifikke symboler. Disse operatørene hjelper til med å ta beslutninger i Java -programmering.

“==”: Denne operatøren praktiseres å sjekke likheten mellom to operander

“!= ”: brukes til å sjekke at ulikheten i operandene

“<“: praktisert å sjekke mindre enn forholdet mellom to operander

“>”: Det brukes til å sjekke at venstre operand er høyere eller ikke

“> =”: for å sjekke at venstre operand er "større enn eller lik" til høyre eller ikke

“<=”: Det praktiseres å sjekke om venstre variabel er mindre enn eller lik høyre

De relasjonelle operatørene kan praktiseres ved å bruke syntaksene nedenfor:

operand1 == operand2; //lik
operand1!= operand2; //ikke lik
operand1> operand2; //større enn
operand1operand1> = operand2; //større enn eller lik
operand1<=operand2; //less than or equal to

Hvordan bruke grunnleggende operatører i Java

Denne delen gir bruk av grunnleggende operatører i Java. Hvert eksempel demonstrerer Java -koden som bruker operatører av en spesifikk kategori.

Eksempel 1: Bruke oppdragsoperatørene

Følgende Java -kode praktiserer forskjellige oppdragsoperatører på variabler.

pakke newpack;
Offentlige klasseoppgaver
public static void main (String [] args)
// Bruke "=" for å tilordne verdier
int a = 3, b = 4, c = 5, d = 6, e = 7;
// bruker "+=" på en
a+= 3;
System.ute.Println ("Nyverdi av A ville være:" +a);
// bruker "-=" på B
B- = 3;
System.ute.println ("Nyverdi av B ville være:" +b);
// bruker "*=" på C
C*= 2;
System.ute.Println ("Nyverdi av C ville være:" +C);
// Bruke "/=" på D
d/= 2;
System.ute.Println ("Nyverdi av D ville være:" +D);
// bruker "%=" på e
E%= 2;
System.ute.Println ("Nyverdi av e ville være:" +e);

Den ovennevnte koden er beskrevet her:

• For det første tildeles verdiene til variabler ved bruk av =
• uttalelsen “a+= 3” legger 3 til gjeldende verdi av en
• trekke 3 fra B ved å bruke “-=”
• Multipliserer verdien av C med 2 ved å bruke “*=”
• deler verdien av d med 2 ved å bruke “/=”
• Verdien av E er delt med 2 og deretter lagres resten som en ny verdi av E.

Utgangen fra koden er gitt nedenfor:

Eksempel 2: Bruke aritmetiske operatører

Følgende Java -kode utfører aritmetiske operasjoner på to tall a = 5 og b = 11.

pakke newpack;
offentlig klasse Arithop
public static void main (String [] args)
// initialisere variabler
int a = 5, b = 11;
// Bruke + på A og B
System.ute.println ("a+b ="+(a+b));
// Bruke - på A og B
System.ute.println ("a-b =" + (a-b));
// Bruke * på A og B
System.ute.println ("a-b =" + (a*b));
// Bruke /på A og B
System.ute.println ("a/b =" + (b/a));
// Bruke % på A og B
System.ute.println ("a%b =" + (a%b));

I den ovennevnte koden blir variablene initialisert først, og deretter representerer hver linje anvendelsen av en annen oppdragsoperatør.

Utgangen er gitt nedenfor:

Eksempel 3: Bruke relasjonelle operatører

Følgende Java -kode praktiserer de relasjonelle operatørene på to variabler x = 3 og y = 5.

pakke newpack;
offentlig klasse Relop
public static void main (String [] args)
// initialisere variabler
int x = 3, y = 5;
//ved hjelp av < operator
System.ute.println ("er x mindre enn y? " + (x operatør
System.ute.println ("er x større enn y? " + (x> y));
// Bruke == operatør
System.ute.println ("er x lik y? " + (x == y));

Den ovennevnte koden implementerer tre relasjonelle operatører på x og y. Videre beskrives koden som:

• initialiserer to variabler x og y
• rapporterer resultatet av x
• skriver ut sanne eller falske resultater for tilstand x> y
• sjekker og skriver ut likheten mellom x og y

Utgangen fra koden er gitt nedenfor:

Eksempel 4: Bruke logiske operatører

Følgende Java-kode praktiserer de logiske operatørene i IF-Else-betinget uttalelse.

pakke newpack;
offentlig klasse Logop
public static void main (String [] args)
int a = 4, b = 5, c = 5;
if (a == b || (b == c && c!= a))

System.ute.Println ("Tilstanden er sann");

ellers

System.ute.println ("Tilstanden er falsk");

Ovennevnte kode er beskrevet som.

• Tre variabler initialiseres
• I IF -tilstand brukte vi og (&&) operatøren mellom b == C og C!= a. Dessuten er denne uttalelsen sammen med A == B ved hjelp av eller (||) operatør.
• Den ovennevnte tilstanden er sann, derfor vil if-block of if-els-uttalelsen bli utført.

Utgangen fra koden vises på bildet nedenfor:

Eksempel 5: Bruke unary -operatører

De unary -operatørene praktiseres i følgende Java -kode.

pakke newpack;
offentlig klasse unop
public static void main (String [] args)
// initialisere variabler
int a = 4, b = 6;
// Bruke unary minus på en
System.ute.println ("Oppdatert verdi av a er:" + (-a));
// ved hjelp av prefiksøkning på B
System.ute.println ("Oppdatert verdi av b er:"+(++ b));

Beskrivelsen av koden er:

• To variabler A og B initialiseres
• skriver ut svaret etter å ha brukt unary minus på en
• viser resultatet etter å ha brukt prefiksøkningsoperatør på B

Utgangen fra koden er gitt her:

Eksempel 6: Bruke bitvis operatører

Følgende Java -kode implementerer flere bitvise operatører på variabler/verdier.

pakke newpack;
offentlig klasse bitop
public static void main (String [] args)
int a = 3, b = 5;
// ved hjelp av bitvis venstre skiftoperatør på en
System.ute.println ("Svaret er:" + (a3));

Koden er beskrevet som:

• A- og B -variabler initialiseres
• Brukte den venstre skiftoperatøren på A og svaret skrives ut. Det binære av nummer 3 vil bli overskrevet av 2 bits.
• skriver ut svaret etter å ha brukt riktig skiftoperatør på B. 3bits fra nummer B ville bli fjernet fra høyre side av binæren på nummer 3.

Utgangen til koden er:

Konklusjon

De grunnleggende operatørene i Java er operatørene som brukes ofte i Java -programmer. Java støtter en lang liste over operatører som hjelper til med å utføre forskjellige operasjoner på variabler/verdier. Operatørene som har like anvendbarhet er plassert i samme kategori. For eksempel kan operatørene som definerer forholdene finnes i den relasjonelle kategorien av operatører. Denne artikkelen viser de grunnleggende operatørene i Java og gir applikasjonen deres ved hjelp av Java -kode. Du ville ha lært oversikten og den foreløpige anvendeligheten av alle grunnleggende operatører i Java.