Java - Opérateurs de base
Java fournit un riche ensemble d'opérateurs pour manipuler les variables. Nous pouvons diviser tous les opérateurs Java dans les groupes suivants −
- Opérateurs arithmétiques
- Opérateurs relationnels
- Opérateurs au niveau du bit
- Opérateurs logiques
- Opérateurs d'affectation
- Opérateurs divers
Les opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés dans les expressions mathématiques de la même manière qu'ils sont utilisés en algèbre. Le tableau suivant répertorie les opérateurs arithmétiques −
Supposons que la variable entière A contienne 10 et que la variable B contienne 20, alors −
Afficher des exemples
| Opérateur | Description | Exemple |
|---|---|---|
| + (Ajout) | Ajoute des valeurs de chaque côté de l'opérateur. | A + B donnera 30 |
| - (Soustraction) | Soustrait l'opérande droit de l'opérande gauche. | A - B donnera -10 |
| &ast ; (Multiplication) | Multiplie les valeurs de chaque côté de l'opérateur. | Un &ast ; B donnera 200 |
| / (Division) | Divise l'opérande de gauche par l'opérande de droite. | B / A donnera 2 |
| % (module) | Divise l'opérande de gauche par l'opérande de droite et renvoie le reste. | B % A donnera 0 |
| ++ (Incrémenter) | Augmente la valeur de l'opérande de 1. | B+plus;+ donne 21 |
| -- (Décrémenter) | Diminue la valeur de l'opérande de 1. | B-- donne 19 |
Les opérateurs relationnels
Les opérateurs relationnels suivants sont pris en charge par le langage Java.
Supposons que la variable A contienne 10 et que la variable B contienne 20, alors −
Afficher des exemples
| Opérateur | Description | Exemple |
|---|---|---|
| ==(égal à) | Vérifie si les valeurs de deux opérandes sont égales ou non, si oui alors la condition devient vraie. | (A ==B) n'est pas vrai. |
| !=(différent de) | Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas égales alors la condition devient vraie. | (A !=B) est vrai. |
| > (supérieur à) | Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, si oui alors la condition devient vraie. | (A> B) n'est pas vrai. |
| <(inférieur à) | Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit, si oui alors la condition devient vraie. | (A |
| >=(supérieur ou égal à) | Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si oui alors la condition devient vraie. | (A>=B) n'est pas vrai. |
| <=(inférieur ou égal à) | Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, si oui alors la condition devient vraie. | (A <=B) est vrai. |
Les opérateurs au niveau du bit
Java définit plusieurs opérateurs au niveau du bit, qui peuvent être appliqués aux types entiers, long, int, short, char et byte.
L'opérateur au niveau du bit fonctionne sur les bits et effectue une opération bit par bit. Supposons si a =60 et b =13 ; maintenant au format binaire, ils seront comme suit −
a =0011 1100
b =0000 1101
-----------------
a&b =0000 1100
a|b =0011 1101
a^b =0011 0001
~a =1100 0011
Le tableau suivant répertorie les opérateurs au niveau du bit −
Supposons que la variable entière A tienne 60 et que la variable B tienne 13 alors −
Afficher des exemples
| Opérateur | Description | Exemple |
|---|---|---|
| &(bitwise and) | L'opérateur ET binaire copie un peu dans le résultat s'il existe dans les deux opérandes. | (A &B) donnera 12 qui est 0000 1100 |
| | (ou au niveau du bit) | L'opérateur OU binaire copie un peu s'il existe dans l'un ou l'autre des opérandes. | (A | B) donnera 61 qui est 0011 1101 |
| ^ (XOR au niveau du bit) | L'opérateur XOR binaire copie le bit s'il est défini dans un opérande mais pas dans les deux. | (A ^ B) donnera 49 qui est 0011 0001 |
| ~ (complément au niveau du bit) | L'opérateur de complément à un binaire est unaire et a pour effet de "basculer" les bits. | (~A ) donnera -61 qui est 1100 0011 sous forme de complément à 2 en raison d'un nombre binaire signé. |
| <<(décalage à gauche) | Opérateur binaire de décalage vers la gauche. La valeur des opérandes de gauche est déplacée vers la gauche du nombre de bits spécifié par l'opérande de droite. | A <<2 donnera 240 soit 1111 0000 |
| >> (décalage vers la droite) | Opérateur de décalage binaire vers la droite. La valeur des opérandes de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite. | A>> 2 donnera 15 soit 1111 |
| >>> (zéro remplissage décalage vers la droite) | Décalage vers la droite de l'opérateur de remplissage par zéro. La valeur des opérandes de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite et les valeurs décalées sont remplies de zéros. | A>>>2 donnera 15 qui est 0000 1111 |
Les opérateurs logiques
Le tableau suivant répertorie les opérateurs logiques −
Supposons que les variables booléennes A soient vraies et que la variable B soit fausse, alors −
Afficher des exemples
| Opérateur | Description | Exemple |
|---|---|---|
| &&(et logique) | Appelé l'opérateur ET logique. Si les deux opérandes sont différents de zéro, alors la condition devient vraie. | (A &&B) est faux |
| || (ou logique) | Opérateur OU logique appelé. Si l'un des deux opérandes est différent de zéro, la condition devient vraie. | (A || B) est vrai |
| ! (pas logique) | Appelé l'opérateur NON logique. Utilisez pour inverser l'état logique de son opérande. Si une condition est vraie, l'opérateur logique NON deviendra faux. | !(A &&B) est vrai |
Les opérateurs d'affectation
Voici les opérateurs d'affectation pris en charge par le langage Java −
Afficher des exemples
| Opérateur | Description | Exemple |
|---|---|---|
| = | Opérateur d'affectation simple. Attribue des valeurs des opérandes de droite à l'opérande de gauche. | C =A + B attribuera la valeur de A + B en C |
| += | Ajouter un opérateur d'affectation AND. Il ajoute l'opérande droit à l'opérande gauche et affecte le résultat à l'opérande gauche. | C +=A est équivalent à C =C +plus; A |
| -= | Opérateur d'affectation ET de soustraction. Il soustrait l'opérande droit de l'opérande gauche et attribue le résultat à l'opérande gauche. | C -=A est équivalent à C =C – A |
| *= | Multiplier l'opérateur d'affectation AND. Il multiplie l'opérande droit avec l'opérande gauche et attribue le résultat à l'opérande gauche. | C *=A est équivalent à C =C * A |
| /= | Opérateur d'assignation ET de division. Il divise l'opérande gauche avec l'opérande droit et attribue le résultat à l'opérande gauche. | C /=A est équivalent à C =C / A |
| %= | Opérateur d'affectation module ET. Il prend le module en utilisant deux opérandes et attribue le résultat à l'opérande gauche. | C %=A est équivalent à C =C % A |
| <<= | Décalage à gauche ET opérateur d'affectation. | C <<=2 est identique à C =C <<2 |
| >>= | Décalage à droite ET opérateur d'affectation. | C>>=2 est identique à C =C>> 2 |
| &= | Opérateur d'affectation AND au niveau du bit. | C &=2 est identique à C =C &2 |
| ^= | OU exclusif au niveau du bit et opérateur d'affectation. | C ^=2 est identique à C =C ^ 2 |
| |= | OU inclus au niveau du bit et opérateur d'affectation. | C |=2 est identique à C =C | 2 |
Opérateurs divers
Il existe peu d'autres opérateurs pris en charge par le langage Java.
Opérateur conditionnel ( ? :)
L'opérateur conditionnel est également appelé opérateur ternaire . Cet opérateur se compose de trois opérandes et est utilisé pour évaluer les expressions booléennes. Le but de l'opérateur est de décider quelle valeur doit être affectée à la variable. L'opérateur s'écrit −
variable x = (expression) ? value if true : value if false
Voici un exemple −
Exemple
Démo en direct
public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " + b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
Cela produira le résultat suivant −
Sortie
Value of b is : 30 Value of b is : 20
opérateur instanceof
Cet opérateur est utilisé uniquement pour les variables de référence d'objet. L'opérateur vérifie si l'objet est d'un type particulier (type classe ou type interface). instanceof s'écrit −
( Object reference variable ) instanceof (class/interface type)
Si l'objet référencé par la variable sur le côté gauche de l'opérateur réussit la vérification IS-A pour le type de classe/interface sur le côté droit, alors le résultat sera vrai. Voici un exemple −
Exemple
Démo en direct
public class Test {
public static void main(String args[]) {
String name = "James";
// following will return true since name is type of String
boolean result = name instanceof String;
System.out.println( result );
}
}
Cela produira le résultat suivant −
Sortie
true
Cet opérateur renverra toujours vrai, si l'objet comparé est l'affectation compatible avec le type à droite. Voici un autre exemple −
Exemple
Démo en direct
class Vehicle {}
public class Car extends Vehicle {
public static void main(String args[]) {
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println( result );
}
}
Cela produira le résultat suivant −
Sortie
true
Priorité des opérateurs Java
La priorité des opérateurs détermine le groupement des termes dans une expression. Cela affecte la façon dont une expression est évaluée. Certains opérateurs ont une priorité plus élevée que d'autres; par exemple, l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition −
Par exemple, x =7 + 3&ast ; 2 ; ici x est affecté 13, pas 20 parce que l'opérateur * a une priorité plus élevée que +, il est donc d'abord multiplié par 3 * 2 puis ajoute dans 7.
Ici, les opérateurs avec la plus haute priorité apparaissent en haut du tableau, ceux avec la plus basse apparaissent en bas. Dans une expression, les opérateurs de priorité supérieure seront évalués en premier.
| Catégorie | Opérateur | Associativité |
|---|---|---|
| Suffixe | expression++ expression-- | De gauche à droite |
| Unaire | ++expression –-expression +expression –expression ~ ! | De droite à gauche |
| Multiplicatif | * / % | De gauche à droite |
| Additif | + - | De gauche à droite |
| Maj | <<>>>>> | De gauche à droite |
| Relationnel | <> <=>=instanceof | De gauche à droite |
| Égalité | ==!= | De gauche à droite |
| ET au niveau du bit | & | De gauche à droite |
| XOR bit à bit | ^ | De gauche à droite |
| OU au niveau du bit | | | De gauche à droite |
| ET logique | && | De gauche à droite |
| OU logique | || | De gauche à droite |
| Conditionnel | ? : | De droite à gauche |
| Affectation | =+=-=*=/=%=^=|=<<=>>=>>>= | De droite à gauche |
Quelle est la prochaine ?
Le chapitre suivant expliquera le contrôle de boucle dans la programmation Java. Le chapitre décrira différents types de boucles et comment ces boucles peuvent être utilisées dans le développement de programmes Java et à quelles fins elles sont utilisées.
Java