Appliquer opérateurs unaires

Par définition, un opérateur unaire en Java est un opérateur qui nécessite exactement un opérande, ou variable, pour fonctionner. Comme illustré dans le Tableau 2.2, ils effectuent souvent des tâches simples, comme l’incrémentation d’une variable numérique ou la négation d’une valeur booléenne.

Opérateur	Exemples	Description
Complément logique	!a	Inverse la valeur logique d’un booléen
Complément binaire	~b	Inverse tous les 0 et 1 dans un nombre
Plus	+c	Indique qu’un nombre est positif (les nombres sont supposés positifs en Java sauf si accompagnés d’un opérateur unaire négatif)
Négation ou moins	-d	Indique qu’un nombre littéral est négatif ou nie une expression
Incrémentation	++e f++	Incrémente une valeur de 1
Décrémentation	–f h–	Décrémente une valeur de 1
Cast	(String)i	Convertit une valeur vers un type spécifique

Les Opérateurs de Complément et de Négation

Commençons par l’opérateur booléen, puisque nous allons travailler avec beaucoup d’opérateurs numériques par la suite. L’opérateur de complément logique (!) inverse la valeur d’une expression booléenne. Par exemple, si la valeur est true, elle sera convertie en false, et vice versa. Pour illustrer cela, comparons les sorties des instructions suivantes :

boolean estAnimalEndormi = false;
System.out.print(estAnimalEndormi); // false
estAnimalEndormi = !estAnimalEndormi;
System.out.print(estAnimalEndormi); // true

Il est également important de connaître l’opérateur de complément binaire (~), qui inverse tous les 0 et 1 d’un nombre. Il ne peut être appliqué qu’aux types numériques entiers comme byte, short, char, int, et long. Essayons un exemple. Pour plus de simplicité, nous ne montrons que les quatre derniers bits (au lieu des 32 bits).

int valeur = 3; // Stocké comme 0011
int complement = ~valeur; // Stocké comme 1100
System.out.println(valeur); // 3
System.out.println(complement); // -4

Pour trouver le complément binaire d’un nombre, multipliez-le par moins un puis soustrayez un.

System.out.println(-1*valeur - 1); // -4
System.out.println(-1*complement - 1); // 3

Passons aux opérateurs plus courants. L’opérateur de négation (-) inverse le signe d’une expression numérique, comme montré dans ces instructions :

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

Notez que dans le dernier exemple, nous avons utilisé des parenthèses () pour l’opérateur de négation (-) afin d’appliquer la négation deux fois. Si nous avions écrit — à la place, cela aurait été interprété comme l’opérateur de décrémentation et aurait affiché -2.21.

Certains opérateurs nécessitent que la variable ou l’expression sur laquelle ils agissent soit d’un type spécifique. Par exemple, vous ne pouvez pas appliquer un opérateur de négation (-) à une expression booléenne, ni appliquer un opérateur de complément logique (!) à une expression numérique. Voici des exemples qui ne compileront pas :

int pelican = !5; // NE COMPILE PAS
boolean pingouin = -true; // NE COMPILE PAS
boolean paon = !0; // NE COMPILE PAS

En Java, contrairement à certains autres langages de programmation, 1 et true ne sont pas liés, tout comme 0 et false ne le sont pas.

Les Opérateurs d’Incrémentation et de Décrémentation

Les opérateurs d’incrémentation (++) et de décrémentation (–) sont particulièrement utiles lorsque vous travaillez avec des variables numériques. Ils ont une priorité d’exécution élevée par rapport aux opérateurs binaires, ce qui signifie qu’ils sont souvent appliqués en premier dans une expression.

Comprendre la Différence Entre Pré et Post

Voici un point crucial : l’ordre dans lequel vous placez ces opérateurs fait une vraie différence dans votre code. Regardons comment ils fonctionnent :

Opérateur	Exemple	Description
Pré-incrémentation	++w	Augmente la valeur de 1 et renvoie la nouvelle valeur
Pré-décrémentation	–x	Diminue la valeur de 1 et renvoie la nouvelle valeur
Post-incrémentation	y++	Augmente la valeur de 1 mais renvoie la valeur originale
Post-décrémentation	z–	Diminue la valeur de 1 mais renvoie la valeur originale

Pour bien comprendre la différence, examinons cet exemple concret :

int visitesParc = 0;
System.out.println(visitesParc); // Affiche 0
System.out.println(++visitesParc); // Affiche 1
System.out.println(visitesParc); // Affiche 1
System.out.println(visitesParc--); // Affiche 1
System.out.println(visitesParc); // Affiche 0

Analysons ce qui se passe :

• Avec ++visitesParc (pré-incrémentation), la valeur est d’abord augmentée, puis la nouvelle valeur (1) est affichée.
• Avec visitesParc-- (post-décrémentation), l’ancienne valeur (1) est d’abord affichée, puis la valeur est diminuée à 0.

Imaginez que vous comptez les visiteurs d’un parc : la pré-incrémentation, c’est comme annoncer “Un nouveau visiteur vient d’entrer !” alors que la post-incrémentation, c’est comme dire “Voici notre compte actuel, et maintenant j’ajoute le nouveau visiteur”.

Cette distinction est particulièrement importante lorsque vous utilisez ces opérateurs dans des expressions plus complexes. Par exemple :

int nombreVisiteurs = 10;
int groupeVisiteurs = 5;
int total = nombreVisiteurs + ++groupeVisiteurs; // total sera 16
System.out.println("Groupe : " + groupeVisiteurs); // Affiche 6
System.out.println("Total : " + total); // Affiche 16
nombreVisiteurs = 10;
groupeVisiteurs = 5;
total = nombreVisiteurs + groupeVisiteurs++; // total sera 15
System.out.println("Groupe : " + groupeVisiteurs); // Affiche 6
System.out.println("Total : " + total); // Affiche 15