Travailler avec des opérateurs unaires

Par définition, un opérateur unaire est celui qui nécessite exactement un opérande, ou une variable, pour
fonction.Ils effectuent souvent des tâches simples, comme augmenter un
variable numérique par un, ou en annulant une valeur booléenne.

Opérateurs de complément logique et de négation
L'opérateur de complément logique, !, inverse la valeur d'une expression booléenne. Par exemple,
si la valeur est vraie, elle sera convertie en faux, et vice versa. Pour illustrer cela, comparez
les sorties des déclarations suivantes :

boolean x = false;
System.out.println(x); // false
x = !x;
System.out.println(x); // true

De même, l'opérateur de négation, -, inverse le signe d'une expression numérique, comme indiqué
dans ces déclarations :

double x = 1.21;
System.out.println(x); // 1.21
x = -x;
System.out.println(x); // -1.21
x = -x;
System.out.println(x); // 1.21

D'après la description, il peut être évident que certains opérateurs nécessitent la variable
ou l’expression sur laquelle ils agissent est d’un type spécifique. Par exemple, vous ne pouvez pas postuler
un opérateur de négation, -, à une expression booléenne, et vous ne pouvez pas non plus appliquer un complément logique
opérateur, !, à une expression numérique. Méfiez-vous des questions de l'examen qui tentent de faire cela,
car ils entraîneront l’échec de la compilation du code. Par exemple, aucune des lignes de code suivantes
va compiler :

int x = !5; // DOES NOT COMPILE
boolean y = -true; // DOES NOT COMPILE
boolean z = !0; // DOES NOT COMPILE

La première instruction ne sera pas compilée car en Java, vous ne pouvez pas effectuer un
inversion logique d'une valeur numérique. La deuxième instruction ne compile pas parce que vous
ne peut pas nier numériquement une valeur booléenne ; vous devez utiliser l'opérateur inverse logique.
Enfin, la dernière instruction ne compile pas car vous ne pouvez pas prendre le complément logique d'une valeur numérique, ni attribuer un entier à une variable booléenne.

en Java 1 et true ne sont pas liés dans
de toute façon, tout comme 0 et false ne sont pas liés.

Opérateurs d'incrémentation et de décrémentation
Les opérateurs d'incrémentation et de décrémentation, et --, respectivement, peuvent être appliqués aux numériques
opérandes et ont l’ordre ou la priorité le plus élevé par rapport aux opérateurs binaires. Dans
en d'autres termes, ils sont souvent appliqués en premier à une expression.
Les opérateurs d'incrémentation et de décrémentation nécessitent une attention particulière car l'ordre dans lequel ils sont
appliqué à leur opérande associé peut faire une différence dans la façon dont une expression est traitée. Si l'opérateur est placé avant l'opérande, appelé l'opérateur de pré-incrémentation et l'opérateur de pré-décrémentation, alors l'opérateur est appliqué en premier et la valeur renvoie
est la nouvelle valeur de l'expression. Alternativement, si l'opérateur est placé après l'opérande,
appelé opérateur de post-incrémentation et opérateur de post-décrémentation, alors la valeur d'origine de l'expression est renvoyée, avec l'opérateur appliqué après le retour de la valeur.
Voici l'exemple d'illustration :

boolean x = false;
System.out.println(x); // false
x = !x;
System.out.println(x); // true

Le premier opérateur de pré-incrémentation met à jour la valeur du compteur et génère le nouveau
valeur de 1. L'opérateur de post-décrémentation suivant met également à jour la valeur du compteur mais génère
la valeur avant que la décrémentation ne se produise.
Une pratique courante lors d'un examen de certification, bien que moins courante dans le monde réel, consiste à
appliquer plusieurs opérateurs d'incrémentation ou de décrémentation à une seule variable sur la même ligne :

double x = 1.21;
System.out.println(x); // 1.21
x = -x;
System.out.println(x); // -1.21
x = -x;
System.out.println(x); // 1.21

Celui-ci est plus compliqué que l'exemple précédent car x est modifié trois
fois sur la même ligne. A chaque fois qu'elle est modifiée, au fur et à mesure que l'expression se déplace de gauche à droite,
la valeur de x change, différentes valeurs étant attribuées à la variable. Comme vous vous en souviendrez
d'après notre discussion sur la priorité des opérateurs, l'ordre des opérations joue un rôle important dans
évaluer cet exemple.
Alors comment lire ce code ? Tout d'abord, le x est incrémenté et renvoyé à l'expression,
qui est multiplié par 5. On peut simplifier cela :

int x = !5; // DOES NOT COMPILE
boolean y = -true; // DOES NOT COMPILE
boolean z = !0; // DOES NOT COMPILE

Ensuite, x est décrémenté, mais la valeur d'origine de 4 est utilisée dans l'expression, conduisant à
ceci :

int counter = 0;
System.out.println(counter); // Outputs 0
System.out.println(++counter); // Outputs 1
System.out.println(counter); // Outputs 1
System.out.println(counter--); // Outputs 1
System.out.println(counter); // Outputs 0

L'affectation finale de x réduit la valeur à 2, et comme il s'agit d'un opérateur de pré-incrémentation, cette valeur est renvoyée à l'expression :

int x = 3;
int y = ++x * 5 / x-- + --x;
System.out.println("x is " + x);
System.out.println("y is " + y);

Enfin, on évalue le multiple et la division de gauche à droite, et on termine par l'addition. Le résultat est ensuite imprimé :

int y = 4 * 5 / x-- + --x; // x assigned value of 4

Pour conclure, les opérateurs unaires simplifient et rationalisent le code en permettant des opérations rapides à un seul opérande telles que l'incrémentation, la négation ou l'inversion de valeurs. Ils sont essentiels pour une logique efficace, des expressions compactes et un contrôle concis des données, améliorant ainsi la lisibilité et la fonctionnalité de la programmation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!