Module 2 - Logique et Structures de Contrôle

1. Les Opérateurs : La Boîte à Outils de la Logique

Les opérateurs sont les symboles qui vous permettent de manipuler des variables et de formuler des questions. Ils sont essentiels pour créer une logique dans vos programmes.

Opérateurs Arithmétiques

Ce sont les bases du calcul. Vous les connaissez certainement depuis l'école.

Opérateur	Symbole	Exemple	Résultat
Addition	+	10 + 5	15
Soustraction	-	10 - 5	5
Multiplication	*	10 * 5	50
Division	/	10 / 5	2
Modulo (reste)	%	10 % 3	1

Attention à la Division Entière

Si vous divisez deux entiers (int), le résultat sera un entier (la partie décimale est tronquée). Pour obtenir un résultat précis, au moins un des nombres doit être un double.

5 / 2 = 2 (division entière)

5.0 / 2.0 = 2.5 (division décimale)

Raccourcis Utiles

→ Incrémenter : ++

x++ est équivalent à x = x + 1

→ Décrémenter : --

x-- est équivalent à x = x - 1

Opérateurs de Comparaison

Ils servent à poser des questions et le résultat est toujours un boolean (true ou false).

Opérateur	Symbole	Exemple	Résultat
Égal à	==	5 == 5	true
Pas égal à	!=	5 != 3	true
Supérieur à	>	10 > 5	true
Inférieur à	<	3 < 5	true
Supérieur ou égal	>=	5 >= 5	true
Inférieur ou égal	<=	3 <= 5	true

Erreur Classique à Éviter

Ne confondez jamais = (assignation : "mets cette valeur dans la variable") et == (comparaison : "cette valeur est-elle égale à celle-ci ?").

Opérateurs Logiques

Ils permettent de combiner plusieurs conditions.

→ && (ET logique)

Vrai uniquement si toutes les conditions sont vraies.

Analogie : "Pour aller au cinéma, je dois avoir de l'argent ET avoir du temps libre."

→ || (OU logique)

Vrai si au moins une des conditions est vraie.

Analogie : "Pour le dîner, je mangerai une pizza OU des pâtes."

→ ! (NON logique)

Inverse la valeur d'un booléen.

Exemple : !true devient false

public class DemoOperateursLogiques {
    public static void main(String[] args) {
        int age = 20;
        boolean aLePermis = true;

        if (age >= 18 && aLePermis) {
            System.out.println("Vous pouvez conduire la voiture.");
        }
    }
}
            

Pour aller plus loin :

Source: EvoluNoob

2. Prise de Décision : Les Structures Conditionnelles

Les structures conditionnelles permettent à votre programme de prendre des décisions et de suivre différents chemins en fonction des conditions.

if, else if, else : Le Chemin à Plusieurs Voies

if (Si)

Le premier chemin. Si la condition est vraie, on exécute ce bloc et on ignore le reste.

else if (Sinon si)

Un chemin alternatif. Si le if précédent était faux, on teste cette nouvelle condition. On peut en avoir plusieurs.

else (Sinon)

La voie par défaut. Si aucune des conditions précédentes n'était vraie, on exécute ce bloc.

public class Conditions {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("Excellent ! Grade A.");
        } else if (score >= 80) {
            System.out.println("Très bien. Grade B.");
        } else {
            System.out.println("Passable. Grade C ou inférieur.");
        }
    }
}
            

Résultat : Très bien. Grade B.

switch : L'Aiguillage

Quand vous avez une seule variable à comparer avec de nombreuses valeurs possibles, une longue suite de if-else if peut devenir lourde. Le switch est une alternative plus propre et plus lisible.

public class DemoSwitch {
    public static void main(String[] args) {
        int jourDeLaSemaine = 4; // 1 = Lundi, 2 = Mardi, etc.
        String nomDuJour;

        switch (jourDeLaSemaine) {
            case 1:
                nomDuJour = "Lundi";
                break;
            case 2:
                nomDuJour = "Mardi";
                break;
            case 3:
                nomDuJour = "Mercredi";
                break;
            case 4:
                nomDuJour = "Jeudi";
                break;
            case 5:
                nomDuJour = "Vendredi";
                break;
            default:
                nomDuJour = "Weekend";
                break;
        }
        System.out.println("Aujourd'hui nous sommes " + nomDuJour);
    }
}
            

