Exercices en JAVA

Ce document présente un recueil d'exercices corrigés en langage Java, destiné principalement aux étudiants en informatique et aux programmeurs souhaitant maîtriser Java, notamment dans sa version 8. Il couvre un large éventail de notions fondamentales et avancées du langage, organisées en 18 chapitres thématiques, avec des exercices pratiques accompagnés de solutions détaillées.

Présentation générale du recueil

Ce recueil comprend 175 exercices corrigés, répartis en 18 chapitres thématiques. Chaque chapitre débute par une liste des notions nécessaires à la résolution des exercices (section Prérequis). Certains exercices ciblent une notion précise, tandis que d'autres, appelés exercices de synthèse, combinent plusieurs notions et demandent un effort de réflexion plus important.

Les solutions détaillées sont fournies, avec le code source disponible en ligne sur le site www.editions-eyrolles.com.

Public visé

• Étudiants en cursus universitaire (DUT, licence, master, MIAGE) et élèves des écoles d’ingénieurs.
• Programmeurs expérimentés dans d’autres langages (Python, PHP, C/C++…) souhaitant s’initier à Java.

Organisation des chapitres et thèmes abordés

Les exercices sont regroupés selon les thèmes suivants :

• Les opérateurs et expressions (10 exercices) : Priorités, conversions, opérateurs logiques, conditionnels.
• Les instructions de contrôle (12 exercices) : if, switch, boucles for, while, do... while, break, continue.
• Les classes et les objets Java (23 exercices) : Création, initialisation, méthodes, champs, récursivité, objets membres.
• Les tableaux (14 exercices) : Déclaration, initialisation, passage en argument, tableaux multidimensionnels.
• L’héritage et le polymorphisme (14 exercices) : Classes dérivées, redéfinition, polymorphisme, classes abstraites, interfaces.
• La classe String et les chaînes de caractères (9 exercices) : Construction, accès aux caractères, manipulation, redéfinition de toString.
• Les types énumérés (7 exercices) : Définition, itération, ajout de méthodes et champs.
• La gestion des exceptions (10 exercices) : Déclenchement, traitement, propagation, bloc finally.
• Les bases de la programmation événementielle (12 exercices) : Écouteurs, gestion des clics, création et suppression de boutons, dessin.
• Les principaux contrôles de Swing (9 exercices) : Cases à cocher, boutons radio, champs de texte, boîtes de liste.
• Les boîtes de dialogue (6 exercices) : Messages, confirmations, saisie.
• Les menus et les actions (7 exercices) : Création, gestion, activation/désactivation, menus composés.
• Les événements de bas niveau : souris et clavier (8 exercices) : Identification des boutons, doubles-clics, suivi des déplacements.
• Les applets Java (6 exercices) : Comptage d’arrêts, dessin, différences avec les applications.
• Les fichiers (5 exercices) : Création, lecture, consultation de répertoires.
• La programmation générique (10 exercices) : Classes et méthodes génériques, effacement, héritage.
• Les collections (5 exercices) : Manipulation, tri, indexation.
• Les expressions lambda et les streams (9 exercices) : Interfaces fonctionnelles, références, méthodes usuelles des streams, opérations reduce et collect.

Exemple d'exercice type : Les instructions de contrôle

Exercice 14 : Comparaison entre for, while et do... while

Objectif : Comprendre les différences de syntaxe et d'exécution entre les trois types de boucles.

int i = 0;
// Boucle for
for (i = 0; i < 5; i++) {
    System.out.println("for : " + i);
}

// Boucle while
i = 0;
while (i < 5) {
    System.out.println("while : " + i);
    i++;
}

// Boucle do... while
i = 0;
do {
    System.out.println("do...while : " + i);
    i++;
} while (i < 5);

Chaque boucle affiche les nombres de 0 à 4. La différence principale est que la boucle do... while exécute son corps au moins une fois, même si la condition est fausse dès le départ.

Exemple d'exercice type : Les expressions lambda et les streams

Exercice 172 : Les méthodes usuelles des streams

Objectif : Utiliser les streams pour traiter des collections de données de manière fonctionnelle.

List<String> noms = Arrays.asList("Alice", "Bob", "Charlie", "David");

// Filtrer les noms commençant par 'A' et les afficher
noms.stream()
    .filter(n -> n.startsWith("A"))
    .forEach(System.out::println);

Ce code utilise une expression lambda pour filtrer la liste et affiche les noms commençant par la lettre 'A'.

Glossaire des termes clés

• Classe : Modèle définissant des objets avec des attributs (champs) et des comportements (méthodes).
• Objet : Instance d’une classe.
• Héritage : Mécanisme permettant de créer une nouvelle classe à partir d’une classe existante.
• Polymorphisme : Capacité d’un objet à prendre plusieurs formes, notamment via la redéfinition de méthodes.
• Expression lambda : Fonction anonyme utilisée pour passer du code comme argument.
• Stream : Séquence d’éléments sur laquelle on peut effectuer des opérations fonctionnelles.
• Exception : Événement signalant une erreur ou situation exceptionnelle durant l’exécution.
• Tableau : Structure de données contenant une collection d’éléments du même type.
• Interface : Contrat définissant un ensemble de méthodes sans implémentation.
• Type énuméré : Type définissant un ensemble fini de constantes nommées.
• Swing : Bibliothèque Java pour la création d’interfaces graphiques.
• Applet : Petite application Java s’exécutant dans un navigateur web.
• Flux (Stream) : Abstraction pour la lecture ou l’écriture de données.
• Générique : Mécanisme permettant de définir des classes ou méthodes paramétrées par des types.

Points clés à retenir

• Ce recueil couvre un large spectre des notions essentielles et avancées du langage Java, avec un total de 175 exercices corrigés.
• Chaque chapitre est structuré autour de notions préalables clairement identifiées, facilitant l’apprentissage progressif.
• Les exercices de synthèse permettent de consolider les connaissances en combinant plusieurs concepts.
• La quatrième édition intègre les nouveautés de Java 8, notamment les expressions lambda et les streams.
• Le recueil s’adresse aussi bien aux étudiants qu’aux programmeurs expérimentés venant d’autres langages.
• Les solutions détaillées et le code source sont accessibles en ligne, offrant un support pédagogique complet.