java operators arithmetic
Dans ce didacticiel, vous découvrirez les différents opérateurs Java - les opérateurs d'attribution, d'arithmétique, unaire, d'égalité et relationnel, conditionnel, de comparaison de type et de décalage de bits et de bits:
Mais avant de commencer directement, comprenons brièvement le terme 'opérateurs'
Les opérateurs ne sont que des symboles spéciaux. Le but de ces symboles est d'effectuer une opération spécifique sur un, deux ou trois opérandes, puis de renvoyer un résultat. Par exemple, symboles comme =,<, & , ^ etc .
Ce que vous apprendrez:
Opérateurs Java
Voyons maintenant les opérateurs pris en charge en langage Java.
Java prend en charge les opérateurs des catégories suivantes:
- Opérateurs d'affectation
- Opérateurs arithmétiques
- Opérateurs unaires
- Égalité et opérateurs relationnels
- Opérateurs conditionnels
- Opérateur de comparaison de types
- Opérateurs de décalage de bits et de bits
# 1) Opérateurs d'affectation
Nous verrons l’un des opérateurs les plus courants, à savoir l’opérateur d’affectation simple ‘=’. Cet opérateur affecte la valeur à sa droite à l'opérande à sa gauche.
Examinons l'exemple Java suivant qui illustre l'utilisation des opérateurs d'affectation.
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 } } Ce programme imprime la sortie suivante:
Cet opérateur peut également être utilisé sur des objets pour affecter des références d'objets.
Par exemple, Voiture car1 = nouvelle voiture (); // ‘=’ attribue une nouvelle instance d’objet Car () à la référence d’objet car1.
# 2) Opérateurs arithmétiques
Pour effectuer des opérations arithmétiques comme l'addition, la soustraction, la multiplication et la division, celles-ci sont identiques à celles des mathématiques de base. Le seul symbole différent est «%», qui est l'opérateur Module ou Reste et le but de cet opérande est de diviser un opérande par un autre et de renvoyer le reste comme résultat.
Voici les opérateurs arithmétiques pris en charge en Java:
| Opérateur | La description |
|---|---|
| | | OU inclusif au niveau du bit |
| + | Opérateur additif (également utilisé pour la concaténation de chaînes) |
| - | Opérateur de soustraction |
| * | Opérateur de multiplication |
| / | Opérateur de division |
| % | Opérateur de module ou de reste |
Vous trouverez ci-dessous un exemple JAVA illustrant l'utilisation d'opérateurs arithmétiques:
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 } } Ce programme imprime la sortie suivante:
# 3) Opérateurs unaires
Les opérateurs unaires sont les opérateurs qui ont besoin d'un seul opérande.
Par exemple, des opérations telles que l'incrémentation / décrémentation d'une valeur de un, la négation d'une expression ou l'inversion de la valeur d'un booléen.
Voici les opérateurs unaires pris en charge en Java:
| Opérateur | La description |
|---|---|
| + | Opérateur unaire plus; indique une valeur positive (les nombres sont positifs sans cela, cependant) |
| - | Opérateur moins unaire; nie une expression |
| ++ | Opérateur d'incrément; incrémente une valeur de 1 |
| - | Opérateur de décrémentation; décrémente une valeur de 1 |
| ! | Opérateur du complément logique; inverse la valeur d'un booléen |
Ci-dessous, un exemple Java illustrant l'utilisation des opérateurs unaires:
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 } } Ce programme imprime la sortie suivante:
Les opérateurs d'incrémentation / décrémentation peuvent être utilisés avant (préfixe) ou après (suffixe) l'opérande. Même si les deux valeurs renverront la valeur d'origine incrémentée / décrémentée de un. La différence est que l'opérateur de préfixe évalue l'opérande à la valeur incrémentée, tandis que la version postfixe évalue l'opérande à la valeur d'origine.
Jetons un œil au PreAndPostDemo suivant illustrant fonctionnalité de préfixe et de suffixe .
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 } } Ce programme imprime la sortie suivante:
# 4) Égalité et opérateurs relationnels
Les opérateurs d'égalité et relationnels sont les opérateurs à comparer et à déterminer si un opérande est supérieur, inférieur, égal à ou non égal à un autre opérande.
Voici les opérateurs d'égalité et relationnels pris en charge en Java:
| Opérateur | La description |
|---|---|
| == | Égal à |
| ! = | Pas égal à |
| > | Plus grand que |
| > = | Plus grand ou égal à |
| < | Moins que |
| <= | Inférieur ou égal à |
Consultez l'exemple Java suivant illustrant l'utilisation des opérateurs relationnels:
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 } } Ce programme imprime la sortie suivante:
# 5) Opérateurs conditionnels
Java prend en charge les opérateurs conditionnels, || et && pour effectuer des opérations OR conditionnelles et ET conditionnelles sur deux opérandes booléens. Ce comportement est également appelé comportement de «court-circuit». Dans ce comportement, la deuxième évaluation d'opérande a lieu uniquement si nécessaire.
Un autre opérateur conditionnel pris en charge est l’opérateur ternaire ‘?:’ Qui est appelé comme raccourci pour une instruction if-then-else.
| Opérateur | La description |
|---|---|
| && | Conditionnel-AND |
| || | Conditionnel-OR |
| ?: | Ternaire (raccourci pour instruction if-then-else) |
Vous trouverez ci-dessous un exemple Java illustrant l'utilisation des opérateurs conditionnels:
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) } Ce programme imprime la sortie suivante:
# 6) Opérateur de comparaison de types
| Opérateur | La description |
|---|---|
| exemple de | Compare un objet à un type spécifié |
Le but de l'instance d'un opérateur est de comparer un objet à un type spécifié. Cela peut être utilisé pour tester si un objet est une instance d'une classe, une sous-classe ou une classe qui implémente une interface particulière.
Examinons l'exemple Java suivant illustrant l'utilisation des opérateurs de comparaison:
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)); } } Ce programme imprime la sortie suivante:
# 7) Opérateurs de décalage de bit et de bit
Java prend également en charge les opérateurs pour effectuer des opérations de décalage de bits et de bits sur tous les types d'entiers, c'est-à-dire long, int, short, char et byte.
Voici les opérateurs de décalage de bit et de bit pris en charge:
| Opérateur | La description |
|---|---|
| ~ | Complément bit à bit unaire |
| << | Décalage gauche signé |
| >> | Décalage droit signé |
| >>> | Décalage à droite non signé |
| & | ET au niveau du bit |
| ^ | OU exclusif au niveau du bit |
Jetons un coup d'œil à l'exemple Java suivant qui illustre l'utilisation des opérateurs de bits:
public class BitwiseOperatorDemo { public static void main(String() args) 0110 = 0111 = 7 System.out.println('x }Ce programme imprime la sortie suivante:
Priorité des opérateurs Java
Jusqu'à présent, nous avons exploré les opérateurs pris en charge en Java. Voyons maintenant la priorité de ces opérateurs. Les opérateurs sont répertoriés selon leur ordre de priorité dans l'ordre décroissant dans le tableau suivant. Postfix a la priorité la plus élevée et mission est l'opérateur de priorité la plus basse.
Importance de la préséance: L'évaluation des opérateurs a lieu selon la priorité des opérateurs, c'est-à-dire que l'évaluation a lieu en commençant par les opérateurs de priorité supérieure et est suivie par les opérateurs ayant une priorité relativement inférieure.
Tous les opérateurs binaires sont évalués de gauche à droite et la seule exception concerne les opérateurs d'affectation. Dans le cas des opérateurs d’affectation, l’évaluation de l’opérateur se déroule de droite à gauche.
logiciel d'horloge gratuit pour pc
| Priorité de l'opérateur | ||
|---|---|---|
| Relationnel | = instanceof | De gauche à droite |
| Les opérateurs | Priorité des opérateurs | Associativité |
| Postfix | expr ++ expr-- | De gauche à droite |
| Unaire | ++ expr --expr + expr -expr ~! | De droite à gauche |
| Multiplicatif | * /% | De gauche à droite |
| Additif | + - | De gauche à droite |
| Décalage | <>>>> | De gauche à droite |
| Égalité | ==! = | De gauche à droite |
| ET au niveau du bit | & | De gauche à droite |
| OU exclusif au niveau du bit | ^ | De gauche à droite |
| OU inclusif au niveau du bit | | | De gauche à droite |
| ET logique | && | De gauche à droite |
| OU logique | || | De gauche à droite |
| Ternaire | ? : | De droite à gauche |
| Mission | = + = - = * = / =% = & = ^ = | =<>= >>> = | De droite à gauche |
Foire aux questions et réponses
Q # 1) Quels sont les opérateurs utilisés en Java?
Réponses: Les opérateurs en Java sont des symboles spéciaux. Le but de ces symboles est d'effectuer des opérations spécifiques sur un, deux ou trois opérandes et de renvoyer un résultat.
Par exemple, symboles comme =,<, & , ^ etc .
Q # 2) Qu'est-ce que l'opérateur === en Java?
Réponses: L'opérateur === est appelé un opérateur d'égalité stricte dans Javascript . Cet opérateur renvoie true si les deux variables sont du même type et contiennent également la même valeur.
Par exemple, 1 === '1' // Cela reviendra faux . Cela est dû au fait que les deux opérandes ne sont pas du même type.
== opérateur dans Javascript compare deux variables de types différents en convertissant automatiquement un type en un autre.
Par exemple, 1 == '1' Cela reviendra vrai. Ici, la chaîne est convertie en nombre et la comparaison a lieu.
Q # 3) Qu'est-ce que Java Assignment Operator?
Réponses: Opérateur d’affectation Java, c’est-à-dire que l’opérateur «=» affecte la valeur à sa droite à l’opérande à sa gauche.
Par exemple, int x = 300; Ici ' = ’Attribue une valeur 300 à variable X
Q # 4) Qu'est-ce que == en Java?
Réponses: L'opérateur == en Java est utilisé pour comparer la référence, c'est-à-dire que cet opérateur vérifie si les deux objets pointent vers le même emplacement mémoire
Cela diffère dans .equals () qui effectue la comparaison des valeurs dans les objets.
Par exemple,
String str1 = new String («Good Morning»);
String str2 = new String («Good Morning»);
System.out.println (str1 == str2); // Ceci renvoie false car cela compare les adresses, c'est-à-dire les emplacements de mémoire de deux objets
System.out.println (str1.equals (str2)); // Cela renvoie true lors de la comparaison de la valeur.
Q # 5) Combien de types d'opérateurs y a-t-il en Java?
Réponses: Vous trouverez ci-dessous les différents types d'opérateurs en Java:
- Opérateur d'assignation
- Opérateurs arithmétiques
- Opérateurs unaires
- Égalité et opérateurs relationnels
- Opérateurs conditionnels
- Opérateur de comparaison de types
- Opérateurs de décalage de bits et de bits
Q # 6) Quelle est l'utilité de l'opérateur de point en Java?
Réponses: L'opérateur de point ou le séparateur ou le point en Java est utilisé pour séparer une variable, c'est-à-dire la méthode, d'une variable de référence d'objet.
Par exemple, Voiture car1 = nouvelle voiture ();
car1.name = 'Audi'; // Ici «.» Est utilisé pour accéder au champ «nom» de la référence d’objet Car «car1»
Q # 7) Quels sont les 3 opérateurs logiques?
Réponses: Les opérateurs logiques opèrent sur l'opérande booléen.
Voici les opérateurs logiques:
- &&: ET logique
- || : OU logique
- ! : Logique non
Q # 8) Que sont les opérateurs binaires en Java?
Réponses: Java prend en charge les opérateurs pour effectuer des opérations de décalage de bits et de bits sur tous les types d'entiers, c'est-à-dire long, int, short, char et byte.
Voici les opérateurs Bitwise et Bit shift pris en charge:
| Opérateur | La description |
|---|---|
| | | OU inclusif au niveau du bit |
| ~ | Complément bit à bit unaire |
| << | Décalage gauche signé |
| >> | Décalage droit signé |
| >>> | Décalage à droite non signé |
| & | ET au niveau du bit |
| ^ | OU exclusif au niveau du bit |
Conclusion
Dans ce didacticiel, nous avons exploré les différents types d'opérateurs pris en charge en Java ainsi que leur objectif.
En un mot, les opérateurs Java incluent:
- Opérateur d'assignation
- Opérateurs arithmétiques
- Opérateurs unaires
- Égalité et opérateurs relationnels
- Opérateurs conditionnels
- Opérateur de comparaison de types
- Opérateurs de décalage de bits et de bits
Nous avons également vu comment ces opérateurs sont utilisés dans le code Java à l'aide de quelques exemples illustrant l'utilisation de ces opérateurs. Même si nous avons vu tous les types d'opérateurs, l'utilisation de ces opérateurs dans la programmation à usage général peut parfois varier.
Certains des opérateurs apparaissent généralement plus fréquemment que les autres comme l'opérateur d'affectation «=» est beaucoup plus couramment utilisé dans le code que l'opérateur de décalage droit non signé »>>>
Nous verrons chacune de ces catégories d'opérateurs en détail dans nos prochains tutoriels.
lecture recommandée
- Exemples d'opérateurs arithmétiques et booléens de script shell Unix
- Déploiement Java: création et exécution d'un fichier JAR Java
- Machine virtuelle Java: comment JVM aide à exécuter une application Java
- Opérateurs Python
- Modificateurs d'accès en Java - Tutoriel avec des exemples
- Tutoriel de réflexion Java avec des exemples
- Introduction au langage de programmation Java - Tutoriel vidéo
- Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques