java operators arithmetic
com obrir un fitxer .dat
En aquest tutorial, aprendreu sobre diversos operadors Java: assignació, aritmètica, unitat, igualtat i relació, condicional, comparació de tipus i operadors de bits i de canvis de bits:
Però abans de començar directament, entenguem breument el terme 'Operadors'
Els operadors no són res més que símbols especials. El propòsit d’aquests símbols és realitzar una operació específica en un, dos o tres operands i després retornar un resultat. Per exemple, símbols com =,<, & , ^ etc .
Què aprendreu:
Operadors Java
Vegem ara els operadors compatibles amb el llenguatge Java.
Java admet operadors de les categories següents:
- Operadors de tasques
- Operadors aritmètics
- Operaris unaris
- Igualtat i operadors relacionals
- Operadors condicionals
- Operador de comparació de tipus
- Operadors Bitwise i Bit Shift
# 1) Operadors de tasques
Veurem un dels operadors més freqüents, és a dir, l’operador d’assignació simple ‘=’. Aquest operador assigna el valor de la seva dreta a l’operand de la seva esquerra.
Vegem el següent exemple de Java que il·lustra l’ús dels operadors de tasques.
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 } } Aquest programa imprimeix la següent sortida:
Aquest operador també es pot utilitzar en objectes per assignar referències d'objectes.
Per exemple, Cotxe cotxe1 = cotxe nou (); // ‘=’ assigna una nova instància d’objecte Car () a la referència d’objecte car1.
# 2) Operadors aritmètics
Per realitzar operacions aritmètiques com la suma, la resta, la multiplicació i la divisió, aquestes són idèntiques a les matemàtiques bàsiques. L'únic símbol diferent és '%', que és l'operador Mòdul o Resta i el propòsit d'aquest operand és dividir un operand per un altre i retornar la resta com a resultat.
A continuació es detallen els operadors aritmètics compatibles amb Java:
| Operador | Descripció |
|---|---|
| | | OR a bit inclòs |
| + | Operador additiu (també s'utilitza per a la concatenació de cadenes) |
| - | Operador de restes |
| * | Operador de multiplicació |
| / | Operador de divisió |
| % | Operador de mòdul o resta |
A continuació es mostra una mostra JAVA que il·lustra l’ús d’operadors aritmètics:
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 } } Aquest programa imprimeix la següent sortida:
# 3) Operadors unaris
Els operadors unaris són els operadors que necessiten un únic operant.
Per exemple, operacions com augmentar / disminuir un valor per un, negar una expressió o invertir el valor d'un booleà.
A continuació es detallen els operadors unaris compatibles amb Java:
| Operador | Descripció |
|---|---|
| + | Unari més Operador; indica un valor positiu (els números són positius sense això, però) |
| - | Operari unari menys; nega una expressió |
| ++ | Operador d’increments; augmenta un valor en 1 |
| - | Operador de decrement; disminueix un valor en 1 |
| ! | Operador de complement lògic; inverteix el valor d'un booleà |
A continuació es mostra un exemple de Java que il·lustra l’ús d’operadors unaris:
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 } } Aquest programa imprimeix la següent sortida:
Els operadors d'increment / decrement es poden utilitzar abans (prefix) o després (postfix) de l'operant. Tot i que tots dos valors retornaran el valor original incrementant-se / disminuint-ne un. La diferència és que l’operador del prefix avalua l’operand fins al valor incrementat, mentre que la versió postfix avalua l’operand fins al valor original.
Vegem el següent PreAndPostDemo que il·lustra el funcionalitat de prefix i postfix .
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 } } Aquest programa imprimeix la següent sortida:
# 4) Igualtat i operadors relacionals
Els operadors relacionals i d’igualtat són els operadors que han de comparar i determinar si un operand és superior a, menor que, igual o no igual a un altre operand.
A continuació es detallen els operadors relacionals i d’igualtat compatibles amb Java:
| Operador | Descripció |
|---|---|
| == | Igual a |
| ! = | No és igual a |
| > | Més gran que |
| > = | Superior o igual a |
| < | Menys que |
| <= | Menys o igual a |
Vegeu el següent exemple de Java que il·lustra l’ús d’operadors relacionals:
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 } } Aquest programa imprimeix la següent sortida:
# 5) Operadors condicionals
Java admet operadors condicionals, || i && per realitzar operacions Conditional-OR i Conditional-AND en dos operands booleans. Aquest comportament també s’anomena comportament de “curtcircuit”. En aquest comportament, la segona avaluació de l'operand només es realitza si es requereix.
Un altre operador condicional admès és l’operador ternari ‘?:’ Que s’anomena abreujat per a una sentència if-then-else.
| Operador | Descripció |
|---|---|
| && | Condicional-I |
| || | Condicional-OR |
| ?: | Ternary (abreviatura de declaració if-then-else) |
A continuació es mostra un exemple de Java que il·lustra l’ús d’operadors condicionals:
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) } Aquest programa imprimeix la següent sortida:
# 6) Operador de comparació de tipus
| Operador | Descripció |
|---|---|
| en lloc de | Compara un objecte amb un tipus especificat |
El propòsit de la instància d'un operador és comparar un objecte amb un tipus especificat. Es pot utilitzar per comprovar si un objecte és una instància d'una classe, una subclasse o una classe que implementa una interfície particular.
Vegem el següent exemple de Java que il·lustra l’ús d’operadors de comparació:
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)); } } Aquest programa imprimeix la següent sortida:
# 7) Operadors de bits i de canvis de bits
Java també admet operadors per realitzar operacions de bit i bit shift en qualsevol dels tipus enters, és a dir, long, int, short, char i byte.
A continuació es detallen els operadors de bits i de canvis de bits compatibles:
| Operador | Descripció |
|---|---|
| ~ | Complement bitari unari |
| << | Signat al torn esquerre |
| >> | Torn signat a la dreta signat |
| >>> | Torn a la dreta sense signar |
| & | A bit a bit I |
| ^ | OR exclusiu per bits |
Vegem el següent exemple de Java que il·lustra l’ús d’operadors bitwise:
public class BitwiseOperatorDemo { public static void main(String() args) 0110 = 0111 = 7 System.out.println('x }Aquest programa imprimeix la següent sortida:
Precedència de l'operador Java
Fins ara hem explorat els operadors compatibles amb Java. Vegem ara la precedència d’aquests operadors. Els operadors es mostren segons la seva precedència en ordre descendent a la taula següent. Postfix té la màxima precedència i assignació és l'operador de precedència més baixa.
Importància de la precedència: L’avaluació dels operadors es realitza segons la precedència de l’operador, és a dir, l’avaluació es fa a partir dels operadors de precedència superior i la segueixen els operadors amb precedència relativament inferior.
Tots els operadors binaris s’avaluen d’esquerra a dreta i l’única excepció són els operadors d’assignació. En el cas dels operadors de tasques, l’avaluació de l’operador es fa de dreta a esquerra.
| Precedència de l'operador | ||
|---|---|---|
| Relacional | = instanceof | Esquerra a dreta |
| Operadors | Precedència dels operadors | Associativitat |
| Postfix | expr ++ expr-- | Esquerra a dreta |
| Unari | ++ expr --expr + expr -expr ~! | De dreta a esquerra |
| Multiplicatiu | * /% | Esquerra a dreta |
| Additiu | + - | Esquerra a dreta |
| Maj | <>>>> | Esquerra a dreta |
| Igualtat | ==! = | Esquerra a dreta |
| A bit a bit I | & | Esquerra a dreta |
| OR exclusiu per bits | ^ | Esquerra a dreta |
| OR a bit inclòs | | | Esquerra a dreta |
| lògic I | && | Esquerra a dreta |
| OR lògic | || | Esquerra a dreta |
| Ternari | ? : | De dreta a esquerra |
| Tasca | = + = - = * = / =% = & = ^ = | =<>= >>> = | De dreta a esquerra |
Preguntes i respostes freqüents
P # 1) Quins són els operadors que s'utilitzen a Java?
Respostes: Els operadors de Java són símbols especials. L’objectiu d’aquests símbols és realitzar operacions específiques en un, dos o tres operands i retornar un resultat.
Per exemple, símbols com =,<, & , ^ etc .
Q # 2) Què és === Operador a Java?
Respostes: === L'operador es diu un operador d'igualtat estricte a Javascript . Aquest operador torna cert si ambdues variables són del mateix tipus i també contenen el mateix valor.
Per exemple, 1 === '1' // Això tornarà fals . Això es deu al fet que tots dos operands no són del mateix tipus.
== operador a Javascript compara dues variables de diferents tipus convertint automàticament un tipus a un altre.
Per exemple, 1 == '1' Això tornarà a ser cert. Aquí, la cadena es converteix en número i es fa la comparació.
P # 3) Què és Java Assignment Operator?
fabricant de diagrames de flux gratuïts per a mac
Respostes: Operador d’assignació de Java, és a dir, l’operador ‘=’ assigna el valor de la seva dreta a l’operand de la seva esquerra.
Per exemple, int x = 300; Aquí ‘ = ’Assigna valor 300 a variable x
Q # 4) Què és == a Java?
Respostes: L'operador == a Java s'utilitza per comparar la referència, és a dir, aquest operador verifica si tots dos objectes apunten a la mateixa ubicació de memòria
Això difereix en .equals () que fa la comparació de valors en els objectes.
Per exemple,
String str1 = new String ('Bon dia');
String str2 = new String ('Bon dia');
System.out.println (str1 == str2); // Això torna fals ja que compara adreces, és a dir, ubicacions de memòria de dos objectes
System.out.println (str1.equals (str2)); // Això torna com a veritable en comparar el valor.
P # 5) Quants tipus d'operadors hi ha a Java?
Respostes: A continuació es detallen els diversos tipus d'operadors de Java:
- Operador de tasques
- Operadors aritmètics
- Operaris unaris
- Igualtat i operadors relacionals
- Operadors condicionals
- Operador de comparació de tipus
- Operadors Bitwise i Bit Shift
P # 6) Quin ús fa de Dot Operator a Java?
Respostes: L'operador de punts o el separador o punt a Java s'utilitza per separar una variable, és a dir, el mètode d'una variable de referència d'objecte.
Per exemple, Cotxe cotxe1 = cotxe nou ();
car1.name = 'Audi'; // Aquí ‘.’ S’utilitza per accedir al camp ‘nom’ de la referència d’objecte de cotxe ‘cotxe1’
Q # 7) Quins són els 3 operadors lògics?
Respostes: Els operadors lògics operen a l’operand booleà.
A continuació es detallen els operadors lògics:
- &&: AND lògic
- || : OR lògic
- ! : Lògic No
Q # 8) Què són els operadors de bits a Java?
Respostes: Java admet operadors per realitzar operacions de bits i desplaçament de bits en qualsevol dels tipus enters, és a dir, long, int, short, char i byte.
A continuació es mostren els operadors de bits i de canvis de bits compatibles:
| Operador | Descripció |
|---|---|
| | | OR a bit inclòs |
| ~ | Complement bitari unari |
| << | Signat al torn esquerre |
| >> | Torn signat a la dreta signat |
| >>> | Torn a la dreta sense signar |
| & | A bit a bit I |
| ^ | OR exclusiu per bits |
Conclusió
En aquest tutorial, hem explorat els diferents tipus d'operadors compatibles amb Java juntament amb el seu propòsit.
En poques paraules, els operadors Java inclouen:
- Operador de tasques
- Operadors aritmètics
- Operaris unaris
- Igualtat i operadors relacionals
- Operadors condicionals
- Operador de comparació de tipus
- Operadors Bitwise i Bit Shift
També vam veure com s’utilitzen aquests operadors al codi Java amb l’ajut d’alguns exemples que il·lustren l’ús d’aquests operadors. Tot i que hem vist tots els tipus d'operadors, l'ús d'aquests operadors a la programació d'ús general pot variar de vegades.
Alguns dels operadors solen aparèixer amb més freqüència que els altres, com que l’operador d’assignació “=” s’utilitza molt més sovint en codi que l’operador de desplaçament a la dreta sense signar
Veurem cadascuna d’aquestes categories d’operadors amb detall als nostres propers tutorials.
Lectura recomanada
- Exemples d'operadors aritmètics i booleans d'escriptura Shell Unix
- Desplegament de Java: creació i execució del fitxer JAR de Java
- Màquina virtual Java: com ajuda JVM a executar aplicacions Java
- Operadors de Python
- Modificadors d'accés a Java: tutorial amb exemples
- Tutorial de reflexió de Java amb exemples
- Introducció al llenguatge de programació Java: vídeo tutorial
- Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java