Cours : Introduction à Java et son Écosystème

1. Histoire de Java

1.1 Les Origines (1991-1995)

Java est né d'un projet interne chez Sun Microsystems appelé "The Green Project". Initié par James Gosling, Mike Sheridan et Patrick Naughton en 1991, le projet visait à créer un langage pour les appareils électroniques grand public (set-top boxes, télévisions interactives).

Le langage s'appelait initialement "Oak" (chêne), en référence à un arbre visible depuis le bureau de Gosling. Oak fut renommé "Java" en 1995 pour des raisons de droits d'auteur (Oak existait déjà).

1.2 La Révolution Internet (1995-1999)

• Mai 1995 : Sun officialise Java à la conférence SunWorld
• 1996 : Sortie de JDK 1.0 (applets Java, AWT)
• 1997 : JDK 1.1 (inner classes, JDBC, RMI, reflection)
• 1998 : J2SE 1.2 (Swing, Collections Framework, JIT compiler)
• 1999 : J2SE 1.3 (HotSpot JVM, JNDI, JavaSound)

1.3 La Maturité (2000-2009)

• 2000 : J2SE 1.3 (HotSpot JVM)
• 2002 : J2SE 1.4 (assert, NIO, logging, regex, XML)
• 2004 : J2SE 5.0 (generics, annotations, enum, autoboxing, for-each)
• 2006 : Java SE 6 (Scripting API, JDBC 4.0, Compiler API)
• 2009 : Oracle rachète Sun Microsystems pour 7,4 milliards de dollars

1.4 L'Ère Oracle (2010-2017)

• 2011 : Java SE 7 (Project Coin : try-with-resources, multi-catch, switch String, NIO.2)
• 2014 : Java SE 8 (lambdas, streams, Optional, Date/Time API, default methods)
• 2017 : Java SE 9 (modules JPMS, jshell, Collection factory methods, Process API)

1.5 Le Cycle Semestriel (2018-2026)

• 2018 : Java SE 10 (var, local-variable type inference), Java SE 11 (LTS : HttpClient, nest-based access)
• 2019 : Java SE 12-13 (switch expressions preview, text blocks preview)
• 2020 : Java SE 14-15 (records preview, pattern matching preview, sealed classes preview)
• 2021 : Java SE 16-17 (LTS : records, sealed classes, pattern matching for instanceof)
• 2022 : Java SE 18-19 (UTF-8 by default, virtual threads preview)
• 2023 : Java SE 20-21 (LTS : virtual threads, record patterns, pattern matching for switch)
• 2024-2026 : Java 22-24 (stream gatherers, structured concurrency, scoped values, flexible constructor bodies)

1.6 Les Jalons Clés

2. JVM, JDK, JRE

2.1 Définitions

JVM (Java Virtual Machine) : Machine virtuelle qui exécute le bytecode Java. C'est le cœur de la portabilité de Java ("Write Once, Run Anywhere").

JRE (Java Runtime Environment) : Environnement d'exécution contenant la JVM + les bibliothèques de classe standard (rt.jar / java.base). Nécessaire pour exécuter des applications Java.

JDK (Java Development Kit) : Kit de développement contenant le JRE + les outils de développement (javac, jar, javadoc, jshell, etc.). Nécessaire pour développer en Java.

2.2 Architecture de la JVM

┌─────────────────────────────────────┐
│         Class Loader Subsystem       │
│  (Bootstrap, Extension, Application) │
├─────────────────────────────────────┤
│         Runtime Data Areas           │
│  ┌───────────┐  ┌────────────────┐  │
│  │ Heap (tas) │  │ Method Area    │  │
│  │ (Young/     │  │ (class data)   │  │
│  │  Old Gen)  │  │                │  │
│  └───────────┘  └────────────────┘  │
│  ┌───────────┐  ┌────────────────┐  │
│  │ JVM Stack │  │ PC Registers   │  │
│  │ (frames)  │  │                │  │
│  └───────────┘  └────────────────┘  │
│  ┌───────────┐  ┌────────────────┐  │
│  │ Native    │  │ Metaspace      │  │
│  │ Stack     │  │ (Java 8+)      │  │
│  └───────────┘  └────────────────┘  │
├─────────────────────────────────────┤
│         Execution Engine             │
│  (Interpreter, JIT Compiler, GC)    │
├─────────────────────────────────────┤
│      Native Interface (JNI)         │
└─────────────────────────────────────┘

2.3 Garbage Collection

La JVM gère automatiquement la mémoire via le Garbage Collector (GC). Les principaux algorithmes :

• Serial GC : Mono-thread, pour applications clientes
• Parallel GC (Throughput) : Multi-thread, pour applications batch
• G1 GC (Garbage-First) : Par défaut depuis Java 9, conçu pour les grands tas
• ZGC : Faible latence (<10ms), disponible depuis Java 11 (expérimental) et stable depuis Java 15
• Shenandoah : Faible latence, pause réduite, disponible depuis Java 12

2.4 Compilation JIT (Just-In-Time)

La JVM compile le bytecode en code natif à l'exécution. Les technologies :

• C1 (Client Compiler) : Compilation rapide, optimisations légères
• C2 (Server Compiler) : Compilation lente, optimisations agressives
• Graal JIT : Compilateur JIT écrit en Java, alternative à C2
• AOT (Ahead-of-Time) : Compilation native avec GraalVM (native-image)

2.5 Distributions JDK

• Oracle JDK : Distribution commerciale (licence NFTC)
• OpenJDK : Référence open-source (GPL+CE)
• Adoptium (Eclipse Temurin) : Builds OpenJDK gratuits et certifiés
• Amazon Corretto : Distribution AWS, support longue durée
• Azul Zulu : Distribution Azul, optimisée pour le cloud
• GraalVM : JDK Oracle supportant la compilation native et le polyglottisme
• Liberica JDK : Distribution BellSoft, inclut JavaFX

3. Écosystème Java

3.1 Build Tools (Outils de build)

Apache Maven

• Fichier : pom.xml
• Approche : Convention over configuration
• Cycle de vie : clean → validate → compile → test → package → verify → install → deploy
• Avantages : Standardisation, dépendances transitives, large écosystème de plugins
• Inconvénients : Verbosité XML, rigidité

Gradle

• Fichier : build.gradle (Groovy) ou build.gradle.kts (Kotlin DSL)
• Approche : Build incremental, graphe de tâches
• Avantages : Performance (cache, incrémental), DSL flexible
• Inconvénients : Courbe d'apprentissage, compatibilité des plugins

3.2 Frameworks Principaux

3.3 IDE (Environnements de Développement)

3.4 Bibliothèques Essentielles

<!-- Maven : dépendances essentielles -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.0.0-jre</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.16.0</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.14</version>
</dependency>

3.5 Testing

• JUnit 5 : Framework de test standard (Jupiter, Vintage)
• Mockito : Mocking et vérification
• AssertJ : Assertions fluides
• Testcontainers : Tests d'intégration avec conteneurs Docker
• Selenium : Tests d'interface web
• Cucumber : BDD (Behavior-Driven Development)
• ArchUnit : Tests d'architecture

3.6 Monitoring et Observabilité

• Micrometer : Métriques pour Spring Boot
• Prometheus : Collecte de métriques
• Grafana : Visualisation de métriques
• ELK Stack (Elasticsearch, Logstash, Kibana) : Centralisation de logs
• OpenTelemetry : Traces distribuées
• JMX (Java Management Extensions) : Monitoring JVM

4. Roadmap du Cursus

┌─────────────────────────────────────────────────────────────┐
│                    MODERN JAVA ENGINEERING                   │
├───────────────┬──────────────────────┬──────────────────────┤
│  Fondamentaux │   Approfondissement  │     Écosystème       │
├───────────────┼──────────────────────┼──────────────────────┤
│  Ch. 00       │   Ch. 03             │   Ch. 06             │
│  Introduction │   Java 8-17-21       │   Spring Core        │
│               │   (Lambdas, Streams, │   (IoC, DI, AOP)     │
│               │    Records, etc.)    │                      │
├───────────────┼──────────────────────┼──────────────────────┤
│  Ch. 01       │   Ch. 04             │   Ch. 07             │
│  Fondamentaux │   Concurrence        │   Spring Boot        │
│  Java         │   (Threads,          │   (Auto-config,      │
│  (Types, I/O, │    Virtual Threads)  │    REST, Actuator)   │
│   Exceptions) │                      │                      │
├───────────────┼──────────────────────┼──────────────────────┤
│  Ch. 02       │   Ch. 05             │   Ch. 08             │
│  Java et      │   JDBC et Bases      │   Spring             │
│  les Objets   │   de Données         │   Microservices      │
│  (OOP,        │   (JPA, Hibernate,   │   (Cloud, Gateway,   │
│   Generics)   │    Flyway)           │    Resilience4j)     │
└───────────────┴──────────────────────┴──────────────────────┘

Progression Recommandée