Résultat : Aujourd'hui nous sommes Jeudi

L'Importance du break

Le break est crucial pour sortir du switch. Sans lui, l'exécution continue dans les cas suivants (« fall-through »). Le default s'exécute si aucune autre case ne correspond.

Pour aller plus loin :

Source: EvoluNoob

3. Répéter des Actions : Les Boucles

Les boucles sont un concept fondamental pour éviter la répétition de code (principe DRY : Don't Repeat Yourself).

La Boucle for : La Répétition Contrôlée

Utilisez for quand vous savez exactement combien de fois vous voulez répéter une action. Sa syntaxe se décompose en trois parties :

for ( initialisation ; condition ; mise_à_jour )

Initialisation : Exécutée une seule fois au tout début (ex: int i = 0).
Condition : Vérifiée avant chaque tour de boucle. Si c'est true, on continue.
Mise à jour : Exécutée à la fin de chaque tour de boucle (ex: i++).

public class BoucleFor {
    public static void main(String[] args) {
        // Cette boucle va s'exécuter 5 fois (pour i de 0 à 4)
        for (int i = 0; i < 5; i++) {
            System.out.println("Le compteur est à : " + i);
        }
    }
}
            

La Boucle while : La Répétition Conditionnelle

Utilisez while quand vous voulez répéter une action tant qu'une condition reste vraie, sans savoir à l'avance combien de tours cela prendra.

Analogie : "Tant que la batterie du téléphone n'est pas à 100%, continuer à charger."

public class BoucleWhile {
    public static void main(String[] args) {
        int munitions = 5;

        while (munitions > 0) {
            System.out.println("Pan ! Il reste " + (munitions - 1) + " munitions.");
            munitions--;
        }
        System.out.println("Chargeur vide !");
    }
}
            

Résultat :

Pan ! Il reste 4 munitions.
Pan ! Il reste 3 munitions.
Pan ! Il reste 2 munitions.
Pan ! Il reste 1 munitions.
Pan ! Il reste 0 munitions.
Chargeur vide !
            

Pour aller plus loin :

Source: EvoluNoob

Attention à la Boucle Infinie

La condition doit pouvoir devenir fausse un jour ! Sinon, la boucle s'exécutera indéfiniment.

La Boucle do-while : Exécuter au Moins une Fois

Cette boucle est une variante de while. Sa particularité est que la condition est vérifiée à la fin de chaque tour. Cela garantit que le code à l'intérieur de la boucle sera exécuté au moins une fois.

Analogie : Un menu dans un jeu. Vous voulez afficher les options au moins une fois avant de demander à l'utilisateur s'il veut quitter.

import java.util.Scanner;

public class DemoDoWhile {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int choix;

        do {
            System.out.println("--- MENU ---");
            System.out.println("1. Jouer");
            System.out.println("2. Options");
            System.out.println("3. Quitter");
            System.out.print("Votre choix : ");
            choix = scanner.nextInt();
        } while (choix != 3);

        System.out.println("Merci d'avoir joué !");
        scanner.close();
    }
}
            

4. Entrées et Sorties avec Scanner

Pour qu'un programme soit interactif, il doit pouvoir lire les informations que l'utilisateur saisit. C'est le rôle des entrées. De la même manière, il doit pouvoir communiquer un résultat à l'utilisateur, ce qui est le rôle des sorties.

En Java, nous avons déjà vu la sortie avec System.out.println(). Pour les entrées, nous utilisons la classe Scanner.

Créer et Utiliser un Objet Scanner

Pour commencer à lire les entrées, il faut d'abord créer un objet de la classe Scanner. On lui indique que la source des données est l'entrée standard du système (System.in), qui correspond au clavier.

Scanner scanner = new Scanner(System.in);

Une fois que l'objet scanner est créé, vous pouvez utiliser ses méthodes pour lire différents types de données :

scanner.nextLine()

Lit une ligne de texte complète, jusqu'à ce que l'utilisateur appuie sur la touche Entrée. Idéale pour récupérer une chaîne de caractères (String).

scanner.nextInt()

Lit un nombre entier (int). Si l'utilisateur tape du texte à la place d'un nombre, le programme générera une erreur.

scanner.nextDouble()

Lit un nombre décimal (double).

Les Bonnes Pratiques avec Scanner

Guider l'utilisateur : Avant de demander une entrée, affichlez un message clair avec System.out.print(). Cela évite la confusion.
Fermer le Scanner : Une fois que vous n'avez plus besoin de l'objet Scanner, fermez-le avec scanner.close(). Cela libère les ressources système.

Exemple 1 : Récupérer des Informations de l'Utilisateur

import java.util.Scanner;

public class UserInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Entrez votre nom: ");
        String name = scanner.nextLine();

        System.out.print("Entrez votre âge: ");
        int age = scanner.nextInt();

        System.out.println("Bonjour " + name + ", vous avez " + age + " ans.");

        scanner.close();
    }
}
            

Exemple 2 : Effectuer des Calculs avec des Entrées Utilisateur

import java.util.Scanner;

public class BasicMath {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Entrez un premier nombre entier: ");
        int number1 = scanner.nextInt();

        System.out.print("Entrez un second nombre entier: ");
        int number2 = scanner.nextInt();

        int sum = number1 + number2;
        int product = number1 * number2;

        System.out.println("La somme de " + number1 + " et " + number2 + " est: " + sum);
        System.out.println("Le produit de " + number1 + " et " + number2 + " est: " + product);

        scanner.close();
    }
}
            

5. Conversions de Types

En Java, chaque variable a un type de données spécifique (comme int, double, String, etc.). Parfois, vous avez besoin de convertir une valeur d'un type à un autre. Ce processus s'appelle le casting. Il existe deux types de conversions : implicite et explicite.

Conversion Implicite (Widening)

La conversion implicite, ou "élargissement", se produit automatiquement. Elle a lieu lorsque vous convertissez un type de données plus petit vers un type plus grand, sans risque de perte d'informations.

Analogie : Verser de l'eau d'un petit verre dans un grand verre : il n'y a aucun débordement.

Cela se produit quand vous passez d'un type à une "plage de valeurs" plus large :

byte → short → int → long
int → float → double

public class TypeCasting {
    public static void main(String[] args) {
        int intValue = 100;
        double doubleValue = intValue;
        System.out.println("Conversion implicite: " + doubleValue);
    }
}
            

Résultat : Conversion implicite: 100.0

Conversion Explicite (Narrowing)

La conversion explicite, ou "rétrécissement", n'est pas automatique. Le compilateur vous oblige à le faire manuellement en utilisant des parenthèses (type). Cela est nécessaire lorsque vous convertissez un type de données plus grand vers un type plus petit. Il y a un risque de perte de données.

Analogie : Verser de l'eau d'un grand verre dans un petit : une partie de l'eau risque de déborder et d'être perdue.

Cela se produit quand vous passez d'un type à une "plage de valeurs" plus étroite :

double → float
double → int
long → int

public class TypeCasting {
    public static void main(String[] args) {
        double anotherDouble = 9.78;
        // On force la conversion en int. La partie décimale (.78) est perdue.
        int narrowedInt = (int) anotherDouble;
        System.out.println("Conversion explicite: " + narrowedInt);
    }
}
            

Résultat : Conversion explicite: 9

Conversion entre String et Types Numériques

Un cas de conversion très fréquent est de passer d'une chaîne de caractères (String) à un nombre et vice-versa. C'est particulièrement utile lorsque vous lisez une entrée de l'utilisateur (qui est toujours lue en tant que String par Scanner.nextLine()) et que vous devez la traiter comme un nombre.

Pour cela, vous utilisez les classes enveloppes (wrapper classes) comme Integer ou Double.

Integer.parseInt(votreString)

Convertit une chaîne de caractères en un int.

Double.parseDouble(votreString)

Convertit une chaîne de caractères en un double.

Exemple 3 : Conversion de Chaînes en Types Numériques

import java.util.Scanner;

public class StringToNumber {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Entrez votre âge (en texte): ");
        String inputAge = scanner.nextLine();
        // Le texte "25" est converti en le nombre entier 25.
        int age = Integer.parseInt(inputAge);
        System.out.println("Vous avez " + age + " ans.");

        scanner.close();
    }
}
            

Attention aux Erreurs de Conversion

Si l'utilisateur entre un texte qui ne peut pas être converti en nombre (comme "trente"), votre programme se terminera avec une erreur. C'est un aspect important de la gestion des erreurs que vous apprendrez plus tard.

Exemple 4 : Conversions entre Types Primitifs

