Opérations arithmétiques
Commençons par le plus simple : les opérations arithmétiques. Il s'agit des célèbres additions (+ signe), soustraction (-), multiplication (*) et division (/).public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
System.out.println(x+y);
System.out.println(x-y);
System.out.println(x*y);
System.out.println(x/y);
}
}
Sortie de la console :
1032
966
32967
30
Vous avez déjà utilisé tout cela. Vous pouvez leur ajouter une opération %
- le reste de la division.
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 33%2;
System.out.println(y);
}
}
Sortie de la console :
1
Dans cet exemple, nous divisons 33 par 2. En conséquence, nous obtenons 16 et il reste une « queue » supplémentaire qui n'est pas divisible par 2 - un. Cette « queue » sera le résultat de l'opération « reste de division ». Java (ainsi que les mathématiques) implémente des opérateurs de comparaison . Vous les connaissez probablement aussi à l'école :
- équivaut à (
==
) - plus (
>
) - moins (
<
) - Plus grand ou égal à (
>=
) - inférieur ou égal à (
<=
) - inégal (
!=
)
==
, et non avec un seul signe =
. Le signe d'unité =
en Java est un opérateur d'affectation, dans lequel une variable se voit attribuer un nombre, une chaîne ou la valeur d'une autre variable.
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x=y);// expect false to be printed to the console
}
}
Sortie de la console :
999
Oops! Ce n’est clairement pas le résultat auquel nous nous attendions. Il s’agit d’un type de données complètement différent : nous nous attendions à voir boolean
, mais nous avons obtenu un nombre. En effet, entre parenthèses, nous avons une opération d'affectation, pas une comparaison. x=y
La valeur y
(999) a été attribuée à la variable x
, puis nous l'avons imprimée x
sur la console. Bonne option :
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x==y);
}
}
Sortie de la console :
false
Nous avons maintenant correctement comparé les 2 chiffres ! :) Une autre particularité de l'opération d'affectation ( =
) est qu'elle peut être effectuée « enchaînée » :
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
int z = 256;
x = y = z;
System.out.println(x);
}
}
Sortie de la console :
256
N'oubliez pas : l'affectation se fait de droite à gauche. Cette expression ( x = y = z
) sera exécutée par étapes :
- y = z, c'est-à-dire y = 256
- x = y, soit x = 256
Opérations unaires
Ils sont appelés « unaires » du mot « uno » - « un ». Ils ont reçu ce nom car, contrairement aux précédents, ils sont réalisés sur un seul numéro, et non sur plusieurs. Ceux-ci inclus:-
Unaire moins. Il inverse le signe du nombre.
public class Main { public static void main(String[] args) { int x = 999; // change the sign for the first time x = -x; System.out.println(x); // change the sign a second time x= -x; System.out.println(x); } }
Sortie de la console :
-999 999
Nous avons utilisé le moins unaire deux fois. En conséquence, notre chiffre est devenu négatif d’abord, puis à nouveau positif !
-
Incrément (
++
) et décrément (--
)Une opération
++
augmente un nombre de un, et une opération--
le diminue de la même unité.public class Main { public static void main(String[] args) { int x = 999; x++; System.out.println(x); x--; System.out.println(x); } }
Sortie de la console :
1000 999
x++
- notation postfixe ++x
- notation préfixe Quelle est la différence fondamentale si vous mettez des plus et des moins avant ou après le nombre ? Voyons dans un exemple :
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
}
}
Sortie de la console :
999
Y a-t-il quelque chose qui ne va pas! Nous voulions incrémenter x
de 1 et attribuer une nouvelle valeur à la variable y
. Autrement dit, y devrait être égal à 1000. Mais nous avons un résultat différent - 999. Il s'avère qu'il x
n'a pas été augmenté et que l'opération d'incrémentation n'a pas fonctionné ? Comment ça a fonctionné. Pour vérifier cela, essayez d'imprimer x sur la console à la fin :)
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
System.out.println(x);
}
}
Sortie de la console :
999
1000
En fait, c'est pourquoi l'opération postfix est appelée ainsi : elle est effectuée après l'expression principale. Autrement dit, dans notre cas : int y = x++;
il est d'abord exécuté y = x
(et la variable y se verra attribuer la valeur initiale x
), et seulement ensuite x++
. Et si nous ne sommes pas satisfaits de ce comportement ? Vous devez utiliser la notation de préfixe :
public class Main {
public static void main(String[] args) {
int x = 999;
int y = ++x;
System.out.println(y);
}
}
Dans ce cas, cela fonctionnera d'abord ++x
et seulement après. y = x;
Cette différence mérite d'être rappelée tout de suite pour ne pas se tromper dans un programme réel, dans lequel tous les comportements peuvent être bouleversés à cause de cela :)
Opérations combinées
De plus, en Java, il existe des opérations dites combinées. Ils utilisent une combinaison de deux opérations :- Affectation
- Opération arithmétique
+=
-=
*=
/=
%=
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
x += y;
System.out.println(x);
}
}
Sortie de la console :
1032
x += y
moyens x = x + y
. Par souci de concision, deux caractères consécutifs sont utilisés. Cela fonctionne également avec des combinaisons de -=
, *=
, /=
et %=
.
Opérations logiques
En plus des opérations sur les nombres, Java propose également des opérations sur les variables booléennes -true
et false
. Ces opérations sont effectuées à l'aide d'opérateurs logiques
-
!
— Opérateur « NON ». Inverse la valeur d'une variable booléennepublic class Main { public static void main(String[] args) { boolean x = true; System.out.println(!x); } }
Sortie de la console :
false
-
&&
— l'opérateur "ET". Renvoie une valeurtrue
uniquement si les deux opérandes sonttrue
.public class Main { public static void main(String[] args) { System.out.println(100 > 10 && 100 > 200); System.out.println(100 > 50 && 100 >= 100); } }
Sortie de la console :
false true
Le résultat de la première opération est
false
, puisqu'une des conditions est fausse, à savoir 100 > 200. L'opérateur exige que toutes les conditions soient vraies (comme dans la deuxième ligne par exemple)&&
pour renvoyer .true
-
||
— Opérateur « OU ». Renvoietrue
lorsqu'au moins un des opérandes est vrai.Ici, notre exemple précédent fonctionnera différemment :
public class Main { public static void main(String[] args) { System.out.println(100 > 10 || 100 > 200); } }
Sortie de la console :
true
Выражение 100 > 200 по-прежнему ложно, но оператору “or” вполне достаточно, что первая часть (100 > 10) является истинной.
GO TO FULL VERSION