Opérateurs de base à Java | Expliqué
Par exemple, les opérateurs Java qui effectuent l'addition, la soustraction, la division, la multiplication, etc. sont placés dans la catégorie arithmétique des opérateurs. De même, les opérateurs qui fournissent la relation entre les variables sont placés dans la catégorie de l'opérateur relationnel.
Cet article répertorie l'utilisation et l'applicabilité des opérateurs de base en Java. Alors, commençons.
Quels sont les opérateurs de base de Java
Cette section décrit les fonctionnalités des opérateurs de base en Java.
Opérateurs d'affectation
Ces opérateurs aident à attribuer une valeur à une variable en Java. Cette action d'affectation peut être effectuée à l'aide de l'un des opérateurs suivants:
«=»: Fonctionne sur deux opérandes et attribue la valeur placée sur le côté droit à la variable écrite sur le côté gauche.
«+ =»: ajoute des opérandes des deux côtés, puis attribue la valeur à la variable écrite sur le côté gauche
«- =»: soustrait l'opérande placé à droite de gauche, puis attribue la valeur à la variable placée sur le côté gauche
«* =»: multiplie les deux opérandes puis attribue la réponse à la variable sur le côté gauche
«/ =»: rapporte le reste en divisant les opérandes ou en divisant l'opérande gauche par une valeur spécifique.
«% =»: obtient le reste en utilisant ce% d'abord, puis la réponse est affectée à la variable sur le côté gauche.
Les syntaxes suivantes peuvent être suivies:
opérand1 = opérandd2; // Utilisation =opérand1 + = opérand2 // en utilisant + =
opérand1- = opérand2 // utilisant - =
opérand1 * = opérand2 // en utilisant * =
opérand1 / = opérand2 // Utilisation / =
opérand1% = opérand2 // Utilisation de% =
Opérateurs arithmétiques
Cette catégorie traite des opérations arithmétiques et les opérateurs suivants résident dans cette catégorie.
«+»: utilisé pour ajouter deux variables / valeurs
"-": fournit la différence entre deux variables / valeur
«*»: multiplie deux variables / valeurs
«/»: utilisé pour diviser une variable sur un autre et le quotient est illustré dans la sortie.
«%»: rapporte le reste () de deux variables / valeurs
La syntaxe de ces opérateurs est fournie ci-dessous, l'opérand1 et l'opérand2 se réfèrent aux variables / valeurs. Il est observé que deux opérandes sont nécessaires pour effectuer des opérations arithmétiques.
opérand1 + opérand2; //ajoutopérand1-operand2; //soustraction
opérand1 * opérand2; //multiplication
opérand1 / opérand2; //division
opérand1% opérand2; //reste
Opérateurs unaires
Ce type effectue diverses opérations sur une variable / valeur. Les opérateurs inclus dans cette catégorie sont décrits ci-dessous:
"+": attribue un signe positif à un opérande (généralement un signe positif n'est pas affiché car il est facultatif)
"-": modifie le signe d'un opérande
«++»: incréments la valeur d'un opérande de 1. L'opérateur d'incrément peut être appliqué en postfixe et préfixe
"-": La valeur d'une variable / valeur est décrémentée de 1. Comme l'incrément, il peut également être utilisé comme préfixe ou post-fixe
"!": La valeur booléenne (vrai / false) est inversée en utilisant cet opérateur
Vous pouvez vous référer à la syntaxe de ces opérateurs prévus ci-dessous:
+opérande; // Unary Plus-opérande; // unary moins
++opérande; // Incrément préfixe
opérande ++; // Incrément post-fixe
opérande--; // Postfix décrément
--opérande; // Préfixe décrément
!opérande; // complément logique
Opérateurs logiques
Ces opérateurs aident à effectuer des opérations logiques telles que et, ou non. Ceux-ci sont décrits ci-dessous:
ET(&&): Cela fonctionne sur deux variables / valeurs, il renvoie vrai si les deux variables sont vraies et fausses dans d'autres cas.
Ou (||): Cet opérateur construit une logique de telle sorte que si les deux valeurs sont fausses, le résultat serait faux autrement.
PAS (!): Cela fait également référence à la catégorie unaire et renvoie des résultats faux / vrais
Vous pouvez vous référer aux syntaxes suivantes pour utiliser les opérateurs logiques:
opérand1 && opérand2 // logique etopérand1 || opérand2 // logique ou
!opérande // logique pas
Opérateurs
Ce cours de cet opérateur traite des valeurs binaires et donc toutes les opérations sont effectuées. Et les opérateurs suivants sont pratiqués:
«&»: Ceci est connu comme binaire et cela fonctionne de la même manière que logique et mais sur les valeurs binaires.
«|»: Cela fonctionne également sur le même modèle que Logical ou, mais il effectue le fonctionnement un peu à peu.
«^»: Ceci est connu sous le nom de XOR, il renvoie True si les deux valeurs sont différentes et renvoient faux si les deux valeurs sont les mêmes.
«~»: Cet opérateur change le bit de 0 à 1 et 1 à 0
"<<“: Cet opérateur de changement de gauche déplace le nombre de bits vers la gauche. Le nombre de bits est décidé par l'utilisateur et il peut être n'importe quel nombre.
«>>»: L'opérateur de shift de droite déplace le nombre de bits du côté droit.
«>>>»: Ceci est connu sous le nom de shift de droite non annuel et il déplace le nombre de bits de «0»
Les syntaxes suivantes se réfèrent aux opérateurs de bitwise:
Operand1 | opérand2; // Bitwise ouOperand1 & Operand2; // bitwise et
opérand1 ^ opérand2; // bitwise xor
~ opérande; // complément bitwise
opérande<
Operand >>> Numéro; // Bitwise Unssigned Dright Shift
Opérateurs relationnels
Cette catégorie fait référence à la relation avec plus d'une variable en utilisant des symboles spécifiques. Ces opérateurs aident à prendre des décisions dans la programmation Java.
«==»: Cet opérateur est pratiqué en vérifiant l'égalité de deux opérandes
"!= ”: utilisé pour vérifier que l'inégalité des opérandes
"<“: pratiqué la vérification moins que la relation entre deux opérandes
">": il est utilisé pour vérifier que l'opérande gauche est plus élevé ou non
«> =»: Pour vérifier que l'opérande gauche est «supérieure ou égale» à la droite ou non
"<=”: Il est pratiqué en vérifiant si la variable de gauche est inférieure ou égale à la droite
Les opérateurs relationnels peuvent être pratiqués en utilisant les syntaxes fournis ci-dessous:
opérand1 == opérand2; //égal àopérande1!= opérand2; //pas égal à
opérand1> opérand2; //plus grand que
opérande1
opérande1<=operand2; //less than or equal to
Comment utiliser les opérateurs de base en Java
Cette section fournit l'utilisation des opérateurs de base en Java. Chaque exemple démontre le code Java qui utilise les opérateurs d'une catégorie spécifique.
Exemple 1: Utilisation des opérateurs d'affectation
Le code Java suivant pratique divers opérateurs d'affectation sur les variables.
Package NewPack;CLASSE PUBLIQUE Affectation
public static void main (String [] args)
// en utilisant "=" pour attribuer des valeurs
int a = 3, b = 4, c = 5, d = 6, e = 7;
// en utilisant "+ =" sur un
a + = 3;
Système.dehors.println ("Nouvelle valeur de A serait:" + a);
// en utilisant "- =" sur b
b- = 3;
Système.dehors.println ("La nouvelle valeur de B serait:" + b);
// en utilisant "* =" sur c
C * = 2;
Système.dehors.println ("La nouvelle valeur de C serait:" + c);
// en utilisant "/ =" sur d
d / = 2;
Système.dehors.println ("La nouvelle valeur de D serait:" + d);
// en utilisant "% =" sur e
E% = 2;
Système.dehors.println ("La nouvelle valeur de E serait:" + e);
Le code indiqué ci-dessus est décrit ici:
- Premièrement, les valeurs sont attribuées à des variables en utilisant =
- L'instruction «A + = 3» ajoute 3 à la valeur actuelle de A
- Soustraire 3 de B en utilisant «- =»
- multiplie la valeur de C par 2 en utilisant «* =»
- divise la valeur de D par 2 en utilisant «/ =»
- La valeur de E est divisée par 2 puis le reste est stocké comme une nouvelle valeur de E.
La sortie du code est fournie ci-dessous:
Exemple 2: Utilisation d'opérateurs arithmétiques
Le code Java suivant effectue des opérations arithmétiques sur deux nombres a = 5 et b = 11.
Package NewPack;classe publique Arithop
public static void main (String [] args)
// Initialisation des variables
int a = 5, b = 11;
// en utilisant + sur A et B
Système.dehors.println ("a + b =" + (a + b));
// Utilisation - sur A et B
Système.dehors.println ("a-b =" + (a-b));
// en utilisant * sur A et B
Système.dehors.println ("a-b =" + (a * b));
// Utilisation / sur A et B
Système.dehors.println ("a / b =" + (b / a));
// Utilisation de% sur A et B
Système.dehors.println ("a% b =" + (a% b));
Dans le code indiqué ci-dessus, les variables sont initialisées d'abord, puis chaque ligne représente l'application d'un opérateur d'affectation différent.
La sortie est fournie ci-dessous:
Exemple 3: Utilisation d'opérateurs relationnels
Le code Java suivant pratique les opérateurs relationnels sur deux variables x = 3 et y = 5.
Package NewPack;classe publique Replot
public static void main (String [] args)
// Initialisation des variables
int x = 3, y = 5;
//en utilisant < operator
Système.dehors.println ("est x inférieur à y? "+ (l'opérateur x
Système.dehors.println ("est x supérieur à y? "+ (x> y));
// Utilisation de l'opérateur ==
Système.dehors.println ("est x égal à y? "+ (x == y));
Le code ci-dessus implémente trois opérateurs relationnels sur x et y. Au plus, le code est décrit comme:
- initialise deux variables x et y
- rapporte le résultat de x
- imprime les résultats vrais ou faux pour la condition x> y
- vérifie et imprime l'égalité de x et y
La sortie du code est fournie ci-dessous:
Exemple 4: Utilisation des opérateurs logiques
Le code Java suivant pratique les opérateurs logiques dans la déclaration conditionnelle IF-Else.
Package NewPack;classe publique Logop
public static void main (String [] args)
int a = 4, b = 5, c = 5;
if (a == b || (b == c && c!= a))
Système.dehors.println ("La condition est vraie");
autre
Système.dehors.println ("La condition est fausse");
Le code ci-dessus est décrit comme.
- Trois variables sont initialisées
- Dans la condition IF, nous avons utilisé l'opérateur et (&&) entre B == C et C!= A. De plus, cette déclaration est jointe à un opérateur A == B en utilisant ou (||).
- La condition ci-dessus est vraie, donc le bloc if de la déclaration if-else serait exécuté.
La sortie du code est affichée dans l'image ci-dessous:
Exemple 5: Utilisation d'opérateurs unaires
Les opérateurs unaires sont pratiqués dans le code Java suivant.
Package NewPack;classe publique unop
public static void main (String [] args)
// Initialisation des variables
int a = 4, b = 6;
// en utilisant unary moins sur un
Système.dehors.println ("La valeur mise à jour de A est:" + (-a));
// en utilisant l'incrément préfixe sur b
Système.dehors.println ("La valeur mise à jour de B est:" + (++ b));
La description du code est:
- Deux variables A et B sont initialisées
- imprime la réponse après avoir appliqué unary moins sur un
- montre le résultat après avoir appliqué l'opérateur d'incrément préfixe sur b
La sortie du code est fournie ici:
Exemple 6: Utilisation des opérateurs de bit
Le code Java suivant implémente plusieurs opérateurs bit sur les variables / valeurs.
Package NewPack;classe publique Bitop
public static void main (String [] args)
int a = 3, b = 5;
// Utilisation de l'opérateur de décalage à gauche sur bit sur un
Système.dehors.println ("La réponse est:" + (a3));
Le code est décrit comme:
- Les variables A et B sont initialisées
- utilisé l'opérateur de décalage gauche sur A et la réponse est imprimée. Le binaire du numéro 3 serait décalé à gauche par 2bits.
- Imprime la réponse après avoir appliqué le bon opérateur de quart sur b. Les 3bits du numéro B seraient retirés du côté droit du binaire du numéro 3.
La sortie du code est:
Conclusion
Les opérateurs de base de Java sont les opérateurs qui sont fréquemment utilisés dans les programmes Java. Java prend en charge une longue liste d'opérateurs qui aident à effectuer diverses opérations sur des variables / valeurs. Les opérateurs ayant une applicabilité similaire sont placés dans la même catégorie. Par exemple, les opérateurs qui définissent les relations peuvent être trouvés dans la catégorie relationnelle des opérateurs. Cet article répertorie les opérateurs de base en Java et fournit leur application en utilisant le code Java. Vous auriez appris l'aperçu et l'applicabilité préliminaire de tous les opérateurs de base en Java.