Cours Java et Eclipse en PDF (Intermédiaire)

TP1 Initiation à Java et Eclipse : Ce qu'il faut savoir. Document pédagogique présentant l'installation et l'usage de l'environnement Java (JDK/JRE/JVM) et l'utilisation d'Eclipse pour créer, compiler et exécuter des projets Java. L'objectif pédagogique est d'amener l'étudiant à concevoir des classes Java, appliquer les règles d'encapsulation, gérer l'héritage et l'association, et exécuter des programmes avec des arguments via les Run Configurations d'Eclipse ; le PDF est proposé en accès gratuit et édité par l'Université de l'Oued, support universitaire reconnu pour la formation en informatique.

🎯 Ce que vous allez apprendre

Liste des compétences visées par le TP1.

Prérequis techniques

• Installation du JDK
• Configuration système : variables d'environnement et chemin d'exécution

• Architecture Java : JDK, JRE et JVM — comprendre le rôle distinct du JDK (outils de compilation comme javac, jar, javadoc, jdb) et du JRE pour l'exécution sur la JVM. Savoir diagnostiquer un problème de compilation versus un problème d'exécution et configurer correctement le chemin d'exécution dans Eclipse.
• Prise en main d'Eclipse et gestion d'un workspace — maîtriser la création d'un projet Java, la structure src / package / JRE System Library et l'utilisation des vues d'Eclipse. Démarche pas à pas pour créer votre premier programme Java et procédure claire pour configurer les Run Configurations afin de passer des arguments à public static void main(String[] args).
• Syntaxe de base et méthode main — écrire et exécuter un programme Hello World, utiliser System.out.println et manipuler les arguments de la JVM.
• Programmation orientée objet : classes, objets et constructeurs — modéliser des entités avec attributs et méthodes, définir plusieurs constructeurs et instancier des objets avec new. Implémentation conforme à un diagramme de classes et gestion des constructeurs paramétrés pour initialiser l'état des objets.
• Encapsulation, visibilité et héritage — appliquer les modificateurs public, protected et private, construire une hiérarchie via extends et appeler explicitement les constructeurs des superclasses.
• Association d'objets et sémantique du passage des arguments — représenter les relations par références et comprendre le passage par valeur des références en Java. Implémenter des interactions entre instances (par ex. une association Encherisseur ↔ ObjetEnVente) et anticiper les effets des modifications d'une référence passée en paramètre.
• Étude de cas pratique : Vente aux enchères (exercices TAF) — réaliser l'application complète demandée dans le TP : classes Encherisseur et ObjetEnVente, logique d'abandon et mise à jour de la valeur, affichage du gagnant. Exercices guidés à exécuter et tester dans Eclipse.

Votre premier programme Java avec Eclipse

Créer son premier programme dans Eclipse suit des étapes reproductibles : créer un nouveau projet Java, ajouter un package dans le dossier src, créer une classe publique contenant la méthode public static void main(String[] args), puis exécuter via Run As → Java Application. Pour passer des arguments, ouvrir Run Configurations et renseigner la section Arguments. Le tutoriel propose également l'exécution depuis la ligne de commande pour vérifier le comportement hors IDE et apprendre à compiler avec javac puis lancer la JVM via java, utile pour diagnostiquer des différences entre IDE et environnement natif.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

💡 Pourquoi utiliser Eclipse pour Java ?

Eclipse facilite le développement Java grâce à un compilateur incrémental, un débogueur intégré et des vues de projet adaptées aux besoins pédagogiques. Comparé à IntelliJ ou VS Code, Eclipse offre une intégration historique des projets Java et une configuration fine des Run Configurations, appréciée en laboratoire universitaire. L'Université de l'Oued recommande Eclipse pour son extensibilité et sa compatibilité avec les environnements d'enseignement, rendant les exercices reproductibles pour les étudiants.

Guide : Compiler et exécuter Java sans IDE

Compiler et exécuter Java depuis la ligne de commande aide à comprendre le rôle du compilateur et de la JVM et permet de reproduire les comportements hors IDE. Ce guide couvre les commandes essentielles et les étapes minimales pour compiler un fichier source et l'exécuter dans un terminal, complément utile au tutoriel Eclipse pas à pas.

