Dans le contenu précédent, j'ai appris à définir et à initialiser les variables. Le but de définir les variables est de manipuler les données. La langue Java nous fournit des symboles de code spécifiquement utilisés pour faire fonctionner ces données, collectivement appelés "opérateurs".
Selon l'utilisation des opérateurs, nous pouvons les diviser dans les catégories suivantes:
Opérateurs arithmétiques
Opérateur d'affectation
Opérateurs d'auto-augmentation et d'autodécréation
Opérateurs logiques
Opérateurs relationnels
opérateur de bits
Ne vous inquiétez pas, ce ne sont que des symboles qui nous aident à traiter les données de fonctionnement. Le suivant utilise des exemples de code pour illustrer l'utilisation de ces opérateurs un par un.
1. Opérateurs arithmétiques
Les opérateurs arithmétiques sont des opérations arithmétiques pour ajouter, soustraire, multiplier, diviser et prendre le reste de variables numériques:
Ajouter: +
réduire:-
prendre:*
retirer:/
Prendre l'équilibre:%
public class operatorsDemo {public static void main (String [] args) {int num1 = 100; int num2 = 20; // ajouter System.out.println ("num1 + num2:" + (num1 + num2)); // soustraire System.out.println ("num1 - num2:" + (num1 - num2)); // Multiply System.out.println ("num1 * num2:" + (num1 * num2)); // Discount System.out.println ("num1 / num2:" + (num1 / num2)); // obtient le System restant.out.println ("num1% num2:" + (num1% num2)); }}Résultat de sortie:
num1 + num2: 120num1 - num2: 80num1 * num2: 2000Num1 / num2: 5num1% num2: 0
2. Opérateur d'affectation
Comme la plupart des langages de programmation, Java utilise l'opérateur '=' pour effectuer des opérations d'affectation. Cette opération attribue le résultat de calcul à droite (appelé le RValue) à la variable à gauche. Les opérateurs d'affectation de Java comprennent:
= (num2 = num1)
+ = (num2 + = num1 équivalent num2 = num2 + num1)
- = (num2 - = num1 équivalent num2 = num2 - num1)
* = (num2 * = num1 équivalent num2 = num2 * num1)
/ = (num2 / = num1 équivalent num2 = num2 / num1)
% = (num2% = num1 équivalent num2 = num2% num1)
public class operatorsDemo {public static void main (String [] args) {int num1 = 10; int num2 = 20; num2 = num1; System.out.println ("= sortie:" + num2); num2 + = num1; System.out.println ("+ = sortie:" + num2); num2 - = num1; System.out.println ("- = sortie:" + num2); num2 * = num1; System.out.println ("* = sortie:" + num2); num2 / = num1; System.out.println ("/ = sortie:" + num2); num2% = num1; System.out.println ("% = sortie:" + num2); }}Sortie des résultats:
= Sortie: 10 + = sortie: 20- = sortie: 10 * = sortie: 100 / = sortie: 10% = sortie: 0
3. Opérateurs d'auto-augmentation et d'auto-décoricité
Les opérateurs d'auto-incidence et d'auto-décoricité ne fonctionnent que sur une seule variable et la valeur de la variable change.
Num ++ (num équivalent = num + 1) augmente en soi, principalement pour les variables numériques, ajoutant 1 à la valeur de sa propre variable.
numll (num équivalent = num -1) auto-détuvant, ciblant principalement les variables numériques, soustrayant la valeur de la variable corporelle par 1.
public class operatorsDemo {public static void main (String [] args) {int num1 = 100; int num2 = 200; num1 ++; num2--; System.out.println ("num1 ++ est:" + num1); System.out.println ("num2-- est:" + num2); }}Sortie des résultats:
num1 ++ est: 101NUM2-- IS: 199
4. Opérateurs logiques
Les opérateurs logiques, comme son nom l'indique, sont utilisés pour les jugements logiques. Le résultat de l'opération est une valeur de type booléen, c'est-à-dire vrai ou faux. Les opérateurs uniformes logiques ont
| Opérateurs logiques | Relations logiques |
|---|---|
| && | et |
| ' | |
| ! | Non |
B1 && b2: si B1 et B2 sont vrais, B1 && b2 reviendra vrai, sinon faux
B1 || B2: Si B1 et B2 sont faux, FAUX sera retourné, sinon vrai sera retourné.
! B1: renvoiera la valeur opposée à B1, si B1 est faux, renvoie true; Si B1 est vrai, revenez faux
public class operatorsDemo {public static void main (String [] args) {boolean b1 = true; booléen b2 = false; System.out.println ("B1 && b2:" + (b1 && b2)); System.out.println ("B1 || B2:" + (B1 || B2)); System.out.println ("! (B1 && b2):" +! (B1 && b2)); }}Résultat de sortie:
b1 && b2: falseb1 || b2: true! (b1 && b2): true
Court-circuit logique:
En Java, les opérateurs logiques prennent en charge les opérations de court-circuit, et une fois que la valeur de l'expression entière peut être clairement exprimée, nous n'avons pas besoin de calculer le reste de l'expression. Par exemple, nous devons juger qu'un objet n'est pas vide et que la valeur de retour de sa méthode n'est pas vide, nous pouvons donc porter un jugement comme ceci:
if (object! = null && object.someFunction ()! = null) {// faire quelque chose.}Si l'objet est vide, l'objet d'expression de première partie! = NULL Retournera False, alors quel que soit le résultat de l'expression objet.SomeFunction ()! = NULL APRÈS L'OPÉRATEUR &&, la valeur finale est fausse. Le compilateur optimisera automatiquement cette partie de l'opération et n'exécutera pas objet.SomeFunction ()! = NULL.
5. Opérateurs relationnels
Utilisé pour comparer la taille de deux données variables, renvoyez la valeur de Boolean, c'est-à-dire vrai ou faux
Les opérateurs relationnels comprennent:
| Opérateurs relationnels | relation |
|---|---|
| > | Supérieur à |
| < | Moins que |
| == | égal |
| ! = | Pas égal à |
| > = | Supérieur ou égal à |
| <= | Moins ou égal à |
'==' et '! =' conviennent à tous les types de valeurs et d'objets (c'est-à-dire variables de type primitif et variables de type de référence).
'>', '<', '> =' et '<=' ne s'appliquent pas aux valeurs des types booléens, car ils n'ont que vrai ou faux, et supérieur à et moins que ce qui n'a aucune signification pratique.
public class operatorsDemo {public static void main (String [] args) {int num1 = 10; int num2 = 50; if (num1 == num2) {System.out.println ("num1 et num2 sont égaux"); } else {System.out.println ("num1 et num2 ne sont pas égaux"); } if (num1! = num2) {System.out.println ("num1 et num2 ne sont pas égaux"); } else {System.out.println ("num1 et num2 ne sont pas égaux"); } else {System.out.println ("num1 et num2 ne sont pas égaux"); } égal ");} if (num1> num2) {System.out.println (" num1 est supérieur à num2 ");} else {System.out.println (" num1 n'est pas supérieur à num2 ");} if (num1> = num2) {system.out.println (" num1 est supérieur à ou num2 ");} else {System. moins de num2 ");} if (num1 <num2) {System.out.println (" num1 est inférieur à num2 ");} if (num1 <num2) {System.out.println (" num1 est inférieur à Num2 ");} else {if (num1 <= num2) {{n'est pas moins que num2");} if (num1 System.out.println ("num1 est inférieur ou égal à Num2");} else {System.out.println ("num1 est supérieur à Num2");Résultat de sortie:
num1 et num2 ne sont pas égauxnum1 et num2 ne sont pas égalnum1 n'est pas supérieur à Num2num1 est inférieur à num2num1 est inférieur à num2num1 est inférieur ou égal à num2
6. Opérateur de bits
L'objet d'opération ciblé par l'opérateur de bits est les «bits» binaires, qui peuvent être appliqués aux types entiers (int), longs, courts, types de caractères (char) et type (octet) et autres types. Pendant le fonctionnement, le bit de bit correspondant (0 ou 1) sera effectué en fonctionnement algébrique booléen ou opération de déplacement.
| opérateur de bits | Logique informatique |
|---|---|
| & | Et opération: pour un certain bit, tant que les deux opérandes sont 1, le résultat du bit est 1, sinon il est 0. |
| ' | ' |
| ^ | Opération XOR: pour un certain bit, si les deux opérandes ne sont pas les mêmes, le résultat du bit est 1, sinon il est 0. |
| ~ | Non-opération: l'opérateur de complément bit dans les sens bit |
| << | Opérateur de quart de travail binaire: l'opérande gauche est bit-gauche déplacé par l'opérande droit. |
| >> | Opérateur de changement de droite binaire: l'opérande gauche est bit-droit décalé par l'opérande droit. |
| >>> | Opérateur de complément zéro de décalage à droite binaire: La valeur de l'opérande gauche est décalée à droite en fonction du nombre de bits spécifiés par l'opérande droit, et le bit vide résultant est rempli de zéro |
La description de la logique de calcul est quelque peu obscure, et nous pouvons utiliser des exemples pour comprendre plus clairement comment les opérateurs BIT effectuent des calculs. Supposons que si X est égal à 60; y est égal à 13; Leurs représentations binaires et les résultats des opérations bit sont les suivants:
x = 0011 1100y = 0000 1101 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Notez la différence entre >> et >>>:
Opérateur de déplacement droit >>, si la valeur de l'opération est positive, 0 est insérée en position élevée; Si la valeur est négative, 1 est inséré en position élevée;
Déplacez-vous à droite pour remplir zéro opérateur >>>, insérez 0 à la position élevée indépendamment du positif ou du négatif.
> Si vous ne comprenez pas l'opération de bits, sautez-le d'abord. Lorsqu'il est réellement utilisé, vous pouvez l'étudier à nouveau.
7. Priorité de l'opérateur
La priorité de l'opérateur détermine le regroupement des termes dans une expression. Cela affecte la façon dont une expression est évaluée. Un certain opérateur a une priorité plus élevée que les autres opérateurs.
Par exemple: l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition et l'expression 1 + 5 * 6. Selon la priorité de l'opérateur, le compilateur calcule d'abord 5 * 6, puis calculer 30 + 1, et enfin obtenir le résultat 31.
La priorité de divers opérateurs est de grande à petite:
., (), [] Monoculaire + (de droite à gauche combinée), monoculaire - (de droite à gauche combinée), ++, -, ~,! *, /,% + (Gauche à droite combinée), - (gauche à droite combinée) >>, <<, >>> <, <=,>,> ==,! = & | ^ && || ?: + = etc.
Ne vous inquiétez pas d'une liste de priorités aussi complexe. Dans la plupart des cas, l'expression elle-même est facile à voir la priorité. Par exemple, l'opération d'affectation doit avoir la priorité la plus basse. Dans les cas où la priorité n'est pas claire, nous pouvons modifier la priorité comme nous le voulons, il n'est donc pas nécessaire de se souvenir trop de la priorité de l'opérateur.
8. Autres opérateurs
Opérateur à trois:
L'opérateur conditionnel de Java est un opérateur ternaire, et sa forme est la suivante:
BooleanExpression? valeurwhentrue: valeur quand
Si la valeur d'expression booléenne est vraie, la valeur de l'expression est la valeur de la valeurwentrue, sinon la valeur de la valeur quand
Par exemple, si nous voulons calculer la valeur absolue de X, nous pouvons l'implémenter via le code suivant:
if (x> = 0) {y = x;} else {y = -x;}Grâce à l'opérateur ternaire, vous n'avez besoin que d'une instruction y = x> = 0? x: -x; Pour le terminer, ce qui est plus concis.
Opérateur de conversion de type:
Nous utilisons la conversion de type dans de nombreux cas. Aux moments appropriés, Java convertira automatiquement le type de données en un autre selon le type de données. Par exemple, si nous attribuons une valeur entière à la variable float, le compilateur convertira INT en flotteur et le affectera à la variable.
Cependant, dans de nombreux cas, Java ne peut pas déterminer si nous devons effectuer une conversion de type. À l'heure actuelle, nous avons besoin d'opérateurs de conversion de type, qui nous permettent d'effectuer explicitement la conversion de type, comme:
int a = 10; long b = (long) a; long c = (long) 100;
Nous pouvons taper convertir à la fois des variables et des constantes.
Lorsque vous effectuez une conversion de type de nombres à virgule flottante, nous devons faire attention au problème de la troncature. Si nous voulons taper converti 10.9: (int) 10.9, sa valeur n'est pas arrondie 11, mais 10