Espace apprenant Java

Exercice 1.3.A Retrouver les outils

Sans rien écrire, repérez dans IntelliJ :

1. la zone où l'on tape le code ;
2. la console de sortie ;
3. le bouton qui lance le programme.

Non vérifiable : pas de test automatique pour cet exercice (réponse libre, observation, saisie au clavier ou résultat qui change à chaque lancement). Comparez avec la solution une fois l'exercice terminé, ou montrez-le à votre formateur.

Exercice 1.5.A Lancer le programme de base

Créez un projet Java (build system IntelliJ, JDK 25) et lancez le code généré par IntelliJ avec le bouton vert.

Que voyez-vous dans la console ? Selon la version d'IntelliJ, le code de base affiche un message ou ne produit aucune sortie : dans les deux cas, l'important est que le programme se termine sans erreur.

Non vérifiable : pas de test automatique pour cet exercice (réponse libre, observation, saisie au clavier ou résultat qui change à chaque lancement). Comparez avec la solution une fois l'exercice terminé, ou montrez-le à votre formateur.

Exercice 2.1.A Dire bonjour

Écrivez un programme qui affiche exactement :

Bonjour !

public class Main {
    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Bonjour !");
    }
}

Bonjour !

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 2.3.A Se présenter sur deux lignes

Affichez votre prénom sur une première ligne, puis votre ville sur la deuxième, avec deux println.

public class Main {
    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Camille");
        System.out.println("Paris");
    }
}

Camille
Paris

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 2.3.B Tout sur une seule ligne

Affichez Java est super en utilisant trois instructions print (une par mot), pour que tout reste sur la même ligne.

public class Main {
    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.print("Java ");
        System.out.print("est ");
        System.out.print("super");
    }
}

Java est super

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 2.5.A Trouver l'erreur

Ce programme ne compile pas. Trouvez pourquoi et corrigez-le.

public class Main {
    public static void main(String[] args) {
        System.out.println("Je suis un programme")
        System.out.println("avec un petit oubli");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Je suis un programme");
        System.out.println("avec un petit oubli");
    }
}

Je suis un programme
avec un petit oubli

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 3.2.A Une lettre

Affichez la lettre J en tant que caractère (char), puis le texte Java en tant que chaîne.

public class Main {
    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println('J');
        System.out.println("Java");
    }
}

J
Java

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 3.3.A Afficher chaque type

Écrivez un programme qui affiche, sur quatre lignes : le texte Java, le nombre entier 2026, le nombre décimal 3.14 et le booléen false.

public class Main {
    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Java");
        System.out.println(2026);
        System.out.println(3.14);
        System.out.println(false);
    }
}

Java
2026
3.14
false

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 3.3.B Quel type choisir ?

Pour chaque information, indiquez le type le plus adapté (int, double, char, boolean ou String) :

1. le nombre de frères et sœurs ;
2. le prix d'un café (1,80 €) ;
3. l'initiale d'un prénom ;
4. « l'utilisateur est connecté : oui ou non » ;
5. le nom d'une ville.

Non vérifiable : pas de test automatique pour cet exercice (réponse libre, observation, saisie au clavier ou résultat qui change à chaque lancement). Comparez avec la solution une fois l'exercice terminé, ou montrez-le à votre formateur.

Exercice 4.2.A Ma fiche d'identité

Déclarez trois variables : prenom (texte), age (entier) et taille (décimal). Affichez-les dans une seule phrase :

Je m'appelle Camille, j'ai 28 ans et je mesure 1.65 m.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : prenom

        // Déclarez votre variable ici : age

        // Déclarez votre variable ici : taille

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        String prenom = "Camille";
        int age = 28;
        double taille = 1.65;

        System.out.println("Je m'appelle " + prenom + ", j'ai " + age + " ans et je mesure " + taille + " m.");
    }
}

Je m'appelle Camille, j'ai 28 ans et je mesure 1.65 m.

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 4.4.A Changer de valeur

Déclarez int score = 0, affichez-le, puis donnez-lui la valeur 50 et affichez-le à nouveau. Le programme doit afficher 0 puis 50.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : score

        // Affichez le résultat ici

        // Modifiez la variable score ici

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int score = 0;
        System.out.println(score);

        score = 50;
        System.out.println(score);
    }
}

0
50

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 4.4.B Ajouter des points

Déclarez int points = 10. Ajoutez-lui 5 avec points = points + 5;, puis affichez Points : 15.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : points

        // Modifiez la variable points ici

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int points = 10;
        points = points + 5;

        System.out.println("Points : " + points);
    }
}

Points : 15

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 4.4.C Échanger deux variables

Deux variables sont déclarées :

• int a = 3;
• int b = 8;

Échangez leurs valeurs pour que a vaille 8 et b vaille 3, puis affichez a = 8, b = 3.

Indice : il faut une troisième boîte temporaire.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : a

        // Déclarez votre variable ici : b

        // Déclarez votre variable ici : temporaire

        // Modifiez la variable a ici

        // Modifiez la variable b ici

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int a = 3;
        int b = 8;

        int temporaire = a;   // on met de côté la valeur de a
        a = b;                // a prend la valeur de b
        b = temporaire;       // b reprend l'ancienne valeur de a

        System.out.println("a = " + a + ", b = " + b);
    }
}

a = 8, b = 3

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 5.1.A Périmètre d'un rectangle

Un rectangle fait 8 de long et 5 de large (deux variables int). Calculez son périmètre (2 × (longueur + largeur)) et affichez Périmètre : 26.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : longueur

        // Déclarez votre variable ici : largeur

        // Calculez ici : perimetre

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int longueur = 8;
        int largeur = 5;

        int perimetre = 2 * (longueur + largeur);

        System.out.println("Périmètre : " + perimetre);
    }
}

Périmètre : 26

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 5.2.A Le reste d'une division

Deux variables : int dividende = 17; et int diviseur = 5;. Calculez le reste de la division dans une variable reste et affichez exactement 17 % 5 = 2.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : dividende

        // Déclarez votre variable ici : diviseur

        // Calculez ici : reste

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int dividende = 17;
        int diviseur = 5;

        int reste = dividende % diviseur;

        System.out.println(dividende + " % " + diviseur + " = " + reste);
    }
}

17 % 5 = 2

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 5.4.A Compter avec ++ et --

Une variable int compteur vaut 10. Incrémentez-la avec ++ et affichez-la, puis décrémentez-la avec -- et affichez-la à nouveau. Résultat attendu : 11 puis 10.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : compteur

        // Modifiez la variable compteur ici

        // Affichez le résultat ici

        // Modifiez la variable compteur ici

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int compteur = 10;

        compteur++;
        System.out.println(compteur);

        compteur--;
        System.out.println(compteur);
    }
}

11
10

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 5.5.A La moyenne de deux notes

Deux notes sont données :

• int note1 = 12;
• int note2 = 15;

Calculez leur moyenne avec la virgule et affichez Moyenne : 13.5.

Indice : un des deux nombres doit être un double pour éviter la division entière.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : note1

        // Déclarez votre variable ici : note2

        // Calculez ici : moyenne

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int note1 = 12;
        int note2 = 15;

        double moyenne = (note1 + note2) / 2.0;

        System.out.println("Moyenne : " + moyenne);
    }
}

Moyenne : 13.5

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 5.5.B Le code d'une lettre

Une variable char lettre vaut 'A'. Convertissez-la en int avec un cast dans une variable code, puis affichez exactement Le code ASCII de A est 65.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : lettre

        // Déclarez votre variable ici : code

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        char lettre = 'A';

        int code = (int) lettre;

        System.out.println("Le code ASCII de " + lettre + " est " + code);
    }
}

Le code ASCII de A est 65

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 5.6.A Afficher une facture alignée

Trois articles :

• Stylo à 1,5 €
• Cahier à 3,2 €
• Classeur à 12 €

Avec System.out.printf, affichez chaque article sur une ligne :

• le nom sur 10 caractères, aligné à gauche ;
• le prix sur 7 caractères, avec 2 décimales, aligné à droite ;
• puis le symbole €.

Déroulé attendu :

Stylo        1,50 €
Cahier       3,20 €
Classeur    12,00 €

public class Main {
    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.printf("%-10s%7.2f €%n", "Stylo", 1.5);
        System.out.printf("%-10s%7.2f €%n", "Cahier", 3.2);
        System.out.printf("%-10s%7.2f €%n", "Classeur", 12.0);
    }
}

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 6.3.A Lire un entier

Lisez un nombre entier avec nextInt() et affichez Vous avez saisi : 7 (si l'utilisateur tape 7).

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : nombre

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

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

        int nombre = scanner.nextInt();

        System.out.println("Vous avez saisi : " + nombre);
    }
}

