Fondamentaux des Expressions et Calculs

Pour comprendre l'exécution du code, il est essentiel de saisir comment les éléments s'assemblent pour former des expressions. Une expression unit des opérandes (valeurs ou variables) via des symboles opératoires spécifiques. Ces combinaisons permettent d'évaluer des résultats dynamiques lors de l'exécution.

1. Les Opérateurs Mathématiques

Le langage Java fournit un ensemble d'outils pour effectuer des traitements numériques standards. Ces opérateurs manipulent des types entiers comme int ou flottants comme double.

Notez que l'addition sert également à concaténer des chaînes de caractères lorsqu'une chaîne est présente dans l'expression.

package formation.logique;

public class DemosCalculs {
    public static void main(String[] arguments) {
        int valGauche = 20;
        int valDroite = 4;
        int somme;
        
        // Addition classique
        somme = valGauche + valDroite;
        System.out.println("Total calculé : " + valGauche + " + " + valDroite + " = " + somme);
        
        // Concaténation implicite
        System.out.println("Chaîne mixte : " + "" + valGauche + valDroite); 
        
        // Division et Modulo
        System.out.println("Résultat division : " + (valGauche / valDroite));
        System.out.println("Reste modulo : " + (valGauche % valDroite));
    }
}

Gestion des Incréments et Décréments

Les opérateurs unaires ++ et -- modifient la valeur d'une variable de unité. Leur position relative à la variable détermine le moment de l'application de la modification.

• Suffixe (x++) : La valeur actuelle est utilisée dans l'expression, puis la variable est augmentée.
• Préfixe (++x) : La variable est augmentée immédiatement avant d'être utilisée.

package formation.logique;

public class ComptageVariante {
    public static void main(String[] args) {
        int compteur = 10;
        
        // Utilisation de la valeur courante (10), puis incrément
        int resultat1 = compteur + 5; 
        compteur++; 
        System.out.println("Valeur compteur après incrémentation tardive : " + compteur); 
        
        // Utilisation de la valeur incémentée immédiatement
        int resultat2 = (++compteur) + 5;
        System.out.println("Nouveau total : " + resultat2);
    }
}

2. Affectations et Assignations

L'assignation simple utilise le symbole égal =, assignant le résultat de l'expression droite à la variable gauche. Pour optimiser le code, des opérateurs composés existent.

3. Comparaison Relationnelle

Ces opérateurs évaluent la relation entre deux entités et retournent toujours une booléenne (true ou false). Ils servent de base aux décisions logiques.

• > Supérieur à
• < Inférieur à
• >= Supérieur ou égal
• <= Inférieur ou égal
• == Égalité stricte
• != Inégalité

Attention lors de la comparaison de types différents : Java effectue des conversions implicites si les valeurs sont compatibles (ex: entier contre réel).

4. Contrôles de Flux Conditionnels

L'instruction if permet d'exécuter du code uniquement si une condition est remplie. Sa variante if-else offre une alternative lorsque la condition échoue.

package formation.decision;

import java.util.Scanner;

public class AnalysePaiement {
    public static void main(String[] args) {
        Scanner lecteur = new Scanner(System.in);
        
        System.out.println("Entrez le montant du panier : ");
        float total = lecteur.nextFloat();
        
        // Règle spécifique : Remise de 15% si dépassement du seuil
        if (total > 100.0f) {
            System.out.println("Seuil atteint ! Application de remise.");
            total -= total * 0.15f;
        } else {
            System.out.println("Pas de réduction applicable.");
        }
        
        System.out.printf("Montant final : %.2f%n", total);
        lecteur.close();
    }
}

5. Connecteurs Logiques Avancés

Pour construire des conditions complexes, on combine plusieurs tests avec des opérateurs logiques. Il existe deux formes principales pour chaque opérateur : l'une avec comportement "court-circuit", l'autre évaluant tous les termes.

La notion de "court-circuit" (&& et ||) est cruciale pour la performance et la sécurité, car elle évite d'évaluer l'expression droite si le résultat est déjà déterminé par la gauche. En revanche, & et | garantissent l'exécution complète des deux côtés, ce qui est utile si l'expression secondaire contient des effets secondaires (comme une modification de variable).

package formation.booleen;

public class TestEvaluations {
    public static void main(String[] args) {
        int index = 0;
        boolean condition;
        
        // Le AND court-circuit empêche l'exécution de (index++)
        // Si le premier test est faux, le second est ignoré.
        condition = (false) && ((index++) > 0); 
        System.out.println("Index après && : " + index); // Reste 0
        
        index = 0;
        // L'AND bit à bit force l'exécution de (index++)
        condition = (false) & ((index++) > 0);
        System.out.println("Index après & : " + index); // Devient 1
    }
}

6. L'Opérateur Ternaire

C'est une forme condensée du bloc if-else permettant d'attribuer une valeur selon une condition unique. La syntaxe générale suit le modèle : condition ? valeur_si_vrai : valeur_si_faux.

package formation.condense;

public class MaxCompareur {
    public static void main(String[] args) {
        int a = 15;
        int b = 20;
        
        // Sélection directe sans bloc if/else
        int maximum = (a > b) ? a : b;
        System.out.println("Le plus grand chiffre est : " + maximum);
        
        boolean etat = (maximum > 18) ? true : false;
        System.out.println("Est-ce supérieur à 18 ? " + etat);
    }
}

7. Ordre d'Exécution et Hiérarchie

Lorsqu'une expression contient divers symboles, Java respecte une prépondérance stricte. Les opérations parentesiques () priment toujours, suivies des logiques unaires, arithmétiques, relationnelles, puis logiques binaires.

Application Complète : Détection des Années Bissextiles

Un cas concret combinant comparaisons, logiques complexes et entrée utilisateur.

package formation.pratique;

import java.util.Scanner;

public class VerifAnnnee {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        
        System.out.print("Veuillez spécifier une année civile : ");
        int anneeEnCours = scan.nextInt();
        
        // Logique : divisible par 4 ET non par 100 OU divisible par 400
        boolean estBissextile = (anneeEnCours % 4 == 0 && anneeEnCours % 100 != 0) || (anneeEnCours % 400 == 0);
        
        if (estBissextile) {
            System.out.println(anneeEnCours + " est bien une année bissextile.");
        } else {
            System.out.println(anneeEnCours + " n'est pas bissextile.");
        }
        
        scan.close();
    }
}