Cours Bases du langage Java en PDF (Intermédiaire)

Les bases du langage Java : Ce qu'il faut savoir. Java est un langage de programmation orientée objet, fortement typé, livré avec une machine virtuelle (JVM) et un ensemble d'outils (JDK) pour compiler et exécuter du bytecode. Sa portabilité via le bytecode, son typage strict et son écosystème de bibliothèques en font un choix central pour le développement d'applications multiplateformes.

🎯 Ce que vous allez apprendre

• Principes de la programmation orientée objets (POO) — définition concrète des concepts d'objet, classe, héritage et encapsulation. Comprendre comment la POO structure le code pour la modularité et la réutilisabilité et savoir modéliser des entités métier en classes Java utilisables dans des projets réels.
• Structure d'une classe Java et ses membres — attributs, méthodes, accesseurs, méthodes de classe et le mot-clé this. Déclarer des classes robustes, définir l'état via attributs et exposer des API d'accès cohérentes (getters/setters) pour préserver l'encapsulation.
• Constructeurs et mécanisme d'instanciation — surcharge des constructeurs, constructeur par défaut et mécanisme d'instanciation. Initialiser correctement des objets, proposer plusieurs chemins de création et éviter les erreurs d'état non initialisé.
• Chaîne de compilation et exécution Java — compréhension du passage source → bytecode → JVM et utilisation pratique des commandes javac HelloWorld.java et java HelloWorld. Compiler et lancer des programmes Java en ligne de commande ou via un IDE.
• Fonctionnement de la JVM et optimisation — vérification du bytecode, chargement de classes, rôle du JIT et du HotSpot. Expliquer les compromis performance/portabilité et optimiser des sections critiques en tenant compte du garbage collector et du JIT.
• Bibliothèques et classes utiles — usage pratique de classes de base telles que String, tableaux et types enveloppe (wrappers). Manipuler chaînes, tableaux et conversions de types, indispensables pour écrire des applications Java correctes et performantes.

📑 Sommaire du document

• Introduction
• Conception par objets
• Encapsulation
• Instanciation
• Compilation
• Classes utiles

💡 Pourquoi choisir ce cours ?

Support signé Julien Sopena (INRIA / LIP6), utilisé dans une Licence professionnelle DANT, garantissant une orientation académique et pratique. Le document inclut des exemples de code concrets et des exercices en .java pour la mise en pratique, avec extraits de commandes réelles pour la configuration et l'exécution. Les éléments pédagogiques privilégient la rigueur méthodologique et l'applicabilité en contexte professionnel.

👤 À qui s'adresse ce cours ?

• Public cible : étudiants en licence et professionnels de niveau Débutant en Java, développeurs souhaitant passer du C++ au Java et souhaitant consolider leurs fondamentaux Java et comprendre la JVM.
• Prérequis : connaissances de base en programmation impérative (variables, structures de contrôle), familiarité avec la syntaxe C-like et une utilisation élémentaire de la ligne de commande pour compiler/exécuter des programmes.

Ce cours fait le pont entre les bases fondamentales et les concepts intermédiaires (gestion de la mémoire, premières notions de concurrence), facilitant la transition vers des projets réels et justifiant le niveau « Intermédiaire » indiqué dans le titre.

Maîtriser la compilation : de .java au .class

Création d'un fichier source .java et transformation en .class sont des étapes fondamentales du workflow Java. Le fichier source doit respecter la convention de nommage de la classe publique et l'extension .java. La compilation produit un fichier .class contenant le bytecode exécutable par la JVM. La définition formelle de la syntaxe du langage et des comportements attendus pour la compilation est précisée par la Java Language Specification (JLS), référence indispensable pour les spécifications du compilateur et la conformité du bytecode.

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

Commandes courantes :

javac HelloWorld.java
java HelloWorld

Structure d'un programme Java et compilation

Un programme Java typique comporte des packages, des imports, une ou plusieurs classes et éventuellement une méthode main pour l'exécution. La compilation peut être effectuée fichier par fichier ou via des outils de build (Maven, Gradle) pour gérer dépendances et phases de compilation. Comprendre la structure facilite la modularité, les tests unitaires et l'intégration continue.

Syntaxe : Instructions et Blocs

La syntaxe Java suit un style C-like : déclarations, expressions et blocs définissent l'organisation du code source. La JLS (Java Language Specification) fixe les règles formelles ; s'y référer garantit la conformité du code et la portabilité du bytecode exécutable. Respecter la ponctuation et les conventions de nommage améliore la lisibilité et réduit les erreurs au moment de la compilation.

Règles de ponctuation en Java

• Chaque instruction opérationnelle se termine par un point-virgule ;, à l'exception des déclarations de classe, méthode ou bloc qui n'en requièrent pas.
• Les conditions des structures for utilisent des points-virgules pour séparer initialisation, condition et incrémentation.
• Les blocs sont délimités par des accolades {} et définissent la portée des variables et déclarations ; les accolades s'appliquent aux classes, méthodes et structures de contrôle.
• Respecter l'indentation et les conventions de nommage (classes en PascalCase, méthodes et variables en camelCase) facilite la maintenance.

Syntaxe et règles d'écriture en Java

• Chaque instruction se termine par un point-virgule ;.
• Les blocs sont délimités par des accolades {} et définissent la portée des variables et déclarations.
• Pour une instruction simple, les accolades peuvent être omises, mais les utiliser systématiquement réduit les erreurs et améliore la lisibilité.
• Respecter l'indentation et les conventions de nommage facilite la maintenance et la relecture du code ; se référer à la JLS pour les règles formelles.
• Fermer explicitement les flux et ressources (appel à close()) est essentiel pour éviter les fuites ; préférer les mécanismes automatiques présentés ci‑dessous.