7
Vous avez saisi : 7

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 6.3.B La somme de deux entiers

Lisez deux entiers a puis b, et affichez leur somme : La somme est : 7 (si on tape 3 puis 4).

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : a

        // Lisez la saisie ici : b

        // Calculez ici : somme

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

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

        int a = scanner.nextInt();
        int b = scanner.nextInt();

        int somme = a + b;

        System.out.println("La somme est : " + somme);
    }
}

3
4
La somme est : 7

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 6.4.A L'aire d'un rectangle

Lisez la longueur puis la largeur (deux double), calculez l'aire et affichez L'aire est : 15.0 (si on tape 3 puis 5).

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : longueur

        // Lisez la saisie ici : largeur

        // Calculez ici : aire

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

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

        double longueur = scanner.nextDouble();
        double largeur = scanner.nextDouble();

        double aire = longueur * largeur;

        System.out.println("L'aire est : " + aire);
    }
}

3
5
L'aire est : 15.0

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 6.5.A Dire bonjour

Lisez un prénom avec nextLine() et affichez exactement Bonjour, Camille ! (si l'utilisateur tape Camille).

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : prenom

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

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

        String prenom = scanner.nextLine();

        System.out.println("Bonjour, " + prenom + " !");
    }
}

Camille
Bonjour, Camille !

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 6.5.B Lire une phrase

Lisez une phrase entière (avec des espaces) dans une variable phrase, puis affichez Vous avez écrit : suivi de la phrase.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : phrase

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

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

        String phrase = scanner.nextLine();

        System.out.println("Vous avez écrit : " + phrase);
    }
}

Il fait beau aujourd'hui
Vous avez écrit : Il fait beau aujourd'hui

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 6.6.A Synthèse : nom, âge, ville

Lisez trois informations :

1. le nom complet, avec nextLine() ;
2. l'âge, avec nextInt() ;
3. la ville, avec nextLine().

Pensez à vider le buffer entre l'âge et la ville. Affichez chaque information sur sa ligne :

Nom : Camille
Âge : 28
Ville : Paris

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : nom

        // Lisez la saisie ici : age

        // Appelez la méthode nextLine() ici

        // Lisez la saisie ici : ville

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

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

        String nom = scanner.nextLine();

        int age = scanner.nextInt();
        scanner.nextLine();               // vide le buffer

        String ville = scanner.nextLine();

        System.out.println("Nom : " + nom);
        System.out.println("Âge : " + age);
        System.out.println("Ville : " + ville);
    }
}

Camille
28
Paris
Nom : Camille
Âge : 28
Ville : Paris

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 6.9.A Le projet complet

Réalisez l'Assistant de voyage en suivant l'énoncé ci-dessus. Pensez à lire le prénom avant les nombres.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Complétez ici

        // Affichez le résultat ici

        // Lisez la saisie ici : prenom

        // Affichez le résultat ici

        // Complétez ici

        // Affichez le résultat ici

        // Lisez la saisie ici : distanceKm

        // Calculez ici : distanceMiles

        // Affichez le résultat ici

        // Complétez ici

        // Affichez le résultat ici

        // Lisez la saisie ici : celsius

        // Calculez ici : fahrenheit

        // Affichez le résultat ici

        // Complétez ici

        // Affichez le résultat ici

        // Lisez la saisie ici : euros

        // Déclarez votre variable ici : taux

        // Calculez ici : dollars

        // Affichez le résultat ici

        // Fermez le Scanner ici
    }
}

import java.util.Scanner;

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

        // 1. Prénom
        System.out.print("Quel est votre prénom ? ");
        String prenom = scanner.nextLine();
        System.out.println("Bienvenue " + prenom + ", préparons votre voyage à New York !");

        // 2. Distance jusqu'à l'aéroport
        System.out.print("Distance jusqu'à l'aéroport (en km) : ");
        double distanceKm = scanner.nextDouble();
        double distanceMiles = distanceKm * 0.621371;
        System.out.println(distanceKm + " km représentent " + distanceMiles + " miles");

        // 3. Température à New York
        System.out.print("Température prévue à New York (en °C) : ");
        double celsius = scanner.nextDouble();
        double fahrenheit = celsius * 1.8 + 32;
        System.out.println(celsius + " °C représentent " + fahrenheit + " °F");

        // 4. Budget
        System.out.print("Budget du voyage (en euros) : ");
        double euros = scanner.nextDouble();
        double taux = 1.10; // taux indicatif, à adapter
        double dollars = euros * taux;
        System.out.println(euros + " € représentent " + dollars + " $");

        scanner.close();
    }
}

Quel est votre prénom ? Léa
Bienvenue Léa, préparons votre voyage à New York !
Distance jusqu'à l'aéroport (en km) : 30
30.0 km représentent 18.64113 miles
Température prévue à New York (en °C) : 5
5.0 °C représentent 41.0 °F
Budget du voyage (en euros) : 1000
1000.0 € représentent 1100.0 $

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 7.2.A Pair ou impair

Lisez un entier. Affichez Pair s'il est pair, Impair sinon. Indice : utilisez %.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : nombre

        // Écrivez votre condition ici (if / else)
    }
}

import java.util.Scanner;

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

        int nombre = scanner.nextInt();

        if (nombre % 2 == 0) {
            System.out.println("Pair");
        } else {
            System.out.println("Impair");
        }
    }
}

7
Impair

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 7.3.A Majeur ou mineur ?

Lisez un âge. Affichez Majeur s'il est de 18 ou plus, sinon Mineur.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : age

        // Écrivez votre condition ici (if / else)
    }
}

import java.util.Scanner;

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

        int age = scanner.nextInt();

        if (age >= 18) {
            System.out.println("Majeur");
        } else {
            System.out.println("Mineur");
        }
    }
}

20
Majeur

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 7.4.A Positif, négatif ou nul

Lisez un entier. Affichez Positif, Négatif ou Nul.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : nombre

        // Écrivez votre condition ici (if / else if / else)
    }
}

import java.util.Scanner;

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

        int nombre = scanner.nextInt();

        if (nombre > 0) {
            System.out.println("Positif");
        } else if (nombre < 0) {
            System.out.println("Négatif");
        } else {
            System.out.println("Nul");
        }
    }
}

-4
Négatif

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 7.4.B Le barème de notes

Lisez une note sur 20. Affichez Très bien (16 et plus), Bien (12 à 15), Passable (10 ou 11) ou Insuffisant (moins de 10).

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : note

        // Écrivez votre condition ici (if / else if / else)
    }
}

import java.util.Scanner;

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

        int note = scanner.nextInt();

        if (note >= 16) {
            System.out.println("Très bien");
        } else if (note >= 12) {
            System.out.println("Bien");
        } else if (note >= 10) {
            System.out.println("Passable");
        } else {
            System.out.println("Insuffisant");
        }
    }
}

13
Bien

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 7.5.A Le mot de passe

Lisez un mot avec nextLine(). S'il vaut secret, affichez Accès autorisé, sinon Accès refusé.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : motDePasse

        // Écrivez votre condition ici (if / else)
    }
}

import java.util.Scanner;

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

        String motDePasse = scanner.nextLine();

        if (motDePasse.equals("secret")) {
            System.out.println("Accès autorisé");
        } else {
            System.out.println("Accès refusé");
        }
    }
}

secret
Accès autorisé

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 7.6.A Initiale et longueur

Lisez un prénom avec nextLine(). Affichez son initiale et sa longueur (si l'utilisateur tape Camille) :

Initiale : C
Longueur : 7

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : prenom

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

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

        String prenom = scanner.nextLine();

        System.out.println("Initiale : " + prenom.charAt(0));
        System.out.println("Longueur : " + prenom.length());
    }
}

Camille
Initiale : C
Longueur : 7

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 7.6.B Oui ou non ?

Lisez une réponse avec nextLine() :

• si l'utilisateur tape oui, quelle que soit la façon de l'écrire (OUI, Oui, avec des espaces autour…), affichez C'est parti ! ;
• sinon, affichez Tant pis.

Indice : strip() et equalsIgnoreCase.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : reponse

        // Modifiez la variable reponse ici

        // Écrivez votre condition ici (if / else)
    }
}

import java.util.Scanner;

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

        String reponse = scanner.nextLine();
        reponse = reponse.strip();          // retire les espaces autour

        if (reponse.equalsIgnoreCase("oui")) {
            System.out.println("C'est parti !");
        } else {
            System.out.println("Tant pis.");
        }
    }
}

  Oui  
C'est parti !

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 7.6.C Le domaine d'une adresse e-mail

Lisez une adresse e-mail :

• affichez ce qui suit le @ : Domaine : exemple.fr si l'utilisateur tape camille@exemple.fr ;
• s'il n'y a pas de @, affichez Adresse invalide.

