java operators arithmetic
I denne vejledning lærer du om forskellige Java-operatører - Opgave-, aritmetik-, unary-, ligestillings- og relationelle, betingede, typesammenligning og bitvise & bit-skiftoperatører:
Men inden vi starter med det direkte, lad os kort forstå ordet 'operatører'
Operatører er intet andet end specielle symboler. Formålet med disse symboler er at udføre en bestemt operation på en, to eller tre operander og derefter returnere et resultat. For eksempel, symboler som =,<, & , ^ etc .
Hvad du lærer:
hvordan ser et internetmodem ud
Java-operatører
Lad os nu se de operatører, der understøttes på Java-sprog.
Java understøtter operatører i følgende kategorier:
- Opgaveoperatører
- Aritmetiske operatører
- Unary operatører
- Ligestillings- og relationsoperatører
- Betingede operatører
- Skriv sammenligningsoperatør
- Bitvise og Bit Shift-operatører
# 1) Opgaveoperatører
Vi ser en af de almindeligt forekommende operatører, dvs. simpel tildelingsoperatør ‘=’. Denne operatør tildeler værdien til højre for operanden til venstre.
Lad os se på følgende Java-prøve, der illustrerer brugen af tildelingsoperatører.
public class AssignmentOperatorDemo{ public static void main(String args[]){ int x=300; //Assigns value on the left of ‘=’ i.e. 300 to it’s left i.e. variable x int y=700; //Assigns value on the left of ‘=’ i.e. 700 to it’s left i.e. variable y int z = 0; //Assigns value on the left of ‘=’ i.e. 0 to it’s left i.e. variable z z = x+y; //Assigns value on the left of ‘=’ i.e. (x+y) i.e. 300+700=1000 to it’s left i.e. variable z System.out.println(x); //This prints output as 300 System.out.println(y); //This prints output as 700 System.out.println(z); //This prints output as 1000 } }
Dette program udskriver følgende output:
Denne operator kan også bruges på objekter til at tildele objektreferencer.
For eksempel, Bilbil1 = ny bil (); // ‘=’ tildeler ny bil () objektforekomst til objektreference bil1.
# 2) Aritmetiske operatører
For at udføre aritmetiske operationer som addition, subtraktion, multiplikation og division er disse identiske med grundlæggende matematik. Det eneste forskellige symbol er “%”, som er operatoren Modulus eller Resten, og formålet med denne operand er at dele en operand med en anden og returnere resten som resultatet.
Følgende er de aritmetiske operatører, der understøttes i Java:
Operatør | Beskrivelse |
---|---|
| | Bitvis inklusive ELLER |
+ | Additive Operator (også brugt til strengkombination) |
- | Subtraktionsoperatør |
* | Multiplikationsoperatør |
/ | Division Operatør |
% | Modulus eller restoperator |
Nedenfor er en JAVA-prøve, der illustrerer brugen af aritmetiske operatorer:
public class ArithmeticOperatorDemo { public static void main (String[] args) { int x = 30; int y = 20; int result_value = x + y; System.out.println('30 + 20 = ' + result_value); // This prints o/p 50 result_value = x - y; System.out.println('30 - 20 = ' + result_value);// This prints o/p 10 result_value = x * y; System.out.println('30 * 20 = ' + result_value);// This prints o/p 600 result_value = x / y; System.out.println('30 / 20 = ' + result_value);// This prints o/p 1 result_value = x % y; // Returns remainder of division 30/20 i.e. 10 System.out.println('30 % 20 = ' + result_value);// This prints o/p 10 } }
Dette program udskriver følgende output:
# 3) Unære operatører
Unary Operators er de operatører, der har brug for en enkelt operand.
For eksempel, operationer som at øge / mindske en værdi med en, negere et udtryk eller invertere en boolesk værdi.
Følgende er de Unary Operators understøttet i Java:
Operatør | Beskrivelse |
---|---|
+ | Unary plus operatør; angiver positiv værdi (tal er dog positive uden dette) |
- | Unary minus operatør; negerer et udtryk |
++ | Forøgelsesoperatør; forøger en værdi med 1 |
- | Nedskrivningsoperatør; reducerer en værdi med 1 |
! | Logisk supplement Operatør; inverterer værdien af en boolsk |
Nedenfor er en Java-prøve, der illustrerer brugen af Unary Operators:
public class UnaryOperatorDemo { public static void main(String[] args) { int result_value = +10;// indicated positive value 10 System.out.println(result_value); //o/p is 10 result_value --; // decrements the value of 10 by 1 System.out.println(result_value); //o/p is 9 result_value ++; // increaments the value of 9 by 1 System.out.println(result_value); //o/p is 10 result_value = - result_value;// this minus operator negates an expression System.out.println(result_value); //o/p is -10 booleanisPass = false; System.out.println(isPass); //o/p is false System.out.println(!isPass);//o/p is inverted isPass value i.e. true } }
Dette program udskriver følgende output:
Increment / decrement-operatorerne kan bruges før (præfiks) eller efter (postfix) operanden. Selvom begge værdier returnerer den oprindelige værdi, der øges / dekrementeres af en. Forskellen er, at præfiksoperatoren evaluerer operanden til den inkrementerede værdi, mens postfix-versionen evaluerer operanden til den oprindelige værdi.
Lad os se på følgende PreAndPostDemo, der illustrerer prefix og postfix-funktionalitet .
public class PreAndPostDemo { public static void main(String[] args){ int a = 5; System.out.println(a++); // output is 5 System.out.println(a); // output is 6 System.out.println(++a); // output is 7 System.out.println(a++); // output is 7 System.out.println(a); // output is 8 } }
Dette program udskriver følgende output:
# 4) Ligestillings- og relationsoperatører
Ligheds- og relationelle operatører er operatører, der skal sammenligne og bestemme, om en operand er større end, mindre end, lig med eller ikke lig med en anden operand.
Følgende er de ligestillings- og relationsoperatører, der understøttes i Java:
Operatør | Beskrivelse |
---|---|
== | Svarende til |
! = | Ikke lig med |
> | Bedre end |
> = | Større end eller lig med |
< | Mindre end |
<= | Mindre end eller lig med |
Se følgende Java-prøve, der illustrerer brugen af Relational Operators:
public class RelationalOperatorDemo { public static void main(String[] args){ int a = 5; int b = 10; boolean resultFlag = (a == b); System.out.println('a == b :'+ resultFlag);//o/p is false as 5 is not equal to 10 resultFlag = (a != b); System.out.println('a != b :'+ resultFlag); //o/p is true as 5 is not equal to 10 resultFlag = (a > b); System.out.println('a >b :'+ resultFlag); //o/p is false as 5 is not greater than 10 resultFlag = (a = b); System.out.println('a >= b:'+ resultFlag); //o/p is false as 5 neither greater than 10 nor equal to 10 } }
Dette program udskriver følgende output:
# 5) Betingede operatører
Java understøtter betingede operatører, || og && til at udføre Conditional-OR og Conditional-AND-operationer på to boolske operander. Denne adfærd kaldes også som 'kortslutnings' -adfærd. I denne adfærd finder den anden operandevaluering kun sted, hvis det kræves.
En anden betinget operatør, der understøttes, er den ternære operator '?:', Der kaldes stenografi for en if-then-else-sætning.
Operatør | Beskrivelse |
---|---|
&& | Betinget-OG |
|| | Betinget-ELLER |
?: | Ternary (stenografi for hvis-så-ellers udsagn) |
Nedenfor er en Java-prøve, der illustrerer brugen af betingede operatører:
public class ConditionalOperatorDemo { public static void main(String[] args) int a = 5; int b = 10; boolean resultFlag = ((a == 5) && (b == 10)); //o/p is true as both conditions are evaluated true System.out.println('a is 5 AND b is 10 :'+resultFlag); resultFlag = ((a == 5) }
Dette program udskriver følgende output:
# 6) Skriv sammenligningsoperatør
Operatør | Beskrivelse |
---|---|
forekomst af | Sammenligner et objekt med en bestemt type |
Formålet med forekomsten af en operatør er at sammenligne et objekt med en bestemt type. Dette kan bruges til at teste, om et objekt er en forekomst af en klasse, en underklasse eller en klasse, der implementerer en bestemt grænseflade.
Lad os se på følgende Java-prøve, der illustrerer brugen af sammenligningsoperatører:
publicclass Shape {} public class Square extends Shape implements Area {} public interface Area {} publicclassInstanceofOperatorDemo { publicstaticvoidmain(String[] args) { Shape shape1 = newShape(); Shape shape2 = newSquare(); System.out.println('shape1 instanceof Shape: ' + (shape1 instanceof Shape)); System.out.println('shape1 instanceof Square: ' + (shape1 instanceof Square)); System.out.println('shape1 instanceof Area:' + (shape1 instanceof Area)); System.out.println('shape2 instanceof Shape: ' + (shape2 instanceof Shape)); System.out.println('shape2 instanceof Square: ' + (shape2 instanceof Square)); System.out.println('shape2 instanceof Area: ' + (shape2 instanceof Area)); } }
Dette program udskriver følgende output:
# 7) Bitvise og bitforskydningsoperatører
Java understøtter også operatører til at udføre Bitwise- og Bit shift-operationer på en hvilken som helst af heltalstyperne, dvs. lang, int, kort, char og byte.
Følgende er de understøttede Bitwise- og Bit shift-operatører:
Operatør | Beskrivelse |
---|---|
~ | Unary bitvis supplement |
<< | Underskrevet venstre skift |
>> | Signeret højre skift |
>>> | Usigneret højre skift |
& | Bitvis OG |
^ | Bitvis eksklusiv ELLER |
Lad os se på følgende Java-prøve, der illustrerer brugen af Bitwise-operatører:
public class BitwiseOperatorDemo { public static void main(String[] args) 0110 = 0111 = 7 System.out.println('x }
Dette program udskriver følgende output:
Java-operatørpræference
Indtil videre har vi undersøgt de operatører, der understøttes i Java. Lad os nu se på disse operatørers forrang. Operatørerne er anført efter deres forrang i faldende rækkefølge i følgende tabel. Postfix har den højeste prioritet og opgave er den laveste prioritetsoperatør.
Betydning af forrang: Evaluering af operatører finder sted efter operatørens forrang, dvs. evaluering finder sted startende med operatørerne med højere prioritet og efterfølges af operatører, der har relativt lavere forrang.
Alle binære operatører evalueres fra venstre mod højre, og den eneste undtagelse er tildelingsoperatører. I tilfælde af tildelingsoperatører finder operatørens evaluering sted fra højre mod venstre.
Operatørens forrang | ||
---|---|---|
Relationel | = forekomst af | Venstre til højre |
Operatører | Operatørernes forrang | Associativitet |
Postfix | udtryk ++ udtryk-- | Venstre til højre |
Unary | ++ expr --expr + expr -expr ~! | Højre til venstre |
Multiplikativ | * /% | Venstre til højre |
Tilsætningsstof | + - | Venstre til højre |
Flytte | <>>>> | Venstre til højre |
Lighed | ==! = | Venstre til højre |
Bitvis OG | & | Venstre til højre |
Bitvis eksklusiv ELLER | ^ | Venstre til højre |
Bitvis inklusive ELLER | | | Venstre til højre |
logisk OG | && | Venstre til højre |
logisk ELLER | || | Venstre til højre |
Ternær | ? : | Højre til venstre |
Opgave | = + = - = * = / =% = & = ^ = | =<>= >>> = | Højre til venstre |
Ofte stillede spørgsmål og svar
Q # 1) Hvad er de operatører, der bruges i Java?
Svar: Operatører i Java er specielle symboler. Formålet med disse symboler er at udføre specifikke operationer på en, to eller tre operander og returnere et resultat.
For eksempel, symboler som =,<, & , ^ etc .
Q # 2) Hvad er === Operatør i Java?
Svar: === operatør kaldes en streng ligestillingsoperatør i Javascript . Denne operator returnerer true, hvis begge variabler er af samme type og også indeholder den samme værdi.
For eksempel 1 === ”1 ″ // Dette vender tilbage falsk . Dette skyldes, at begge operander ikke er af samme type.
== operatør i Javascript sammenligner to variabler af forskellige typer ved automatisk at konvertere en type til en anden.
For eksempel 1 == ”1 ″ Dette vil blive sandt. Her bliver strengen konverteret til antal, og sammenligning finder sted.
Q # 3) Hvad er Java Assignment Operator?
gratis video downloadere til Windows 10
Svar: Java-tildelingsoperatør, dvs. '=' operatoren tildeler værdien til højre for operanden til venstre.
For eksempel, int x = 300; Her ' = 'Tildeler værdi 300 til variabel x
Q # 4) Hvad er == i Java?
Svar: == operator i Java bruges til at sammenligne reference, dvs. denne operator verificerer, om begge objekter peger på den samme hukommelsesplacering
Dette adskiller sig i .equals () der sammenligner værdierne i objekterne.
For eksempel,
Streng str1 = ny streng (“God morgen”);
Streng str2 = ny streng (“God morgen”);
System.out.println (str1 == str2); // Dette returnerer falsk, da dette sammenligner adresser, dvs. hukommelsesplaceringer for to objekter
System.out.println (str1.equals (str2)); // Dette returnerer sandt, når det sammenligner værdi.
Spørgsmål nr. 5) Hvor mange typer operatører er der i Java?
Svar: Nedenfor er de forskellige typer operatører i Java:
- Opdragsoperatør
- Aritmetiske operatører
- Unary operatører
- Ligestillings- og relationsoperatører
- Betingede operatører
- Skriv sammenligningsoperatør
- Bitvise og Bit Shift-operatører
Q # 6) Hvad er brugen af Dot Operator i Java?
Svar: Punktoperatoren eller separatoren eller perioden i Java bruges til at adskille en variabel, dvs. metoden, fra en objektreferencevariabel.
For eksempel, Bilbil1 = ny bil ();
car1.name = “Audi”; // Her bruges '.' Til at få adgang til feltet 'navn' på bilobjektreference 'car1'
Q # 7) Hvad er de 3 logiske operatører?
Svar: Logiske operatører opererer på den boolske operand.
Følgende er de logiske operatører:
- &&: Logisk OG
- || : Logisk ELLER
- ! : Logisk Ikke
Q # 8) Hvad er bitvise operatører i Java?
Svar: Java understøtter operatører til at udføre bitvise og bitforskydningsoperationer på en hvilken som helst af heltalstyperne, dvs. lang, int, kort, char og byte.
Følgende er de understøttede Bitwise- og Bit shift-operatører:
Operatør | Beskrivelse |
---|---|
| | Bitvis inklusive ELLER |
~ | Unary bitvis supplement |
<< | Underskrevet venstre skift |
>> | Signeret højre skift |
>>> | Usigneret højre skift |
& | Bitvis OG |
^ | Bitvis eksklusiv ELLER |
Konklusion
I denne vejledning har vi udforsket de forskellige typer operatører, der understøttes i Java sammen med deres formål.
Kort sagt inkluderer Java-operatørerne:
- Opdragsoperatør
- Aritmetiske operatører
- Unary operatører
- Ligestillings- og relationsoperatører
- Betingede operatører
- Skriv sammenligningsoperatør
- Bitvise og Bit Shift-operatører
Vi så også, hvordan disse operatører bruges i Java-koden ved hjælp af nogle eksempler, der illustrerer brugen af disse operatører. Selvom vi har set alle typer operatører, kan brugen af disse operatører til generel programmering til tider variere.
Nogle af operatørerne vises normalt oftere end de andre, da tildelingsoperatøren “=” er meget meget almindeligt brugt i kode end den usignerede højre skiftoperatør “>>>
Vi vil se hver af disse operatørkategorier i detaljer i vores kommende tutorials.
Anbefalet læsning
- Unix Shell Script Aritmetiske og Boolske operatøreksempler
- Java-implementering: Oprettelse og udførelse af Java JAR-fil
- Java Virtual Machine: Hvordan JVM hjælper med at køre Java-applikationer
- Python-operatører
- Adgang modifikatorer i Java - vejledning med eksempler
- Java Reflection Tutorial med eksempler
- Introduktion til Java-programmeringssprog - Videovejledning
- JAVA-vejledning til begyndere: 100+ praktiske Java-videovejledninger