Compilation manuelle avec javac

Exemple minimal pour compiler et lancer un programme HelloWorld depuis un terminal :

javac HelloWorld.java
java HelloWorld

Si la classe est dans un package, utiliser la structure de dossiers correspondante et lancer java depuis la racine du classpath. Ces commandes permettent de vérifier le résultat exact produit par la JVM sans l'intervention de l'IDE.

Guide d'installation rapide du JDK

Étapes essentielles : télécharger la distribution officielle adaptée à votre système (Windows, Linux ou macOS), exécuter l'installateur et définir la variable d'environnement JAVA_HOME, puis ajouter %JAVA_HOME%/bin (Windows) ou $JAVA_HOME/bin (Linux/macOS) au PATH. Sur Windows : installer le package officiel, ouvrir « Paramètres » → « Système » → « Informations système » → « Paramètres système avancés » → « Variables d'environnement » et créer/modifier JAVA_HOME, puis redémarrer la session utilisateur. Sur Linux (bash), ajouter dans ~/.bashrc ou ~/.profile : export JAVA_HOME=/chemin/vers/jdk et export PATH=$JAVA_HOME/bin:$PATH, puis exécuter source ~/.bashrc. Ces étapes assurent la compatibilité entre le JDK et Eclipse et facilitent le diagnostic en cas d'erreur.

Types primitifs Java : synthèse

Contenu du TP1 : De l'installation à la POO

Le TP1 combine installation du JDK, configuration d'Eclipse (workspace, projet, JRE System Library), création d'un premier programme Java et usage des outils de compilation et d'exécution intégrés. La progression propose des exercices courts et des tâches TAF orientées code pour valider la compréhension de la POO : définition de classes, constructeurs, encapsulation, héritage et associations. Des conseils pratiques de debugging et des instructions pour les Run Configurations facilitent l'exécution des programmes avec arguments.

Support de TP1 : Exercices et mise en pratique

Le support inclut des TAF structurés, des scénarios de test pour Eclipse et des recommandations d'évaluation pratique. Les énoncés invitent à coder, compiler et exécuter dans l'IDE afin d'ancrer les compétences techniques et procédurales. Exercices corrigés fournis pour le suivi et l'auto-évaluation sont disponibles dans le PDF, favorisant un apprentissage autonome et progressif.

Exercices corrigés de Programmation Orientée Objet

Une série d'exercices corrigés accompagne la théorie : création de classes, relations d'association, héritage et gestion des constructeurs. Ces exercices, conçus pour le format TP, incluent des jeux de tests à exécuter dans Eclipse et des versions lignes de commande pour l'évaluation. Ils complètent le tutoriel Eclipse pas à pas et permettent de vérifier la maîtrise des notions clefs, utile pour un premier programme java et pour apprendre à compiler java ligne de commande.

📑 Sommaire du document

• Objectifs du TP
• Environnement de Développement : Eclipse
• Nouveau projet : Hello World
• Cas d’étude : Vente aux enchères
• Classes et objets
• Encapsulation
• Héritage
• Variables statiques et partagées

💡 Pourquoi choisir ce cours ?

Ce TP met en regard la prise en main d'un IDE professionnel avec des exercices pratiques de POO via une étude de cas exploitable en laboratoire. Produit par l'Université de l'Oued, il propose une progression par tâches (TAF) qui impose de coder, compiler et exécuter, renforçant l'apprentissage pratique. Les consignes de configuration (JDK/JRE) et les procédures pour les Run Configurations rendent ce tutoriel opérationnel pour les étudiants.

👤 À qui s'adresse ce cours ?

• Public cible : étudiants en informatique ou développeurs débutants en Java cherchant à consolider la POO et l'usage d'un IDE professionnel.
• Prérequis : notions de programmation impérative (variables, boucles, fonctions), familiarité élémentaire avec le système de fichiers et la ligne de commande, compréhension basique des algorithmes.

❓ Foire Aux Questions (FAQ)