Indice : indexOf renvoie -1 quand il ne trouve rien, et substring(debut) prend la fin du texte.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : adresse

        // Déclarez votre variable ici : arobase

        // Écrivez votre condition ici (if / else)
    }
}

import java.util.Scanner;

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

        String adresse = scanner.nextLine();
        int arobase = adresse.indexOf("@");

        if (arobase == -1) {
            System.out.println("Adresse invalide");
        } else {
            System.out.println("Domaine : " + adresse.substring(arobase + 1));
        }
    }
}

camille@exemple.fr
Domaine : exemple.fr

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 8.1.A Adolescent ?

Lisez un âge. Affichez Adolescent s'il est entre 12 et 17 inclus, sinon Pas adolescent.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : age

        // Écrivez votre condition ici (if / else)
    }
}

import java.util.Scanner;

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

        int age = scanner.nextInt();

        if (age >= 12 && age <= 17) {
            System.out.println("Adolescent");
        } else {
            System.out.println("Pas adolescent");
        }
    }
}

15
Adolescent

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 8.2.A Le plus grand de trois

Écrivez un programme qui demande trois nombres entiers à l'utilisateur et affiche le plus grand des trois.

1. Avec un Scanner, lisez trois entiers avec nextInt() et rangez-les dans trois variables (a, b et c).
2. Comparez-les avec des if / else if / else, en combinant deux comparaisons avec &&. Par exemple, a est le plus grand si a est supérieur ou égal à b et à c.
3. Affichez le résultat sous la forme Le plus grand : 8.

Exemple : si l'utilisateur saisit 8, 3 puis 5, le programme affiche Le plus grand : 8. Si deux nombres sont égaux et plus grands que le troisième, n'importe lequel des deux convient.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : a

        // Lisez la saisie ici : b

        // Lisez la saisie ici : c

        // Écrivez votre condition ici (if / else if / else)
    }
}

import java.util.Scanner;

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

        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int c = scanner.nextInt();

        if (a >= b && a >= c) {
            System.out.println("Le plus grand : " + a);
        } else if (b >= a && b >= c) {
            System.out.println("Le plus grand : " + b);
        } else {
            System.out.println("Le plus grand : " + c);
        }
    }
}

8
3
5
Le plus grand : 8

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 8.3.A Ternaire

Lisez un entier. Avec un ternaire, stockez "pair" ou "impair" dans une variable parite et affichez-la.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : nombre

        // Calculez ici : parite

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

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

        int nombre = scanner.nextInt();

        String parite = (nombre % 2 == 0) ? "pair" : "impair";

        System.out.println(nombre + " est " + parite);
    }
}

9
9 est impair

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 8.4.A Le jour de la semaine

Lisez un numéro de 1 à 7 et affichez le nom du jour avec un switch (1 = Lundi … 7 = Dimanche). Pour tout autre numéro, affichez Numéro invalide.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Lisez la saisie ici : jour

        // Écrivez votre switch ici
    }
}

import java.util.Scanner;

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

        int jour = scanner.nextInt();

        switch (jour) {
            case 1:
                System.out.println("Lundi");
                break;
            case 2:
                System.out.println("Mardi");
                break;
            case 3:
                System.out.println("Mercredi");
                break;
            case 4:
                System.out.println("Jeudi");
                break;
            case 5:
                System.out.println("Vendredi");
                break;
            case 6:
                System.out.println("Samedi");
                break;
            case 7:
                System.out.println("Dimanche");
                break;
            default:
                System.out.println("Numéro invalide");
        }
    }
}

3
Mercredi

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 8.5.A Le projet complet

Réalisez le Défi running.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Affichez le résultat ici

        // Lisez la saisie ici : prenom

        // Affichez le résultat ici

        // Lisez la saisie ici : duree

        // Calculez ici : allure

        // Affichez le résultat ici

        // Déclarez votre variable ici : niveau

        // Écrivez votre condition ici (if / else if / else)

        // Affichez le résultat ici

        // Écrivez votre condition ici (if)

        // Fermez le Scanner ici
    }
}

import java.util.Scanner;

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

        System.out.print("Prénom : ");
        String prenom = scanner.nextLine();

        System.out.print("Durée du 10 km (en minutes) : ");
        int duree = scanner.nextInt();

        double allure = duree / 10.0;
        System.out.println(prenom + ", votre allure est de " + allure + " min/km");

        String niveau;
        if (duree < 40) {
            niveau = "Expert";
        } else if (duree < 55) {
            niveau = "Confirmé";
        } else if (duree < 70) {
            niveau = "Régulier";
        } else {
            niveau = "Débutant";
        }
        System.out.println("Niveau : " + niveau);

        if (duree == 60) {
            System.out.println("Pile une heure !");
        }

        scanner.close();
    }
}

Prénom : Camille
Durée du 10 km (en minutes) : 52
Camille, votre allure est de 5.2 min/km
Niveau : Confirmé

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 9.2.A Le compte à rebours

Affichez 5, 4, 3, 2, 1 puis Décollage !. Indice : i--.

public class Main {
    public static void main(String[] args) {
        // Écrivez votre boucle ici (for)

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 5; i >= 1; i--) {
            System.out.println(i);
        }
        System.out.println("Décollage !");
    }
}

5
4
3
2
1
Décollage !

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 9.3.A Compter jusqu'à 10

Affichez les nombres de 1 à 10, un par ligne, avec une boucle for.

public class Main {
    public static void main(String[] args) {
        // Écrivez votre boucle ici (for)
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}

1
2
3
4
5
6
7
8
9
10

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 9.3.B Les nombres pairs

Affichez les nombres pairs de 2 à 20. Indice : i % 2 == 0, ou bien i += 2.

public class Main {
    public static void main(String[] args) {
        // Écrivez votre boucle ici (for)
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 2; i <= 20; i += 2) {
            System.out.println(i);
        }
    }
}

2
4
6
8
10
12
14
16
18
20

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 9.4.A Redemander jusqu'à un bon nombre

Demandez un nombre entre 1 et 10 avec un do…while, et recommencez tant que la saisie est hors de cet intervalle. Terminez en affichant Merci !.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Déclarez votre variable ici : nombre

        // Écrivez votre boucle ici (do…while)

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

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

        do {
            System.out.print("Un nombre entre 1 et 10 : ");
            nombre = scanner.nextInt();
        } while (nombre < 1 || nombre > 10);

        System.out.println("Merci !");
    }
}

Un nombre entre 1 et 10 : 15
Un nombre entre 1 et 10 : 7
Merci !

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 9.6.A La somme de 1 à 100

Calculez la somme des entiers de 1 à 100 et affichez Somme : 5050.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : somme

        // Écrivez votre boucle ici (for)

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int somme = 0;

        for (int i = 1; i <= 100; i++) {
            somme += i;
        }

        System.out.println("Somme : " + somme);
    }
}

Somme : 5050

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 9.7.A Le projet complet

Réalisez le coffre-fort.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Déclarez votre variable ici : codeSecret

        // Déclarez votre variable ici : essaisMax

        // Déclarez votre variable ici : ouvert

        // Écrivez votre boucle ici (for)

        // Écrivez votre condition ici (if / else)

        // Fermez le Scanner ici
    }
}

import java.util.Scanner;

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

        int codeSecret = 4821;
        int essaisMax = 3;
        boolean ouvert = false;

        for (int essai = 1; essai <= essaisMax; essai++) {
            System.out.print("Code (essai " + essai + "/" + essaisMax + ") : ");
            int saisie = scanner.nextInt();

            if (saisie == codeSecret) {
                ouvert = true;
                break;
            }
            System.out.println("Mauvais code. Essais restants : " + (essaisMax - essai));
        }

        if (ouvert) {
            System.out.println("Coffre ouvert !");
        } else {
            System.out.println("Coffre verrouillé.");
        }

        scanner.close();
    }
}

Code (essai 1/3) : 1111
Mauvais code. Essais restants : 2
Code (essai 2/3) : 4821
Coffre ouvert !

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 9.7.B Gros exercice : la caisse de la boulangerie (menu en boucle)

Vous allez écrire un vrai petit programme interactif : la caisse d'une boulangerie. Il affiche un menu, lit le choix de l'utilisateur, agit selon ce choix, puis recommence jusqu'à ce qu'on choisisse de quitter. C'est l'exercice de synthèse du chapitre : il combine la boucle while (ou do…while) et le switch.

Le menu à afficher à chaque tour :

===== Caisse boulangerie =====
1. Ajouter une baguette (1,10 €)
2. Ajouter un croissant (1,20 €)
3. Ajouter un pain au chocolat (1,30 €)
4. Voir le total
5. Encaisser et quitter
Votre choix :

Règles :

