Unary -operatører i Java | Forklart

Java støtter forskjellige kategorier av operatører som aritmetikk, relasjonell, unary osv. Unary -operatørene opptrer annerledes enn andre operatører, da de bare krever en operand for å utføre en spesifikk operasjon. De unary -operatørene brukes til å endre tegnet på operanden, øke/redusere en operand eller reversere en boolsk verdi. Denne guiden til Unary -operatører ville tjene følgende læringsresultater:

• Å bli oppmerksom på å jobbe med unary -operatører
• bruker flere unary -operatører i Java

Hvor unary operatører jobber i java

Syntaksen til hver unary -operatør støttet av Java er definert her som vil hjelpe deg med å få den grunnleggende arbeidsstrømmen til Unary -operatører.

Pluss (+): Denne operatøren praktiseres for å representere positiv operand. Følgende syntaks følges for å bruke dette:

+operand;

Minus(-): Denne operatøren endrer tegnet på en operand og brukes ved å følge syntaksen nedenfor:

-operand;

Økning (++): Denne unary -operatøren legger 1 til operanden ved å prefiksere eller legge ut fiksen “++”Til operanden. Følgende syntaks refererer til postfix og prefiksøkning:

++operand; // Prefiksøkning
operand ++; // Postfix økning

Decrement (-): Unary Decrement trekker 1 fra gjeldende verdi på variabelen/verdien. Det kan brukes ved å prefiksere eller legge ut "-" til en operand. Syntaksen gitt nedenfor brukes til Unary Decrement:

--operand; // prefiks redusering
operand--; // Postfix Decrement

Merk: Hvis en variabel er assosiert med postfix som betyr at variabelen først vil bli brukt til databehandling, og deretter vil verdien bli økt/dekrementert. Mens prefikset øker/reduserer verdien før beregning.

Logisk komplement (!): Denne operatøren er aktuelt på boolske verdier og endrer dem fra sann til falsk og omvendt. Syntaksen gitt nedenfor følges for dette:

!operand;

Hvordan bruke Unary -operatørene i Java

Denne delen gir flere Java -eksempler som viser bruken av unary -operatører i Java.

Bruker Unary Plus: Unary Plus gjør ikke en endring av verdien ettersom det positive tegnet er valgfritt, og det vises dermed ikke noe sted etter tildeling. Følgende Java -kode erklærer en variabel a med +5, men når den brukes etter det er det positive tegnet unntatt.

pakke newpack;
offentlig klasse unop
public static void main (String [] args)
int a =+5;
System.ute.println (a);

Utgangen viser at det positive tegnet er unntatt når en er trykt.

Bruker unary minus: Java -koden gitt nedenfor praktiserer det unary minus på både positive og negative verdier.

pakke newpack;
offentlig klasse unop
public static void main (String [] args)
int a = 5, b = -6;
// Bruke unary minus på en
a =-(a);
System.ute.println (a);
// Bruke unary minus på B
b =-(b);
System.ute.println (b);

Koden er beskrevet nedenfor:

• initialiserer en som positivt og b som en negativ verdi
• Brukte unary minus på en og oppdater en
• skriver ut den nye verdien av en
• Brukte unary minus på b og oppdater verdien av b
• skriver ut den nye verdien av b

Utgangen fra koden er gitt nedenfor:

Ved hjelp av prefiks og postfix -økning: Prefikset og postfix -økningen Operatører øker verdien med 1. Men prefikset og postfikset brukes i henhold til deres krav, ettersom prefikset øker før utførelsen og postfikset øker verdien etter utførelse av variabelen.

For å vise bruken av postfix og prefiksøkning blir følgende linjer med Java -kode utført:

pakke newpack;
offentlig klasse unop
public static void main (String [] args)
int x = 99, y = 9;
// ved hjelp av unary prefiksøkning på x
++x;
System.ute.println (x);
// ved hjelp av unary postfix økning på y
y ++;
System.ute.println (y);

Koden er beskrevet som:

• Initialiserer to variabler x og y
• Anvendt prefiksøkning på x
• skriver ut verdien etter økningen
• Bruke postfix økning på y
• skriver ut den økte verdien av y

Utgangen fra koden er gitt nedenfor:

Ved hjelp av prefiks og postfix reduksjon: Begrepet dekrement er det samme som økning, men det reduserer verdien med 1. Koden gitt nedenfor reduserer verdien av variabler ved prefiksing/postfiksing -:

pakke newpack;
offentlig klasse unop
public static void main (String [] args)
int a = 20, b = 10;
// ved hjelp av unary prefiks dekrement på en
--en;
System.ute.println (a);
// ved hjelp av unary postfix reduksjon på b
b--;
System.ute.println (b);

Ovennevnte kode,

• erklærer først to variabler en og b
• ved hjelp av prefiks reduksjon og skriv ut ny verdi av en
• Ved hjelp av Postfix Decrement og viser den oppdaterte verdien av b

Utgangen fra koden er gitt nedenfor:

Bruke logikkkomplement: Logikkkomplementoperatøren reverserer rekkefølgen på en boolsk verdi. Følgende Java -kode utøver den boolske falske til True og omvendt:

pakke newpack;
offentlig klasse unop
public static void main (String [] args)
// erklære en boolsk variabel
boolsk bool1 = true, bool2 = falsk;
// ved hjelp av logikkkomplementoperatør på BOOL1
bool1 =!bool1;
System.ute.println (bool1);
// ved hjelp av logikkkomplementoperatør på BOOL2
bool2 =!bool2;
System.ute.Println (BOOL2);

Koden er beskrevet nedenfor:

• erklærer to boolske variabler bool1 og bool2
• gjelder “!”Operatør på bool1 og oppdaterer verdien av bool1
• gjelder “!”Operatør på bool2 og oppdaterer verdien av BOOL2

Utgangen til koden vises nedenfor:

Konklusjon

De unary -operatørene lar deg endre skiltet, utføre en økning/reduksjon eller endre den boolske verdien (True/False). Denne artikkelen gir arbeid og bruk av Unary -operatører i Java. Du ville ha lært den grunnleggende syntaksen til alle Unary -operatørene. For bedre forståelse utøves de unary -operatørene ved å bruke eksempler på Java -kode.