Voici la traduction de l'article du russe vers le français, en respectant toutes les règles :

Qu'est-ce que c'est et pourquoi ?

Imagine que tu es un robot qui prend des décisions. Par exemple : « S'il pleut dehors, prends un parapluie ». Ou : « Si j'ai 100 roubles ET que je veux une glace, alors achète-la ». En programmation, ces décisions sont prises à l'aide des opérateurs de comparaison (ils comparent des nombres ou du texte) et des opérateurs logiques (ils combinent plusieurs conditions en une seule).

En Java, comme dans la vie, on se pose des questions : « 10 est-il plus grand que 5 ? », « Les deux mots sont-ils égaux ? », « Les deux conditions sont-elles remplies simultanément ? ». Les réponses sont toujours « oui » (true) ou « non » (false). C'est comme un feu tricolore : s'il est vert (true) — on avance, s'il est rouge (false) — on s'arrête.

Pourquoi en avons-nous besoin ? Sans eux, l'ordinateur ne peut pas décider tout seul quoi faire dans différentes situations. Par exemple, dans un jeu : si le joueur n'a plus de vies (vies == 0), alors afficher « Game Over ». Ou dans une calculatrice : si un nombre supérieur à 100 est saisi, alors afficher un avertissement. Les opérateurs de comparaison et les opérateurs logiques sont la base de tout comportement « intelligent » des programmes.

En Python, d'ailleurs, c'est très similaire : on y trouve aussi ==, !=, >, <, >=, <= et les opérateurs logiques and, or, not. Mais en Java, il y a une différence importante : les chaînes de caractères (texte) ne se comparent pas avec ==, mais avec une commande spéciale .equals(). Nous allons détailler cela.

Exemples de code avec explications

Exemple 1 : Comparaison de nombres (simple « plus grand/plus petit »)

// Déclarons des variables avec des nombres
int agePierre = 12;
int agePaul = 14;

// Comparons : l'âge de Pierre est-il supérieur à l'âge de Paul ?
boolean pierrePlusAge = agePierre > agePaul;
System.out.println("Pierre est-il plus âgé que Paul ? " + pierrePlusAge); // Affiche : false

// Comparons : l'âge de Pierre est-il inférieur à l'âge de Paul ?
boolean pierreMoinsAge = agePierre < agePaul;
System.out.println("Pierre est-il plus jeune que Paul ? " + pierreMoinsAge); // Affiche : true

// Vérifions l'égalité
boolean ilsOntMemeAge = agePierre == agePaul;
System.out.println("Ont-ils le même âge ? " + ilsOntMemeAge); // Affiche : false

// Vérifions l'inégalité
boolean ageDifferent = agePierre != agePaul;
System.out.println("Les âges sont-ils différents ? " + ageDifferent); // Affiche : true

Explication : Nous avons créé deux variables avec des nombres. L'opérateur > vérifie si le premier nombre est plus grand que le second. Si oui — la valeur est true, sinon false. L'opérateur < — c'est l'inverse. == vérifie l'égalité (attention : deux signes égal, pas un ! Un seul signe, c'est l'affectation). != — vérifie que les nombres ne sont pas égaux. Le résultat de chaque comparaison est une valeur booléenne true ou false, que nous stockons dans une variable de type boolean (type logique).

Exemple 2 : Comparaison de chaînes de caractères (texte) — différence importante avec Python

String nom1 = "Anna";
String nom2 = "Anna";
String nom3 = "Ivan";

// Comparons les chaînes avec equals (pas avec == !)
boolean annaEtAnnaIdentiques = nom1.equals(nom2);
System.out.println("Nom1 et Nom2 sont-ils identiques ? " + annaEtAnnaIdentiques); // true

boolean annaEtIvanIdentiques = nom1.equals(nom3);
System.out.println("Nom1 et Nom3 sont-ils identiques ? " + annaEtIvanIdentiques); // false

// Comparons sans tenir compte de la casse (majuscules/minuscules)
String nom4 = "anna";
boolean sansTenirCompteCasse = nom1.equalsIgnoreCase(nom4);
System.out.println("Anna et anna (sans tenir compte de la casse) ? " + sansTenirCompteCasse); // true

// Voici ce qu'il NE FAUT PAS faire (nous expliquerons pourquoi dans les erreurs)
boolean comparaisonDangereuse = (nom1 == nom2);
System.out.println("Avec == : " + comparaisonDangereuse); // Peut afficher true, mais c'est un hasard !

Explication : En Java, les chaînes ne sont pas de simples nombres, mais des objets complexes. L'opérateur == vérifie si les chaînes se trouvent au même endroit en mémoire, et non si leur texte est identique. C'est pourquoi on utilise la méthode .equals() pour comparer le texte. Si tu veux comparer sans tenir compte des majuscules/minuscules (par exemple, « Anna » et « anna »), utilise .equalsIgnoreCase(). En Python, d'ailleurs, on peut utiliser == pour les chaînes — cela fonctionne correctement. Mais en Java — souviens-toi : les chaînes uniquement avec equals !

Exemple 3 : Opérateurs logiques — « ET » (&&), « OU » (||), « NON » (!)

int temperature = 25;
boolean ensoleille = true;
boolean vent = false;

// Vérifions une condition complexe : "Aller se promener s'il fait chaud ET qu'il fait soleil"
boolean peutSePromener = (temperature > 20) && ensoleille;
System.out.println("Peut-on se promener ? " + peutSePromener); // true (25 > 20 ET ensoleillé = true)

// Vérifions : "Prendre une veste s'il fait froid OU s'il y a du vent"
boolean prendreVeste = (temperature < 15) || vent;
System.out.println("Faut-il prendre une veste ? " + prendreVeste); // false (NI froid NI venteux)

// Utilisons "NON" : "S'il NE pleut PAS, alors on va se promener"
boolean pleut = false;
boolean nePleutPas = !pleut; // ! transforme false -> true
System.out.println("Il ne pleut pas ? " + nePleutPas); // true

// Exemple complexe : "Rester à la maison s'il fait froid ET (qu'il pleut OU qu'il y a du vent)"
int temperature2 = 10;
boolean pluie = true;
boolean vent2 = false;
boolean resterMaison = (temperature2 < 15) && (pluie || vent2);
System.out.println("Faut-il rester à la maison ? " + resterMaison); // true (froid ET pluie)

Explication : Les opérateurs logiques fonctionnent comme en mathématiques et dans la vie. && (ET) donne true seulement si les deux conditions sont true. || (OU) donne true si au moins une condition est true. ! (NON) inverse la valeur : true devient false, false devient true. En Python, c'est la même chose, mais écrit en toutes lettres : and, or, not. En Java, on utilise des symboles, mais le sens est absolument le même. Les parenthèses aident à définir l'ordre : on calcule d'abord ce qui est entre parenthèses, puis le reste.

Exemple 4 : Utilisation dans if-else (décisions réelles)

int points = 85;
int seuilReussite = 70;

if (points >= seuilReussite) {
    System.out.println("Tu as réussi ! Félicitations !");
} else {
    System.out.println("Essaie encore.");
}