• Gardez un total (double) et un nombre d'articles (int), tous deux initialisés à 0 avant la boucle.
• À chaque tour : afficher le menu, lire le choix avec nextInt(), puis un switch sur ce choix.
• cas 1, 2, 3 : ajouter le prix au total, augmenter le nombre d'articles, et confirmer (Ajouté.).
• cas 4 : afficher le nombre d'articles et le total.
• cas 5 : afficher le ticket final et sortir de la boucle.
• default : afficher Choix invalide..
• La boucle tourne tant que l'utilisateur n'a pas choisi 5.

Exemple de déroulé (l'utilisateur tape 1, puis 2, puis 4, puis 5) :

===== Caisse boulangerie =====
1. Ajouter une baguette (1,10 €)
2. Ajouter un croissant (1,20 €)
3. Ajouter un pain au chocolat (1,30 €)
4. Voir le total
5. Encaisser et quitter
Votre choix : 1
Ajouté.
===== Caisse boulangerie =====
1. Ajouter une baguette (1,10 €)
2. Ajouter un croissant (1,20 €)
3. Ajouter un pain au chocolat (1,30 €)
4. Voir le total
5. Encaisser et quitter
Votre choix : 2
Ajouté.
===== Caisse boulangerie =====
1. Ajouter une baguette (1,10 €)
2. Ajouter un croissant (1,20 €)
3. Ajouter un pain au chocolat (1,30 €)
4. Voir le total
5. Encaisser et quitter
Votre choix : 4
2 article(s), total : 2.3 €
===== Caisse boulangerie =====
1. Ajouter une baguette (1,10 €)
2. Ajouter un croissant (1,20 €)
3. Ajouter un pain au chocolat (1,30 €)
4. Voir le total
5. Encaisser et quitter
Votre choix : 5
----- Ticket -----
2 article(s)
Total à payer : 2.3 €
Merci, au revoir !

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Déclarez votre variable ici : total

        // Déclarez votre variable ici : articles

        // Déclarez votre variable ici : actif

        // Écrivez votre boucle ici (while)

        // Appelez la méthode close() ici
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double total = 0;
        int articles = 0;
        boolean actif = true;

        while (actif) {
            System.out.println("===== Caisse boulangerie =====");
            System.out.println("1. Ajouter une baguette (1,10 €)");
            System.out.println("2. Ajouter un croissant (1,20 €)");
            System.out.println("3. Ajouter un pain au chocolat (1,30 €)");
            System.out.println("4. Voir le total");
            System.out.println("5. Encaisser et quitter");
            System.out.print("Votre choix : ");
            int choix = sc.nextInt();

            switch (choix) {
                case 1:
                    total += 1.10;
                    articles++;
                    System.out.println("Ajouté.");
                    break;
                case 2:
                    total += 1.20;
                    articles++;
                    System.out.println("Ajouté.");
                    break;
                case 3:
                    total += 1.30;
                    articles++;
                    System.out.println("Ajouté.");
                    break;
                case 4:
                    System.out.println(articles + " article(s), total : " + total + " €");
                    break;
                case 5:
                    System.out.println("----- Ticket -----");
                    System.out.println(articles + " article(s)");
                    System.out.println("Total à payer : " + total + " €");
                    System.out.println("Merci, au revoir !");
                    actif = false;
                    break;
                default:
                    System.out.println("Choix invalide.");
            }
        }
        sc.close();
    }
}

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 10.3.A Premier et dernier

Pour le tableau de prénoms {"Léa", "Hugo", "Inès", "Noé"}, affichez le premier et le dernier prénom. Le dernier doit se calculer avec length.

public class Main {
    public static void main(String[] args) {
        // Créez votre tableau ici : prenoms

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        String[] prenoms = {"Léa", "Hugo", "Inès", "Noé"};

        System.out.println("Premier : " + prenoms[0]);
        System.out.println("Dernier : " + prenoms[prenoms.length - 1]);
    }
}

Premier : Léa
Dernier : Noé

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 10.4.A Afficher un tableau

Créez le tableau {5, 10, 15, 20} et affichez chaque valeur sur une ligne avec un for-each.

public class Main {
    public static void main(String[] args) {
        // Créez votre tableau ici : valeurs

        // Parcourez avec une boucle for-each ici
    }
}

public class Main {
    public static void main(String[] args) {
        int[] valeurs = {5, 10, 15, 20};

        for (int valeur : valeurs) {
            System.out.println(valeur);
        }
    }
}

5
10
15
20

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 10.4.B Saisir des notes

Demandez à l'utilisateur 4 notes, rangez-les dans un tableau, puis affichez leur moyenne.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créez le Scanner ici

        // Créez votre tableau ici : notes

        // Déclarez votre variable ici : somme

        // Écrivez votre boucle ici (for)

        // Calculez ici : moyenne

        // Affichez le résultat ici
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] notes = new int[4];
        int somme = 0;

        for (int i = 0; i < notes.length; i++) {
            System.out.print("Note " + (i + 1) + " : ");
            notes[i] = scanner.nextInt();
            somme += notes[i];
        }

        double moyenne = (double) somme / notes.length;
        System.out.println("Moyenne : " + moyenne);
    }
}

Note 1 : 12
Note 2 : 15
Note 3 : 9
Note 4 : 18
Moyenne : 13.5

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 10.5.A Somme d'un tableau

Calculez et affichez la somme du tableau {4, 8, 15, 16, 23, 42}. Résultat : 108.

public class Main {
    public static void main(String[] args) {
        // Créez votre tableau ici : valeurs

        // Déclarez votre variable ici : somme

        // Parcourez avec une boucle for-each ici

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int[] valeurs = {4, 8, 15, 16, 23, 42};
        int somme = 0;

        for (int valeur : valeurs) {
            somme += valeur;
        }

        System.out.println(somme);
    }
}

108

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 10.5.B Le plus petit

Trouvez et affichez la plus petite valeur du tableau {14, 3, 27, 9, 11}.

public class Main {
    public static void main(String[] args) {
        // Créez votre tableau ici : valeurs

        // Déclarez votre variable ici : minimum

        // Parcourez avec une boucle for-each ici

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        int[] valeurs = {14, 3, 27, 9, 11};
        int minimum = valeurs[0];

        for (int valeur : valeurs) {
            if (valeur < minimum) {
                minimum = valeur;
            }
        }

        System.out.println("Minimum : " + minimum);
    }
}

Minimum : 3

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 10.6.A Le projet complet

Réalisez la station météo.

public class Main {
    public static void main(String[] args) {
        // Créez votre tableau ici : temperatures

        // Déclarez votre variable ici : somme

        // Déclarez votre variable ici : maximum

        // Déclarez votre variable ici : joursChauds

        // Écrivez votre boucle ici (for)

        // Calculez ici : moyenne

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        double[] temperatures = {14.5, 16.0, 12.5, 18.0, 20.5, 19.0, 15.5};

        double somme = 0;
        double maximum = temperatures[0];
        int joursChauds = 0;

        for (int i = 0; i < temperatures.length; i++) {
            System.out.println("Jour " + (i + 1) + " : " + temperatures[i] + " °C");

            somme += temperatures[i];
            if (temperatures[i] > maximum) {
                maximum = temperatures[i];
            }
            if (temperatures[i] > 16) {
                joursChauds++;
            }
        }

        double moyenne = somme / temperatures.length;

        System.out.println("Moyenne : " + moyenne + " °C");
        System.out.println("Maximum : " + maximum + " °C");
        System.out.println("Jours au-dessus de 16 °C : " + joursChauds);
    }
}

Jour 1 : 14.5 °C
Jour 2 : 16.0 °C
Jour 3 : 12.5 °C
Jour 4 : 18.0 °C
Jour 5 : 20.5 °C
Jour 6 : 19.0 °C
Jour 7 : 15.5 °C
Moyenne : 16.571428571428573 °C
Maximum : 20.5 °C
Jours au-dessus de 16 °C : 3

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 11.4.A Ma liste de courses

Créez une ArrayList<String>, ajoutez 3 articles, puis affichez-les avec un for-each, un par ligne, précédés de -.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // Créez votre liste ici : courses

        // Appelez la méthode add() ici

        // Parcourez avec une boucle for-each ici
    }
}

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> courses = new ArrayList<>();
        courses.add("Pain");
        courses.add("Lait");
        courses.add("Pommes");

        for (String article : courses) {
            System.out.println("- " + article);
        }
    }
}

- Pain
- Lait
- Pommes

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 11.4.B Compter et retirer