Installation du JDK et configuration de l'environnement

Télécharger et installer le JDK adapté à votre système permet de disposer des outils de compilation et d'exécution. Depuis Java 11, le JRE est inclus dans la distribution du JDK. Les versions LTS recommandées sont Java 8, 11, 17 et 21 ; Java 21 est la LTS la plus récente et constitue un bon choix pour les nouveaux projets. Après installation, vérifiez les variables d'environnement (JAVA_HOME, PATH) et testez java -version et javac -version. Pour des environnements professionnels, l'utilisation d'un gestionnaire de versions (SDKMAN!, jenv) simplifie la coexistence de plusieurs distributions et versions.

Les meilleurs IDE pour pratiquer le Java

Bien que l'usage de la ligne de commande aide à comprendre la chaîne de compilation, l'utilisation d'un IDE reste recommandée pour des projets complexes : débogage intégré, refactorings automatisés, gestion de dépendances et intégration avec Maven/Gradle accélèrent le développement et réduisent les erreurs.

Outils de développement (IDE)

• IntelliJ IDEA — IDE très complet, riche en fonctionnalités pour la programmation objet, gestion avancée de projets Maven/Gradle et refactorings. Recommandé pour des projets professionnels et l'optimisation de productivité.
• Eclipse — plateforme modulable et extensible, largement utilisée dans l'industrie, adaptée aux environnements d'entreprise et aux outils open source.
• NetBeans — interface simple, bonne intégration des fonctionnalités Java de base, utile pour un apprentissage progressif.

Comparatif : Pourquoi passer du C++ au Java ?

Java offre une portabilité accrue grâce au bytecode et à la JVM, un modèle de mémoire géré (garbage collector) réduisant les risques d'erreurs liées à la gestion manuelle de la mémoire, et une bibliothèque standard riche facilitant le développement. C++ conserve des avantages en performance brute et contrôle bas niveau ; Java privilégie la sécurité, la productivité et la portabilité, des atouts pour des applications d'entreprise et des services multiplateformes.

Pourquoi Java est-il plus sûr que le C++ ?

La sécurité de Java repose sur la vérification du bytecode, le typage fort, les vérifications à l'exécution (contrôle des limites de tableaux, absence de pointeurs bruts) et la gestion automatique de la mémoire. Le modèle de sécurité de la JVM limite les accès non autorisés et réduit les vulnérabilités courantes en C++ (use-after-free, buffer overflow).

Origines et évolution : de Oak à Java 21

Initialement nommé Oak en 1991 chez Sun Microsystems par James Gosling, Java visait les appareils ménagers avant de devenir un standard pour le développement multiplateforme. L'évolution vers Java 2 a structuré l'écosystème et la gouvernance a changé au fil du temps : Oracle assure la maintenance des versions standards tandis que la communauté et des distributions open source contribuent à l'écosystème. La JLS reste la référence formelle pour la syntaxe et la conformité du bytecode exécutable.

Gestion des flux et des exceptions en Java

La gestion correcte des flux d'entrée/sortie et des ressources est cruciale pour éviter les fuites et garantir la robustesse d'une application. Fermer explicitement un flux via close() libère des ressources système ; ne pas le faire peut mener à des fuites de descripteurs et à des comportements imprévisibles en production. Les APIs modernes et les bonnes pratiques recommandent l'utilisation de constructions sûres présentées ci‑dessous.

Gestion des exceptions et des ressources

Le mécanisme try-with-resources automatise la fermeture des ressources implémentant AutoCloseable, réduisant le risque d'oubli de close() et simplifiant le code de gestion d'erreur. Exemple :

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line = br.readLine();
    // traitement...
} catch (IOException e) {
    e.printStackTrace();
}

Concepts intermédiaires : gestion de la mémoire et concurrence

Notions de niveau intermédiaire traitées de façon pragmatique : distinction Stack vs Heap, principes du garbage collector et impacts sur la performance, ainsi qu'une première approche de la concurrence. Ces thèmes aident à diagnostiquer et corriger des problèmes de performance et de mémoire dans des applications réelles, en s'appuyant sur la JLS et les recommandations des distributions Java.

Gestion de la concurrence (Threads)

Présentation du multi-threading en Java : création de threads via Thread et Runnable, synchronisation élémentaire avec synchronized, et risques associés (conditions de course, interblocages). Le contenu aborde aussi les utilitaires du package java.util.concurrent pour des patterns plus sûrs et évolutifs, et montre comment mesurer l'impact des threads sur le garbage collector et les performances.

❓ Foire Aux Questions (FAQ)

Comment la JVM assure-t-elle la sécurité et la portabilité du bytecode ? La JVM effectue une passe de vérification du bytecode (contrôles de type, taille de pile, flot de données, initialisation des variables) avant exécution, puis charge les classes et applique des optimisations JIT pour produire du code natif si nécessaire ; ces étapes contribuent à l'exécution sûre d'un .class sur différentes architectures.

Quel est l'effet réel du JIT/HotSpot sur les performances d'une application Java ? Le JIT (HotSpot) traduit à la volée les portions de bytecode fréquemment exécutées en code machine natif, réduisant l'impact de l'interprétation initiale ; il y a un coût d'optimisation à chaud, mais pour les applications longue durée le JIT améliore significativement le débit.