public class PrimitiveConversion {
    public static void main(String[] args) {
        // Conversion de int à long : implicite
        int smallNumber = 100;
        long largeNumber = smallNumber;
        System.out.println("int converti en long: " + largeNumber);

        // Conversion de double à float : explicite
        double doubleValue = 10.5;
        float floatValue = (float) doubleValue;
        System.out.println("double converti en float: " + floatValue);
    }
}
            

Résultat :

int converti en long: 100
double converti en float: 10.5
            

À Retenir

Comprendre ces règles est essentiel pour éviter les erreurs de compilation et les problèmes de logique dans vos programmes. Les conversions implicites se font automatiquement vers des types plus grands. Les conversions explicites nécessitent un casting manuel vers des types plus petits.

Exercices Pratiques : Mettez vos connaissances à l'épreuve

Maintenant que vous avez vu la théorie, il est temps de pratiquer ! Essayez de résoudre ces exercices par vous-même avant de regarder les solutions.

Exercice 1 : Pair ou Impair ?

Écrivez un programme qui demande à l'utilisateur de saisir un nombre entier, puis qui affiche si ce nombre est "Pair" ou "Impair".

Indice : Utilisez la classe Scanner pour lire l'entrée et l'opérateur modulo (%) pour vérifier la parité. Un nombre est pair si le reste de sa division par 2 est égal à 0.

Voir la solution

import java.util.Scanner;

public class PairOuImpair {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Veuillez entrer un nombre entier : ");
        int nombre = scanner.nextInt();

        // On vérifie le reste de la division par 2
        if (nombre % 2 == 0) {
            System.out.println("Le nombre " + nombre + " est Pair.");
        } else {
            System.out.println("Le nombre " + nombre + " est Impair.");
        }

        scanner.close();
    }
}

Exercice 2 : Calculateur de Notes

Créez un programme qui demande une note (un entier sur 100) et affiche le grade correspondant en utilisant une structure if-else if-else.

90 ou plus : "A - Excellent"
80 à 89 : "B - Très bien"
70 à 79 : "C - Bien"
60 à 69 : "D - Passable"
Moins de 60 : "F - Échec"

Indice : Commencez par vérifier la condition la plus élevée (>= 90) et descendez progressivement.

Voir la solution

import java.util.Scanner;

public class CalculateurNotes {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Entrez la note de l'étudiant (sur 100) : ");
        int note = scanner.nextInt();

        if (note >= 90) {
            System.out.println("Grade : A - Excellent");
        } else if (note >= 80) {
            System.out.println("Grade : B - Très bien");
        } else if (note >= 70) {
            System.out.println("Grade : C - Bien");
        } else if (note >= 60) {
            System.out.println("Grade : D - Passable");
        } else {
            System.out.println("Grade : F - Échec");
        }

        scanner.close();
    }
}

Exercice 3 : Le Jeu du Plus ou Moins

Développez un petit jeu où l'ordinateur choisit un nombre aléatoire entre 1 et 100. L'utilisateur doit ensuite deviner ce nombre. Après chaque tentative, le programme doit indiquer si le nombre à deviner est "plus grand" ou "plus petit". La partie se termine lorsque l'utilisateur trouve le bon nombre.

Indice : Utilisez int nombreAleatoire = (int)(Math.random() * 100) + 1; pour générer le nombre. Une boucle do-while est parfaite pour ce genre de jeu, car vous voulez que l'utilisateur joue au moins une fois.

Voir la solution

import java.util.Scanner;

public class JeuPlusOuMoins {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // L'ordinateur choisit un nombre entre 1 et 100
        int nombreADeviner = (int)(Math.random() * 100) + 1;
        int tentativeUtilisateur = 0;
        int nombreEssais = 0;

        System.out.println("J'ai choisi un nombre entre 1 et 100. À vous de le deviner !");

        do {
            System.out.print("Votre proposition : ");
            tentativeUtilisateur = scanner.nextInt();
            nombreEssais++; // On incrémente le compteur d'essais

            if (tentativeUtilisateur < nombreADeviner) {
                System.out.println("C'est plus grand !");
            } else if (tentativeUtilisateur > nombreADeviner) {
                System.out.println("C'est plus petit !");
            }

        } while (tentativeUtilisateur != nombreADeviner);

        System.out.println("Bravo ! Vous avez trouvé le nombre " + nombreADeviner + " en " + nombreEssais + " essais.");
        scanner.close();
    }
}