Avec la liste Pain, Lait, Pommes : affichez sa taille, retirez Lait, puis affichez la nouvelle taille.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // Créez votre liste ici : courses

        // Appelez la méthode add() ici

        // Affichez le résultat ici

        // Appelez la méthode remove() ici

        // Affichez le résultat ici
    }
}

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> courses = new ArrayList<>();
        courses.add("Pain");
        courses.add("Lait");
        courses.add("Pommes");

        System.out.println(courses.size());   // 3
        courses.remove("Lait");
        System.out.println(courses.size());   // 2
    }
}

3
2

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 11.4.C La moyenne d'une liste de notes

Créez une ArrayList<Integer> avec les notes 12, 15, 9, 18. Calculez et affichez leur moyenne.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // Créez votre liste ici : notes

        // Appelez la méthode add() ici

        // Déclarez votre variable ici : somme

        // Parcourez avec une boucle for-each ici

        // Calculez ici : moyenne

        // Affichez le résultat ici
    }
}

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> notes = new ArrayList<>();
        notes.add(12);
        notes.add(15);
        notes.add(9);
        notes.add(18);

        int somme = 0;
        for (int note : notes) {
            somme += note;
        }

        double moyenne = (double) somme / notes.size();
        System.out.println("Moyenne : " + moyenne);
    }
}

Moyenne : 13.5

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 11.5.A Les doublons disparaissent

Ajoutez dans un HashSet<String> les mots rouge, bleu, rouge, vert, bleu. Affichez le nombre d'éléments : il doit valoir 3.

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        // Créez votre ensemble (HashSet) ici : couleurs

        // Appelez la méthode add() ici

        // Affichez le résultat ici
    }
}

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> couleurs = new HashSet<>();
        couleurs.add("rouge");
        couleurs.add("bleu");
        couleurs.add("rouge");
        couleurs.add("vert");
        couleurs.add("bleu");

        System.out.println(couleurs.size());   // 3
    }
}

3

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 11.6.A Mon annuaire

Créez un HashMap<String, String> associant Léa → 06 12 34 56 78 et Hugo → 06 98 76 54 32. Affichez le numéro de Hugo.

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // Créez votre dictionnaire (HashMap) ici : annuaire

        // Appelez la méthode put() ici

        // Affichez le résultat ici
    }
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, String> annuaire = new HashMap<>();
        annuaire.put("Léa", "06 12 34 56 78");
        annuaire.put("Hugo", "06 98 76 54 32");

        System.out.println("Numéro de Hugo : " + annuaire.get("Hugo"));
    }
}

Numéro de Hugo : 06 98 76 54 32

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 11.6.B Panier avec quantités

Avec un HashMap<String, Integer>, enregistrez pommes → 3 et poires → 5. Puis affichez chaque ligne sous la forme pommes : 3.

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // Créez votre dictionnaire (HashMap) ici : panier

        // Appelez la méthode put() ici

        // Parcourez avec une boucle for-each ici
    }
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> panier = new HashMap<>();
        panier.put("pommes", 3);
        panier.put("poires", 5);

        for (String fruit : panier.keySet()) {
            System.out.println(fruit + " : " + panier.get(fruit));
        }
    }
}

pommes : 3
poires : 5

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 12.2.A Une méthode de bienvenue

Écrivez une méthode afficherBienvenue() qui affiche Bienvenue à la formation Java !, puis appelez-la deux fois depuis main.

public class Main {
    // Méthode à écrire : static void afficherBienvenue()

    public static void main(String[] args) {
        // Complétez ici
    }
}

public class Main {

    static void afficherBienvenue() {
        System.out.println("Bienvenue à la formation Java !");
    }

    public static void main(String[] args) {
        afficherBienvenue();
        afficherBienvenue();
    }
}

Bienvenue à la formation Java !
Bienvenue à la formation Java !

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 12.3.A Le plus grand de deux

Écrivez static int maximum(int a, int b). Testez avec maximum(7, 12).

public class Main {
    // Méthode à écrire : static int maximum(int a, int b)

    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {

    static int maximum(int a, int b) {
        if (a >= b) {
            return a;
        } else {
            return b;
        }
    }

    public static void main(String[] args) {
        System.out.println(maximum(7, 12));   // 12
    }
}

12

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 12.4.A Le double

Écrivez static int doubler(int n) qui renvoie le double de n. Affichez doubler(21) (résultat : 42).

public class Main {
    // Méthode à écrire : static int doubler(int n)

    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {

    static int doubler(int n) {
        return n * 2;
    }

    public static void main(String[] args) {
        System.out.println(doubler(21));
    }
}

42

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 12.4.B La moyenne d'un tableau

Écrivez static double moyenne(int[] valeurs) qui renvoie la moyenne. Testez avec {10, 12, 17}.

public class Main {
    // Méthode à écrire : static double moyenne(int[] valeurs)

    public static void main(String[] args) {
        // Créez votre tableau ici : notes

        // Affichez le résultat ici
    }
}

public class Main {

    static double moyenne(int[] valeurs) {
        int somme = 0;
        for (int valeur : valeurs) {
            somme += valeur;
        }
        return (double) somme / valeurs.length;
    }

    public static void main(String[] args) {
        int[] notes = {10, 12, 17};
        System.out.println(moyenne(notes));   // 13.0
    }
}

13.0

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 12.5.A Majeur ?

Écrivez static boolean estMajeur(int age). Testez avec 17 et 18.

public class Main {
    // Méthode à écrire : static boolean estMajeur(int age)

    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {

    static boolean estMajeur(int age) {
        return age >= 18;
    }

    public static void main(String[] args) {
        System.out.println(estMajeur(17));   // false
        System.out.println(estMajeur(18));   // true
    }
}

false
true

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 12.7.A Le mini-projet

Réalisez la caisse.

import java.util.Scanner;

public class Main {
    // Méthode à écrire : static double avecTva(double prixHt)

    public static void main(String[] args) {
        // Créez le Scanner ici

        // Affichez le résultat ici

        // Lisez la saisie ici : prixHt

        // Affichez le résultat ici

        // Fermez le Scanner ici
    }
}

import java.util.Scanner;

public class Main {

    static double avecTva(double prixHt) {
        double prixTtc = prixHt * 1.055;
        return Math.round(prixTtc * 100) / 100.0;   // arrondi au centime
    }

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

        System.out.print("Prix HT (€) : ");
        double prixHt = scanner.nextDouble();

        System.out.println("À payer : " + avecTva(prixHt) + " €");
        scanner.close();
    }
}

Prix HT (€) : 2
À payer : 2.11 €

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 13.2.A Le ticket de caisse

Avec trois tableaux :

• les noms : "Baguette", "Croissant", "Tarte aux pommes" ;
• les quantités : 2, 3, 1 ;
• les prix : 1.10, 1.30, 12.50.

Affichez un ticket aligné en colonnes :

• le nom sur 18 caractères, à gauche ;
• la quantité ;
• le montant de la ligne sur 8 caractères, avec 2 décimales.

Terminez par un trait de 32 tirets, puis le total, aligné sous les montants.

public class Main {
    public static void main(String[] args) {
        // Créez votre tableau ici : articles

        // Créez votre tableau ici : quantites

        // Créez votre tableau ici : prix

        // Déclarez votre variable ici : total

        // Écrivez votre boucle ici (for)

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        String[] articles = { "Baguette", "Croissant", "Tarte aux pommes" };
        int[] quantites = { 2, 3, 1 };
        double[] prix = { 1.10, 1.30, 12.50 };

        double total = 0;
        for (int i = 0; i < articles.length; i++) {
            double ligne = quantites[i] * prix[i];
            total += ligne;
            System.out.printf("%-18s x%d %8.2f €%n", articles[i], quantites[i], ligne);
        }
        System.out.println("--------------------------------");
        System.out.printf("%-21s %8.2f €%n", "TOTAL", total);
    }
}

Baguette           x2     2,20 €
Croissant          x3     3,90 €
Tarte aux pommes   x1    12,50 €
--------------------------------
TOTAL                    18,60 €

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 13.2.B Une ligne de nombres

Écrivez une méthode static String ligne(int n) qui renvoie "1-2-3-…-n", sans tiret à la fin, en utilisant un StringBuilder. Testez avec 5, 10 et 1.

public class Main {
    // Méthode à écrire : static String ligne(int n)

    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {
    static String ligne(int n) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= n; i++) {
            if (i > 1) {
                sb.append("-");   // un tiret avant chaque nombre, sauf le premier
            }
            sb.append(i);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        System.out.println(ligne(5));
        System.out.println(ligne(10));
        System.out.println(ligne(1));
    }
}

1-2-3-4-5
1-2-3-4-5-6-7-8-9-10
1

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 13.4.A Le menu en bloc de texte

Affichez un menu de trois choix :

• encadré de traits = ;
• avec une ligne d'accueil Bonjour Hugo, vous avez 120 points.

Le nom et les points sont dans des variables : utilisez un bloc de texte et formatted.

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : nom

