[Notes de démarrage Java] Bases du langage Java (3) : opérateurs

Introduction

Un opérateur est un symbole spécial. Un opérateur est un symbole spécifique qui exploite un ou plusieurs opérandes via certaines règles de fonctionnement et génère un résultat. une expression.

Les opérateurs en Java sont principalement répartis dans les catégories suivantes :

Opérateur d'affectation

Opérateur arithmétique

Opérateur relationnel

Opérateurs logiques

Opérateurs conditionnels (opérateurs ternaires)

Opérateurs de bits

Opérateurs d'affectation

Les opérateurs d'affectation sont utilisés pour attribuer des variables ou des constantes spécifient des valeurs, et le symbole du l'opérateur d'affectation est "=".

Exemple

int a = 1;  //定义时直接赋值int b;int c;
b = 
c = 2;  //可以在一个语句内为多个变量赋值
int d = b + 3;   //变量运算后再赋值，先执行右边，再执行左边

Opérateurs arithmétiques

Java prend en charge les opérations mathématiques de base telles que l'addition, la soustraction, la multiplication, la division et le reste. Ce sont les suivants :

Opérateur d'addition :

double a = 1.1;double b = 1.2;double somme = a b;
Système .out .PRintln(sum); //Sortie 2.3

Opérateur de soustraction : -

double a = 2.2;double b = 1.1;double sub = a - b;
Système .out.println(sub); //Sortie 1.1

Opérateur de multiplication : *

int a = 11;double b = 1.2;double multiplication = a * b;
System.out.println(multiply); //Sortie 1.32

Opérateur de division : /

L'opérateur de division est un peu particulier : si les deux valeurs​​de l'opération Ils sont tous de type int, et le résultat obtenu est également de type int. Le point décimal sera supprimé directement et ne sera pas arrondi

int a = 10 int b = 4; b; System.out.println(c); //Le résultat original de 10chu4 est 2,5, mais le résultat de la division de deux nombres de type int est un nombre de type int Bien que la valeur du résultat soit assignée à double,
//Mais le. le résultat est affiché Il devient 2,0, ce qui équivaut à supprimer le point décimal lorsque l'opération est terminée, puis à le convertir en 2,0double a2 = 5,2;double b2 = 3,1;double c2 = a2/b2; System.out.println(c2); //Opération sur deux valeurs doubles, résultat de sortie : 1.6774193548387097System.out.println(5 / 0.0); //Le diviseur est de type double 0.0 et la sortie est l'infini négatif System.out .println(5 / 0); //Le diviseur est 0, et une erreur sera signalée lors de l'exécution

Opérateur restant : %

int a = 5;int b = 3;double c = 3.2;
System.out.println(a%b); //Sortie 2System.out.println(a%c); //1.7999999999999998System.out.println(0%5); .out.println(5% 0); //Une erreur se produira lors de l'exécution de

Négatif : -

int i = -1;int i2 = -i;
System.out.println(i2) ; //Sortie 1

auto-incrémentation :

int i = 1;
i ; //Équivalent à l'ajout de 1 à la valeur de i; System.out.println( i); //Sortie 2

Le signe auto-croissant peut être placé devant la variable ou derrière la variable. ajoutez d'abord 1 à l'opérande, puis effectuez l'opération d'expression. Le mettre à la fin fait le contraire.

int i1 = 1; int i2 = 1; int i3 = i1; //À ce moment, la valeur de i3 est 1 et la valeur de i1 est 2 ; , puis Add 1 to i1; int i4 = i2; //À ce stade, la valeur de i4 est 2, et la valeur de i2 est également 2 ; à i4;

Auto-décrémentation : --

est similaire à l'auto-incrémentation

int i1 = 1;int i2 = 1;int i3 = i1 ; //À ce moment, la valeur de i3 est 1, La valeur de i1 est 0 ; il attribue d'abord la valeur de i1 à i3, puis décrémente i1 de 1 ; la valeur de i4 est 0, et la valeur de i2 est également 0 ; il attribue d'abord la valeur de i2 de 1, puis attribue la valeur à i4

Opérateur relationnel (opérateur de comparaison)

L'opérateur relationnel peut tester la relation entre deux opérandes (Mais la valeur de l'opérande ne sera pas modifiée), le résultat de l'expression relationnelle est booléen vrai/faux :

System.out.println(4 == 4); / /Le résultat est trueSystem.out.println(4 != 3); //Le résultat est trueSystem.out.println(true == false); //Le résultat est faux

Opérateur logique

Les opérateurs logiques sont utilisés pour faire fonctionner des variables ou des constantes de type booléen

Voir exemples

System.out.println(!true); / /Le résultat est falseSystem.out.println(2 > 1 && 1 > 1); 2 > 1 || 1 > 1); //Le résultat est trueSystem.out.(true ^ false); //Le résultat est vrai, XOR, ce qui équivaut à inverser la première valeur précédente, puis effectuer l'opération "OU"

Jetons un coup d'œil à la différence entre ||

int a = 1;int b = 1;if (a == 1 | b > 1){
System.out.println(b ); //La valeur de la sortie b est 2. Bien que le résultat du OU au niveau du bit sur le côté gauche du symbole | , le code sur le côté droit du symbole | sera toujours exécuté pour||
.

int a = 1;int b = 1;if(a == 1 || b > 1){
System.out.println(b); //La valeur de sortie de b est 1, | | Le résultat sur le côté gauche du symbole est vrai, et le code sur le côté droit du symbole || ne sera pas exécuté à nouveau>

Opérateur conditionnel (ternaire opérateur)

Sa forme générale est :

Expression 1 ? Expression 2 : Expression 3

Sur la base du résultat de l'expression 1, il est jugé s'il faut exécuter l'expression 2. ou Expression 3. Si le résultat de l'expression 1 est If true, l'expression 2 sera exécutée, sinon l'expression 3 sera exécutée

les opérateurs conditionnels peuvent remplacer les petites instructions if...else dans certains cas ;

String s = 1 > 2 ? "1 est supérieur à 2" : "1 n'est pas supérieur à 2";
System.out.println(s); que 2

Opérateurs de bits

Les opérateurs de bits participent au fonctionnement de deux données et effectuent des opérations basées sur des bits binaires. Il existe sept opérateurs au niveau du bit en Java : ET au niveau du bit (&), OU au niveau du bit (|), NON au niveau du bit (~), XOR au niveau du bit (^), opérateur de décalage à gauche (> ), opérateur de décalage vers la droite non signé (>>>).

Pour une introduction détaillée, veuillez vous référer à l'article suivant :

http://www.cnblogs.com/yezhenhan/archive/2012/06/20/2555849.html

Priorité des opérateurs

Dans de nombreux cas, une expression est composée de plusieurs opérateurs, et la priorité détermine l'ordre dans lequel les opérateurs sont évalués :

Bien que les opérateurs aient des priorités, une expression sera évaluée séquentiellement en fonction de la priorité des opérateurs d'expression. Cependant, dans la programmation réelle, si une expression est très longue, il n'est pas recommandé de l'écrire ainsi. , il est divisé en Écrit en plusieurs étapes, car la lisibilité de leur écriture ensemble est trop mauvaise.

Ce qui précède est le contenu de [Java Introduction Notes] Java Language Basics (3) : Opérateurs Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !