Java : vue d'ensemble¶

Avant d'écrire du code, une carte du territoire : ce qu'est vraiment « Java », comment ton code s'exécute, et en quoi il diffère de Rust, C++ et Python.

Java, c'est trois choses¶

Quand on dit « Java », on parle en fait de trois éléments distincts :

Le langage

La syntaxe et les règles de typage (classes, interfaces, génériques, record...). Le compilateur javac le traduit en bytecode, pas en code machine.

La JVM (Java Virtual Machine)

Le programme qui exécute le bytecode : elle charge les classes, les vérifie, les interprète, compile à la volée les parties chaudes et gère la mémoire. D'autres langages ciblent la même JVM (Kotlin, Scala, Clojure).

La bibliothèque standard

Le JDK livre des milliers de classes : collections, E/S, réseau, HTTP, dates, concurrence, cryptographie... C'est beaucoup plus large que la std de Rust, plus proche des « piles incluses » de Python.

Le JDK (Java Development Kit) regroupe les trois, plus les outils (javac, jshell, javap, jar...). Tu l'installes au chapitre suivant.

Du fichier source à l'exécution¶

flowchart LR
    A["Calcul.java<br/>(source)"] -->|javac| B["Calcul.class<br/>(bytecode portable)"]
    subgraph JVM["JVM"]
        direction TB
        C["Chargeur de classes<br/>+ vérificateur"] --> D["Interpréteur"]
        D -->|"méthodes chaudes"| E["JIT : compilation<br/>en code machine"]
        F["GC : ramasse-miettes"]
    end
    B -->|java Calcul| JVM

Prenons un programme minuscule :

public class Calcul {
    static int carre(int x) {
        return x * x;
    }

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

javac Calcul.java produit Calcul.class. L'outil javap -c montre le bytecode de carre (commentaires ajoutés) : des instructions pour une machine à pile, indépendantes du processeur.

static int carre(int);
  Code:
     0: iload_0      // empile le 1er argument
     1: iload_0      // l'empile encore
     2: imul         // multiplie les deux sommets de pile
     3: ireturn      // renvoie le résultat

Ce même .class tourne sur Linux, macOS ou Windows, x86 ou ARM : c'est le fameux write once, run anywhere. Pas besoin de recompiler par cible comme en Rust ou en C++.

Un fichier .class commence toujours par les octets CA FE BA BE, suivis du numéro de version du format : 69 pour Java 25. Une JVM plus ancienne refuse un .class trop récent.

Java face à ce que tu connais¶

En résumé : Java a le typage statique de Rust et C++, mais le modèle mémoire de Python (tout objet est manipulé par référence et libéré automatiquement).

Ce qui va te surprendre¶

Tout est classe

Pas de fonction libre : tout code vit dans une classe (sauf dans un petit fichier « compact » de Java 25, vu au chapitre suivant). Seuls 8 types primitifs (int, double, boolean...) ne sont pas des objets. Voir Syntaxe et types.

Des références partout

Une variable de type objet contient une référence, jamais l'objet lui-même. a = b ne copie rien : les deux noms désignent le même objet. Voir Mémoire et références.

Le GC

Pas de free, pas de delete, pas de destructeur appelé à un moment précis. Pour fermer un fichier, on utilise try-with-resources, l'équivalent de with en Python.

Les exceptions

C'est le mécanisme d'erreur standard, et le compilateur t'oblige à traiter certaines d'entre elles (les checked exceptions). Voir Exceptions et Optional.

null

N'importe quelle référence peut valoir null, et le compilateur ne t'aide pas. La NullPointerException sera ta compagne de route.

Java moderne est concis

La réputation de verbosité vient du Java des années 2000. Depuis Java 8 (lambdas), 10 (var), 16 (record) et 21 (pattern matching), le code ressemble beaucoup plus à du Kotlin ou du Rust.

Compare le même programme écrit « à l'ancienne » et en Java 25 :

static final class Personne {
    private final String nom;
    private final int age;

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

    public String getNom() { return nom; }
    public int getAge() { return age; }
    // + equals(), hashCode() et toString() écrits à la main (une quinzaine de lignes)
}

// dans main :
List<String> plusDe30 = new ArrayList<String>();
for (Personne p : gens) {
    if (p.getAge() >= 30) {
        plusDe30.add(p.getNom());
    }
}

record Personne(String nom, int age) {}   // equals, hashCode, toString inclus

void main() {
    var gens = List.of(new Personne("Ada", 36), new Personne("Linus", 28));
    var plusDe30 = gens.stream()
            .filter(p -> p.age() >= 30)
            .map(Personne::nom)
            .toList();
    IO.println(plusDe30);   // affiche : [Ada]
}

Tu croiseras les deux styles : beaucoup de code existant (et de réponses sur Internet) date d'avant Java 17. Ce cours utilise le style moderne, et signale l'ancien quand il est encore courant.

Conventions de nommage¶

Java est très homogène sur ce point, et Spring s'appuie parfois sur ces noms (par exemple les getters, voir Classes et objets).

Le domaine inversé sert à garantir des noms de paquets uniques au monde : si tu possèdes dunkan.xyz, tes paquets commencent par xyz.dunkan. Le paquet correspond à un dossier (xyz/dunkan/todo/), comme un module Rust ou un paquet Python.

Plan de la partie Java¶