        // Déclarez votre variable ici : points

        // Complétez ici

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        String nom = "Hugo";
        int points = 120;

        String menu = """
                ==================================
                Bonjour %s, vous avez %d points
                ==================================
                  1. Commander
                  2. Voir mes points
                  3. Quitter
                """.formatted(nom, points);

        System.out.print(menu);
    }
}

==================================
Bonjour Hugo, vous avez 120 points
==================================
  1. Commander
  2. Voir mes points
  3. Quitter

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 13.5.A Palindrome ?

Écrivez static boolean estPalindrome(String mot) :

• elle renvoie vrai si le mot se lit pareil dans les deux sens, sans tenir compte des majuscules ;
• utilisez reverse().

Testez avec "Kayak", "radar" et "Java".

public class Main {
    // Méthode à écrire : static boolean estPalindrome(String mot)

    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Main {
    static boolean estPalindrome(String mot) {
        String envers = new StringBuilder(mot).reverse().toString();
        return mot.equalsIgnoreCase(envers);
    }

    public static void main(String[] args) {
        System.out.println(estPalindrome("Kayak"));
        System.out.println(estPalindrome("radar"));
        System.out.println(estPalindrome("Java"));
    }
}

true
true
false

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 13.5.B Gros exercice : le ticket de caisse bien aligné (StringBuilder + format)

Exercice de synthèse du chapitre. On génère un ticket de caisse proprement aligné, en réunissant StringBuilder (construire le texte) et String.format (aligner les colonnes et les prix).

On part de ces articles (nom ; prix unitaire ; quantité), à ranger dans trois tableaux (String[], double[], int[]) :

Baguette   1.10  3
Croissant  1.20  2
Gâteau     18.50 1

Construisez, avec un seul StringBuilder, un ticket qui affiche chaque ligne alignée (nom, qté × prix, sous-total), puis le total. Les montants doivent avoir 2 décimales.

Déroulé attendu :

===== BOULANGERIE =====
Baguette   3 x 1,10 = 3,30 €
Croissant  2 x 1,20 = 2,40 €
Gâteau     1 x 18,50 = 18,50 €
------------------------
TOTAL      24,20 €

public class Main {
    public static void main(String[] args) {
        // Créez votre tableau ici : noms

        // Créez votre tableau ici : prix

        // Créez votre tableau ici : quantites

        // Créez votre objet ici : ticket

        // Appelez la méthode append() ici

        // Déclarez votre variable ici : total

        // Écrivez votre boucle ici (for)

        // Appelez la méthode append() ici

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        String[] noms = {"Baguette", "Croissant", "Gâteau"};
        double[] prix = {1.10, 1.20, 18.50};
        int[] quantites = {3, 2, 1};

        StringBuilder ticket = new StringBuilder();
        ticket.append("===== BOULANGERIE =====\n");

        double total = 0;
        for (int i = 0; i < noms.length; i++) {
            double sousTotal = prix[i] * quantites[i];
            total += sousTotal;
            ticket.append(String.format("%-10s %d x %.2f = %.2f €%n",
                noms[i], quantites[i], prix[i], sousTotal));
        }
        ticket.append("------------------------\n");
        ticket.append(String.format("%-10s %.2f €%n", "TOTAL", total));

        System.out.print(ticket);
    }
}

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 14.2.A Une classe Chat

Créez une classe Chat avec les attributs nom (String) et age (int), et un constructeur qui les initialise. Dans main, créez un chat Félix de 3 ans et affichez son nom.

public class Chat {
    // Constructeur : Chat(String nom, int age)
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : felix

        // Affichez le résultat ici
    }
}

public class Chat {
    String nom;
    int age;

    Chat(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Chat felix = new Chat("Félix", 3);

        System.out.println(felix.nom);
    }
}

Félix

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 14.3.A Deux objets indépendants

Dans main, créez deux chats (Félix, 3 ans et Luna, 5 ans). Faites miauler les deux, puis affichez lequel est le plus âgé.

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : felix

        // Créez votre objet ici : luna

        // Appelez la méthode miauler() ici

        // Écrivez votre condition ici (if / else if / else)
    }
}

public class Main {
    public static void main(String[] args) {
        Chat felix = new Chat("Félix", 3);
        Chat luna = new Chat("Luna", 5);

        felix.miauler();
        luna.miauler();

        if (felix.age > luna.age) {
            System.out.println(felix.nom + " est le plus âgé.");
        } else if (luna.age > felix.age) {
            System.out.println(luna.nom + " est le plus âgé.");
        } else {
            System.out.println("Ils ont le même âge.");
        }
    }
}

Félix dit : Miaou !
Luna dit : Miaou !
Luna est le plus âgé.

Non vérifiable : pas de test automatique pour cet exercice (réponse libre, observation, saisie au clavier ou résultat qui change à chaque lancement). Comparez avec la solution une fois l'exercice terminé, ou montrez-le à votre formateur.

Exercice 14.3.B Un compteur

Créez une classe Compteur :

• un attribut valeur (un int, qui vaut 0 au départ) ;
• trois méthodes :
  • incrementer() ajoute 1 ;
  • reinitialiser() remet à 0 ;
  • afficher() écrit Compteur : <valeur>.

Dans main, créez deux compteurs, incrémentez le premier trois fois et le second une fois, puis affichez-les :

Compteur : 3
Compteur : 1

public class Compteur {
    // Méthode à écrire : void incrementer()
    // Méthode à écrire : void reinitialiser()
    // Méthode à écrire : void afficher()
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : a

        // Créez votre objet ici : b

        // Appelez la méthode incrementer() ici

        // Appelez la méthode afficher() ici
    }
}

public class Compteur {
    int valeur = 0;

    void incrementer() {
        valeur++;
    }

    void reinitialiser() {
        valeur = 0;
    }

    void afficher() {
        System.out.println("Compteur : " + valeur);
    }
}

public class Main {
    public static void main(String[] args) {
        Compteur a = new Compteur();
        Compteur b = new Compteur();

        a.incrementer();
        a.incrementer();
        a.incrementer();
        b.incrementer();

        a.afficher();
        b.afficher();
    }
}

Compteur : 3
Compteur : 1

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 14.3.C Une variable, deux noms : que s'affiche-t-il ?

Lisez ce programme sans le lancer, puis écrivez ce qu'il affiche. Vérifiez ensuite en le lançant dans IntelliJ.

public class Chaton {
    String nom;
    int age;

    Chaton(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Chaton a = new Chaton("Mina", 1);
        Chaton b = a;
        Chaton c = new Chaton("Mina", 1);

        b.age = 5;

        System.out.println(a.age);
        System.out.println(b.age);
        System.out.println(c.age);
    }
}

5
5
1

Non vérifiable : pas de test automatique pour cet exercice (réponse libre, observation, saisie au clavier ou résultat qui change à chaque lancement). Comparez avec la solution une fois l'exercice terminé, ou montrez-le à votre formateur.

Exercice 14.4.A Vieillir

Ajoutez à Chat une méthode feterAnniversaire() qui augmente l'âge de 1. Appelez-la deux fois sur Félix puis affichez son âge (5).

public class Chat {
    // Constructeur : Chat(String nom, int age)
    // Méthode à écrire : void feterAnniversaire()
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : felix

        // Appelez la méthode feterAnniversaire() ici

        // Affichez le résultat ici
    }
}

public class Chat {
    String nom;
    int age;

    Chat(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }

    void feterAnniversaire() {
        age++;
    }
}

public class Main {
    public static void main(String[] args) {
        Chat felix = new Chat("Félix", 3);

        felix.feterAnniversaire();
        felix.feterAnniversaire();

        System.out.println(felix.age);   // 5
    }
}

5

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 14.5.A Une méthode qui parle

Ajoutez à Chat une méthode miauler() qui affiche Félix dit : Miaou ! (avec le nom du chat). Appelez-la depuis main.

public class Chat {
    // Constructeur : Chat(String nom, int age)
    // Méthode à écrire : void miauler()
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : felix

        // Appelez la méthode miauler() ici
    }
}

public class Chat {
    String nom;
    int age;

    Chat(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }

    void miauler() {
        System.out.println(nom + " dit : Miaou !");
    }
}

public class Main {
    public static void main(String[] args) {
        Chat felix = new Chat("Félix", 3);
        felix.miauler();
    }
}

Félix dit : Miaou !

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 14.5.B Un rectangle

Créez une classe Rectangle :

• deux attributs largeur et longueur (des double) ;
• un constructeur qui les initialise ;
• deux méthodes aire() et perimetre(), qui renvoient un double.

Dans main, créez un rectangle de 4 sur 5 et affichez son aire et son périmètre :

Aire : 20.0
Périmètre : 18.0

