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 caissier dans un magasin de bonbons. Tu as une boîte de 10 chocolats, et un client arrive qui veut en acheter 3. Combien en restera-t-il ? Et si demain on apporte 5 boîtes de 10 chocolats — combien y en aura-t-il en tout ? Pour calculer cela, il n'est pas nécessaire de compter chaque bonbon avec le doigt. Il suffit d'effectuer des opérations arithmétiques — addition, soustraction, multiplication et division.

En Java, ces opérations ressemblent presque à celles des mathématiques, sauf qu'au lieu du signe de multiplication « × », on écrit *, et au lieu du signe de division « ÷ », on écrit /. L'ordinateur est comme ce caissier, mais très rapide et ne faisant jamais d'erreur (si tu ne te trompes pas dans la commande).

Pourquoi en a-t-on besoin en programmation ? Imagine que tu écris un jeu où le héros ramasse des pièces. Chaque seconde, il faut ajouter à son score le nombre de pièces ramassées. Ou tu fabriques une calculatrice pour les cours de maths. Ou un programme qui calcule combien de jours il reste avant le Nouvel An. Partout, on a besoin d'opérations arithmétiques.

En Java, il y a 5 opérations arithmétiques de base :

• + — addition (comme en maths)
• - — soustraction
• * — multiplication
• / — division (mais en Java, il y a une astuce avec les nombres entiers)
• % — reste de la division (c'est nouveau ! Il montre ce qu'il reste si on divise entièrement)

Mettons-nous d'accord tout de suite : en Java, comme en Python, il y a des types de données. Pour les nombres, on utilise le plus souvent int (nombres entiers, par exemple 5, -3, 100) et double (nombres décimaux, par exemple 3.14, -0.5). Si tu les mélanges dans une même opération, Java se débrouillera tout seul, mais cela peut parfois donner des résultats inattendus (nous en discuterons dans les erreurs).

Contrairement à Python, où on peut simplement écrire print(2 + 3) et tout fonctionne, en Java, il faut d'abord créer une classe et une méthode main. N'aie pas peur — c'est juste un « conteneur » pour ton programme. Tous les exemples ci-dessous seront à l'intérieur d'un tel conteneur.

Exemples de code avec explications

Exemple 1 : Addition et soustraction (comme dans la vie)

Imagine que tu avais 15 euros, tu en as trouvé 7, puis tu en as dépensé 10 pour une glace. Combien te reste-t-il ?

public class Main {
    public static void main(String[] args) {
        // Déclarons des variables — ce sont comme des boîtes avec des étiquettes
        int bylo = 15;          // Avait 15 euros
        int nashel = 7;         // A trouvé 7 euros
        int potratil = 10;      // A dépensé 10 euros

        // Calculons : avait + trouvé - dépensé
        int ostalos = bylo + nashel - potratil;

        // Affichons le résultat à l'écran
        // En Java, pour afficher, on utilise System.out.println()
        System.out.println("Il te reste : " + ostalos + " euros");
        // À l'écran apparaîtra : Il te reste : 12 euros
    }
}

Comment ça marche : Java exécute les actions de gauche à droite, comme en maths. D'abord 15 + 7 = 22, puis 22 - 10 = 12. Le résultat est stocké dans la variable ostalos. Le signe + dans System.out.println est utilisé pour concaténer du texte et des nombres — on appelle cela la concaténation. En Python, on utilise des virgules ou des f-strings, tandis qu'en Java, on utilise le signe plus.

Exemple 2 : Multiplication (calcul de la surface d'une pièce)

Tu as décidé de savoir combien de mètres carrés fait ta chambre. La longueur est de 6 mètres, la largeur de 4 mètres.

public class Main {
    public static void main(String[] args) {
        int dlina = 6;
        int shirina = 4;

        // Multiplication : surface = longueur * largeur
        int ploshad = dlina * shirina;

        System.out.println("Surface de la chambre : " + ploshad + " m²");
        // Affichage : Surface de la chambre : 24 m²

        // Calculons maintenant le périmètre : (longueur + largeur) * 2
        int perimetr = (dlina + shirina) * 2;
        System.out.println("Périmètre de la chambre : " + perimetr + " m");
        // Affichage : Périmètre de la chambre : 20 m
    }
}

Fais attention aux parenthèses ! En Java, comme en maths, les opérations entre parenthèses sont effectuées en premier. Si on avait écrit dlina + shirina * 2, on aurait d'abord multiplié 4 par 2 (ce qui donne 8), puis ajouté 6 — résultat 14, et non 20. Les parenthèses changent l'ordre !

En Python, les parenthèses fonctionnent exactement de la même manière — c'est une règle commune à tous les langages de programmation.

Exemple 3 : Division et reste (partage d'une pizza)

Tu as 23 parts de pizza et 5 amis. Combien de parts chacun recevra-t-il si on partage équitablement ? Combien te restera-t-il ?

public class Main {
    public static void main(String[] args) {
        int kuskov = 23;
        int druzei = 5;

        // Division entière : 23 / 5 = 4 (reste 3)
        // Java supprime la partie décimale si les deux nombres sont entiers !
        int kazhdomu = kuskov / druzei;
        System.out.println("Chaque ami : " + kazhdomu + " parts");
        // Affichage : Chaque ami : 4 parts

        // Reste de la division : 23 % 5 = 3
        int ostatok = kuskov % druzei;
        System.out.println("Il te restera : " + ostatok + " parts");
        // Affichage : Il te restera : 3 parts

        // Vérification : 4 * 5 + 3 = 23 — tout est correct !
    }
}

Point important : En Java, si tu divises un nombre entier par un nombre entier, le résultat sera également entier — la partie décimale est simplement supprimée (pas arrondie, mais supprimée !). 23 / 5 = 4, et non 4.6. Si tu veux un résultat décimal, au moins un des nombres doit être décimal (par exemple, 23.0 / 5 ou 23 / 5.0). En Python 3, la division de nombres entiers donne un résultat décimal par défaut, et pour la division entière, on utilise //. En Java, il n'y a pas un tel opérateur — il faut spécifier explicitement le type.

L'opérateur % (reste)