1. Chapitres 00-01-02 : Base obligatoire pour tous
2. Chapitre 03 : Java moderne (indispensable)
3. Chapitre 04 : Concurrence (intermédiaire)
4. Chapitre 05 : Bases de données (indispensable)
5. Chapitres 06-07-08 : Spring (pro, microservices)

5. Comparaison avec d'Autres Langages

Quand choisir Java ?

• Applications d'entreprise (ERP, CRM, systèmes bancaires)
• Applications Android (historiquement)
• Grands systèmes distribués
• Projets nécessitant la stabilité et le support LTS
• Équipes nombreuses (le typage fort aide la maintenance)

Forces de Java en 2026

1. Maturité : 30 ans d'évolution, stabilité industrielle
2. Écosystème : Bibliothèques pour tout besoin
3. Performance : JIT, GC modernes, native-image
4. Portabilité : JVM sur toutes les plateformes
5. Emploi : Base installée massive

Faiblesses de Java

1. Verbοsité : Historiquement verbeux (amélioré depuis Java 14+)
2. Consommation mémoire : Plus élevée que Go/Rust
3. Démarrage à froid : JVM lente au démarrage (amélioré avec CDS, native-image)
4. Dette technique historique : Applet, AWT, Swing

6. Configuration de l'Environnement de Travail

6.1 Installation du JDK

# Vérifier la version actuelle
java -version
javac -version

# Télécharger Adoptium Temurin JDK 21 LTS
# https://adoptium.net/
# Installer et configurer JAVA_HOME

# Sous Windows (PowerShell)
[System.Environment]::SetEnvironmentVariable('JAVA_HOME', 'C:\Program Files\Eclipse Adoptium\jdk-21.0.1.12-hotspot', 'User')

# Sous macOS/Linux (bash/zsh)
export JAVA_HOME=/usr/lib/jvm/jdk-21
export PATH=$JAVA_HOME/bin:$PATH

6.2 Installation de Maven

# Vérifier Maven
mvn -version

# Télécharger Apache Maven 3.9.x
# https://maven.apache.org/download.cgi
# Configurer MAVEN_HOME et PATH

6.3 Installation d'IntelliJ IDEA

1. Télécharger IntelliJ IDEA Community ou Ultimate
2. Installer les plugins recommandés :
   • Lombok
   • SonarLint
   • CheckStyle-IDEA
   • JRebel (si Ultimate)
   • Docker
3. Configurer le JDK dans File → Project Structure → SDK

7. Votre Premier Projet Java

// HelloWorld.java
package com.modernjava.intro;

/**
 * Premier programme : démonstration des features Java 21
 */
public class HelloWorld {

    private static final String GREETING = "Bienvenue dans Modern Java Engineering";

    public static void main(String... args) {
        // Java 10+ : var pour l'inférence de type locale
        var message = buildMessage("Java");
        
        // Java 21+ : Pattern matching pour switch
        var detail = switch (message.length()) {
            case int i when i < 10 -> "Court message";
            case int i when i < 30 -> "Message moyen";
            default -> "Long message";
        };

        System.out.println(message);
        System.out.println("Info : " + detail);

        // Java 8+ : Stream API
        var names = java.util.List.of("Alice", "Bob", "Charlie");
        names.stream()
             .map(String::toUpperCase)
             .forEach(System.out::println);
    }

    // Java 16+ : Record
    record Info(String name, int version) {}

    private static String buildMessage(String language) {
        // Java 15+ : Text blocks
        return """
               %s %s !
               %s
               Java 21 LTS - Prêt pour l'aventure
               """.formatted(GREETING, "2026", language).stripIndent();
    }
}

Compilation et exécution

# Compilation
javac HelloWorld.java

# Exécution
java HelloWorld

# Avec Maven
mvn compile exec:java -Dexec.mainClass="com.modernjava.intro.HelloWorld"

# Avec jshell (Java 9+)
jshell HelloWorld.java

8. Ressources Essentielles

Documentation Officielle

• OpenJDK
• Java Language Specification
• Java API Documentation
• Inside Java (Oracle Blog)

Sites d'Apprentissage

• Baeldung : Tutoriels Spring et Java
• Java Magazine : Articles techniques
• Dev.java : Portail officiel d'apprentissage
• InfoQ Java : Actualités et conférences
• JetBrains Academy : Cours interactifs

Ouvrages de Référence

• "Effective Java" - Joshua Bloch (3rd edition, 2018)
• "Java Concurrency in Practice" - Brian Goetz
• "Modern Java in Action" - Raoul-Gabriel Urma
• "Spring in Action" - Craig Walls
• "Clean Code" - Robert C. Martin