public class Rectangle {
    // Constructeur : Rectangle(double largeur, double longueur)
    // Méthode à écrire : double aire()
    // Méthode à écrire : double perimetre()
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : r

        // Affichez le résultat ici
    }
}

public class Rectangle {
    double largeur;
    double longueur;

    Rectangle(double largeur, double longueur) {
        this.largeur = largeur;
        this.longueur = longueur;
    }

    double aire() {
        return largeur * longueur;
    }

    double perimetre() {
        return 2 * (largeur + longueur);
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle r = new Rectangle(4, 5);

        System.out.println("Aire : " + r.aire());
        System.out.println("Périmètre : " + r.perimetre());
    }
}

Aire : 20.0
Périmètre : 18.0

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 14.6.A Un élève avec deux constructeurs

Créez une classe Eleve :

• deux attributs : prenom (String) et age (int) ;
• deux constructeurs :
  • un complet, Eleve(String prenom, int age) ;
  • un pratique, Eleve(String prenom), qui donne 18 ans par défaut ;
• une méthode sePresenter() qui affiche Je suis <prenom>, <age> ans.

Créez Camille (18 ans par défaut) et Hugo (22 ans) :

Je suis Camille, 18 ans.
Je suis Hugo, 22 ans.

public class Eleve {
    // Constructeur : Eleve(String prenom, int age)
    // Constructeur : Eleve(String prenom)
    // Méthode à écrire : void sePresenter()
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : camille

        // Créez votre objet ici : hugo

        // Appelez la méthode sePresenter() ici
    }
}

public class Eleve {
    String prenom;
    int age;

    // Constructeur n°1 : le complet
    Eleve(String prenom, int age) {
        this.prenom = prenom;
        this.age = age;
    }

    // Constructeur n°2 : le pratique, avec une valeur par défaut
    Eleve(String prenom) {
        this.prenom = prenom;
        this.age = 18;
    }

    void sePresenter() {
        System.out.println("Je suis " + prenom + ", " + age + " ans.");
    }
}

public class Main {
    public static void main(String[] args) {
        Eleve camille = new Eleve("Camille");
        Eleve hugo = new Eleve("Hugo", 22);

        camille.sePresenter();
        hugo.sePresenter();
    }
}

Je suis Camille, 18 ans.
Je suis Hugo, 22 ans.

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 15.3.A Une carte cadeau

Créez une classe CarteCadeau :

• un attribut privé solde, dont la valeur de départ est donnée au constructeur ;
• un getter getSolde() ;
• une méthode depenser(double montant) qui retire le montant seulement s'il reste assez de solde.

Dans main, créez une carte de 50 €.

public class CarteCadeau {
    // Attributs : solde
    // Constructeur : CarteCadeau(double solde)
    // Méthode à écrire : public double getSolde()
    // Méthode à écrire : public void depenser(double montant)
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : carte

        // Appelez la méthode depenser() ici

        // Affichez le résultat ici
    }
}

public class CarteCadeau {
    private double solde;

    public CarteCadeau(double solde) {
        this.solde = solde;
    }

    public double getSolde() {
        return solde;
    }

    public void depenser(double montant) {
        if (montant > 0 && montant <= solde) {
            solde -= montant;
        } else {
            System.out.println("Solde insuffisant.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        CarteCadeau carte = new CarteCadeau(50);

        carte.depenser(20);
        carte.depenser(40);   // Solde insuffisant.

        System.out.println(carte.getSolde());   // 30.0
    }
}

Solde insuffisant.
30.0

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 15.3.B Le setter du livre

Reprenez Livre. Ajoutez un setter setTitre(String titre) qui refuse un titre vide (titre.isEmpty()).

public void setTitre(String titre) {
    if (!titre.isEmpty()) {
        this.titre = titre;
    } else {
        System.out.println("Titre invalide.");
    }
}

Non vérifiable : pas de test automatique pour cet exercice (réponse libre, observation, saisie au clavier ou résultat qui change à chaque lancement). Comparez avec la solution une fois l'exercice terminé, ou montrez-le à votre formateur.

Exercice 15.4.A Le thermostat

Créez une classe Thermostat :

• un attribut privé temperature (un int, 19 au départ) ;
• un getter ;
• un setter setTemperature(int temperature) qui n'accepte que les valeurs entre 5 et 30 ; sinon, il affiche Température refusée : <valeur> et ne change rien.

Testez avec 22, puis 50 :

Température : 22
Température refusée : 50
Température : 22

public class Thermostat {
    // Attributs : temperature
    // Méthode à écrire : public int getTemperature()
    // Méthode à écrire : public void setTemperature(int temperature)
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : salon

        // Appelez la méthode setTemperature() ici

        // Affichez le résultat ici

        // Appelez la méthode setTemperature() ici

        // Affichez le résultat ici
    }
}

public class Thermostat {
    private int temperature = 19;

    public int getTemperature() {
        return temperature;
    }

    public void setTemperature(int temperature) {
        if (temperature >= 5 && temperature <= 30) {
            this.temperature = temperature;
        } else {
            System.out.println("Température refusée : " + temperature);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thermostat salon = new Thermostat();

        salon.setTemperature(22);
        System.out.println("Température : " + salon.getTemperature());

        salon.setTemperature(50);
        System.out.println("Température : " + salon.getTemperature());
    }
}

Température : 22
Température refusée : 50
Température : 22

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 15.5.A Tester le compte

Avec CompteBancaire, créez un compte de 100 €, déposez 50, retirez 30, tentez de retirer 500, puis affichez le solde (120.0).

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : compte

        // Appelez la méthode deposer() ici

        // Appelez la méthode retirer() ici

        // Déclarez votre variable ici : ok

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        CompteBancaire compte = new CompteBancaire("Léa", 100);

        compte.deposer(50);
        compte.retirer(30);

        boolean ok = compte.retirer(500);
        System.out.println("Retrait de 500 accepté ? " + ok);   // false

        System.out.println("Solde : " + compte.getSolde());     // 120.0
    }
}

Retrait de 500 accepté ? false
Solde : 120.0

Non vérifiable : pas de test automatique pour cet exercice (réponse libre, observation, saisie au clavier ou résultat qui change à chaque lancement). Comparez avec la solution une fois l'exercice terminé, ou montrez-le à votre formateur.

Exercice 15.5.B Un livret d'épargne

Créez une classe Livret :

• un attribut privé solde (un double), reçu par le constructeur ;
• un getter ;
• deux méthodes deposer(double montant) et retirer(double montant) ;
• pas de setter : le solde ne change que par ces deux méthodes.

Deux règles :

• un montant négatif ou nul est refusé (Montant invalide.) ;
• on ne peut pas retirer plus que le solde (Solde insuffisant.).

Testez : livret de 100 €, dépôt de 50, retrait de 500, retrait de 30.

Solde insuffisant.
Solde : 120.0 €

public class Livret {
    // Attributs : solde
    // Constructeur : Livret(double solde)
    // Méthode à écrire : public double getSolde()
    // Méthode à écrire : public void deposer(double montant)
    // Méthode à écrire : public void retirer(double montant)
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : livret

        // Appelez la méthode deposer() ici

        // Appelez la méthode retirer() ici

        // Affichez le résultat ici
    }
}

public class Livret {
    private double solde;

    public Livret(double solde) {
        this.solde = solde;
    }

    public double getSolde() {
        return solde;
    }

    public void deposer(double montant) {
        if (montant <= 0) {
            System.out.println("Montant invalide.");
            return;
        }
        solde += montant;
    }

    public void retirer(double montant) {
        if (montant <= 0) {
            System.out.println("Montant invalide.");
        } else if (montant > solde) {
            System.out.println("Solde insuffisant.");
        } else {
            solde -= montant;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Livret livret = new Livret(100);

        livret.deposer(50);
        livret.retirer(500);
        livret.retirer(30);

        System.out.println("Solde : " + livret.getSolde() + " €");
    }
}

Solde insuffisant.
Solde : 120.0 €

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 15.5.C Un mot de passe bien gardé

Créez une classe Compte :

• un attribut privé motDePasse (un String), sans getter ;
• un constructeur qui reçoit le mot de passe ;
• une méthode boolean verifier(String essai) qui renvoie true si l'essai est égal au mot de passe.

Dans main, créez un compte avec "secret", puis testez "secret" et "123456".

Pourquoi n'y a-t-il pas de getMotDePasse() ici ?

true
false

public class Compte {
    // Attributs : motDePasse
    // Constructeur : Compte(String motDePasse)
    // Méthode à écrire : public boolean verifier(String essai)
}

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : compte

        // Affichez le résultat ici
    }
}

public class Compte {
    private String motDePasse;

    public Compte(String motDePasse) {
        this.motDePasse = motDePasse;
    }

    public boolean verifier(String essai) {
        return motDePasse.equals(essai);
    }
}

public class Main {
    public static void main(String[] args) {
        Compte compte = new Compte("secret");

        System.out.println(compte.verifier("secret"));
        System.out.println(compte.verifier("123456"));
    }
}

true
false

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 16.2.A Compter les visiteurs

Créez une classe Visiteur avec un compteur static qui augmente à chaque nouvel objet. Créez 4 visiteurs et affichez le compteur (4).

public class Visiteur {
    // Attributs : total, nom
    // Constructeur : Visiteur(String nom)
    // Méthode à écrire : public static int getTotal()
}

public class Main {
    public static void main(String[] args) {
        // Créez vos objets ici

        // Affichez le résultat ici
    }
}

public class Visiteur {
    private static int total = 0;
    private String nom;

    public Visiteur(String nom) {
        this.nom = nom;
        total++;
    }

    public static int getTotal() {
        return total;
    }
}

public class Main {
    public static void main(String[] args) {
        new Visiteur("Léa");
        new Visiteur("Hugo");
        new Visiteur("Inès");
        new Visiteur("Noé");

        System.out.println(Visiteur.getTotal());   // 4
    }
}

4

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 16.3.A Une méthode utilitaire

Dans une classe Outils, écrivez public static int carre(int n) qui renvoie n * n. Affichez Outils.carre(7) (49).

public class Outils {
    // Méthode à écrire : public static int carre(int n)
}

public class Main {
    public static void main(String[] args) {
        // Affichez le résultat ici
    }
}

public class Outils {
    public static int carre(int n) {
        return n * n;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Outils.carre(7));   // 49
    }
}

49

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 16.3.B Utiliser Math

Avec la classe Math, calculez et affichez l'aire d'un disque de rayon 3 (Math.PI * rayon * rayon).

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : rayon

        // Calculez ici : aire

        // Affichez le résultat ici
    }
}

public class Main {
    public static void main(String[] args) {
        double rayon = 3;
        double aire = Math.PI * rayon * rayon;

        System.out.println("Aire : " + aire);
    }
}

Aire : 28.274333882308138

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 16.5.A Les constantes d'un jeu

Créez une classe Jeu avec deux constantes :

• VIES_MAX : 3 ;
• POINTS_PAR_PIECE : 10.

Dans main, un joueur ramasse 7 pièces : calculez son score avec la constante et affichez Score : 70, puis Vies : 3.

public class Jeu {
    // Attributs : VIES_MAX, POINTS_PAR_PIECE
}

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : pieces

        // Calculez ici : score

        // Affichez le résultat ici
    }
}

public class Jeu {
    public static final int VIES_MAX = 3;
    public static final int POINTS_PAR_PIECE = 10;
}

public class Main {
    public static void main(String[] args) {
        int pieces = 7;
        int score = pieces * Jeu.POINTS_PAR_PIECE;

        System.out.println("Score : " + score);
        System.out.println("Vies : " + Jeu.VIES_MAX);
    }
}

Score : 70
Vies : 3

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 17.2.A Ranger une bibliothèque

Créez deux classes dans le package fr.bibliotheque.modele :

1. Livre :
   • un titre ;
   • son getter.
2. Adherent :
   • un nom ;
   • une méthode emprunter(Livre livre) qui affiche Léa emprunte « Le Petit Prince ».

Mettez le Main dans le package fr.bibliotheque.

public class Livre {
    // Attributs : titre
    // Constructeur : Livre(String titre)
    // Méthode à écrire : public String getTitre()
}

public class Adherent {
    // Attributs : nom
    // Constructeur : Adherent(String nom)
    // Méthode à écrire : public void emprunter(Livre livre)
}

import fr.bibliotheque.modele.Adherent;
import fr.bibliotheque.modele.Livre;

public class Main {
    public static void main(String[] args) {
        // Créez votre objet ici : lea

        // Appelez la méthode emprunter() ici
    }
}

package fr.bibliotheque.modele;

public class Livre {
    private final String titre;

    public Livre(String titre) {
        this.titre = titre;
    }

    public String getTitre() {
        return titre;
    }
}

package fr.bibliotheque.modele;

public class Adherent {
    private final String nom;

    public Adherent(String nom) {
        this.nom = nom;
    }

    public void emprunter(Livre livre) {
        System.out.println(nom + " emprunte « " + livre.getTitre() + " »");
    }
}

package fr.bibliotheque;

import fr.bibliotheque.modele.Adherent;
import fr.bibliotheque.modele.Livre;

public class Main {
    public static void main(String[] args) {
        Adherent lea = new Adherent("Léa");
        lea.emprunter(new Livre("Le Petit Prince"));
    }
}

Léa emprunte « Le Petit Prince »

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 17.3.A Deux Date

Ce programme ne compile pas. Lisez le message, puis corrigez-le pour utiliser la Date de java.util, sans retirer aucun des deux imports *.

import java.sql.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Date aujourdhui = new Date();
        System.out.println(aujourdhui != null);
    }
}

Main.java:6: error: reference to Date is ambiguous
        Date aujourdhui = new Date();
        ^
  both class java.util.Date in java.util and class java.sql.Date in java.sql match
Main.java:6: error: reference to Date is ambiguous
        Date aujourdhui = new Date();
                              ^
  both class java.util.Date in java.util and class java.sql.Date in java.sql match
2 errors

import java.sql.*;
import java.util.*;
import java.util.Date;   // c'est cette Date-là qu'on veut

public class Main {
    public static void main(String[] args) {
        Date aujourdhui = new Date();
        System.out.println(aujourdhui != null);
    }
}

true

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 17.4.A Pythagore avec import static

Calculez l'hypoténuse d'un triangle rectangle de côtés 3 et 4 (√(a² + b²)), en écrivant sqrt et pow sans Math. devant.

import static java.lang.Math.pow;
import static java.lang.Math.sqrt;

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : a

        // Déclarez votre variable ici : b

        // Calculez ici : c

        // Affichez le résultat ici
    }
}

import static java.lang.Math.pow;
import static java.lang.Math.sqrt;

public class Main {
    public static void main(String[] args) {
        double a = 3;
        double b = 4;
        double c = sqrt(pow(a, 2) + pow(b, 2));
        System.out.println("Hypoténuse : " + c);
    }
}

Hypoténuse : 5.0

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 18.2.A La date de retour

Un livre est emprunté le 2026-10-19 pour 21 jours. Affichez À rendre le : 2026-11-09.

import java.time.LocalDate;

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : emprunt

        // Déclarez votre variable ici : retour

        // Affichez le résultat ici
    }
}

import java.time.LocalDate;

public class Main {
    public static void main(String[] args) {
        LocalDate emprunt = LocalDate.of(2026, 10, 19);
        LocalDate retour = emprunt.plusDays(21);

        System.out.println("À rendre le : " + retour);
    }
}

À rendre le : 2026-11-09

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 18.3.A Le livre est-il en retard ?

La date limite est le 2026-11-09 et nous sommes le 2026-11-12. Affichez En retard si la date du jour est après la limite, sinon Dans les temps.

import java.time.LocalDate;

public class Main {
    public static void main(String[] args) {
        // Déclarez votre variable ici : limite

        // Déclarez votre variable ici : aujourdhui

        // Écrivez votre condition ici (if / else)
    }
}

import java.time.LocalDate;

public class Main {
    public static void main(String[] args) {
        LocalDate limite = LocalDate.of(2026, 11, 9);
        LocalDate aujourdhui = LocalDate.of(2026, 11, 12);

        if (aujourdhui.isAfter(limite)) {
            System.out.println("En retard");
        } else {
            System.out.println("Dans les temps");
        }
    }
}

En retard

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.

Exercice 18.4.A La rentrée en français

La rentrée est le 2026-09-01. Affichez Rentrée : 01/09/2026, puis, sur la ligne suivante, Vacances : 21/10/2026 pour la date 2026-10-21.

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        // Calculez ici : francais

        // Déclarez votre variable ici : rentree

        // Déclarez votre variable ici : vacances

        // Affichez le résultat ici
    }
}

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        DateTimeFormatter francais = DateTimeFormatter.ofPattern("dd/MM/yyyy");
        LocalDate rentree = LocalDate.of(2026, 9, 1);
        LocalDate vacances = LocalDate.of(2026, 10, 21);

        System.out.println("Rentrée : " + rentree.format(francais));
        System.out.println("Vacances : " + vacances.format(francais));
    }
}

Rentrée : 01/09/2026
Vacances : 21/10/2026

Vérifiable : cet exercice a un test automatique. Dans IntelliJ, ouvrez tests > le chapitre > l'exercice > MainTest, puis cliquez sur le triangle vert : une coche verte signifie que votre programme affiche bien le résultat attendu.