1.1.2 – JDK, JRE, javac et java

Quatre noms reviennent souvent. Ne les mélangez pas. Pour écrire et compiler du code, vous avez besoin du JDK. Pour seulement lancer un programme déjà compilé, le JRE suffit.

javac App.java
java App

1.1.3 – Classe, méthode main, fichier source

En Java, tout votre code se trouve dans une classe. Pour lancer un programme, la JVM cherche une méthode bien précise : main. C’est le point d’entrée.

Une classe public doit être dans un fichier du même nom. Par exemple, la classe App se place dans le fichier App.java. Par convention, le nom d’une classe commence par une majuscule (PascalCase) : App, Livre, UserService. Voyons un programme minimal.

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

1.1.4 – package et import

Dès que le projet grandit, une seule classe ne suffit plus. Java range les classes dans des package — tout simplement des dossiers. La première ligne du fichier déclare le package. Le nom du package doit correspondre au chemin des dossiers : le package app.model se place dans le dossier app/model/. Par convention, un nom de package s’écrit en minuscules : app, app.model — pas App.Model.

Pour utiliser une classe qui se trouve dans un autre package, vous avez deux possibilités. Vous pouvez écrire le nom complet à chaque fois. Ou bien vous ajoutez un import, puis vous utilisez le nom court. En pratique, l’import est plus lisible.

java.util.Scanner in = new java.util.Scanner(System.in); // sans import

Import d’une classe

package app;

import java.util.Scanner;

public class App {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println(in.nextLine());
        in.close();
    }
}

Quand vous compilez et lancez le programme, vous devez tenir compte du package :

javac app/App.java
java app.App

Import avec *

Vous n’avez pas envie d’écrire chaque classe une par une ? L’écriture import java.util.* importe toutes les classes du package java.util, par exemple Scanner, Random ou Date.

import java.util.*;

public class App {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Random r = new Random();
        System.out.println(in.nextLine() + " " + r.nextInt(10));
        in.close();
    }
}

1.2.1 – Types primitifs

Java propose huit types primitifs. En pratique, vous utiliserez surtout int, double, boolean et char.

Avez-vous remarqué la colonne « valeur par défaut » ? Elle concerne les attributs d’une classe (voir 1.2.9). Une variable locale n’a pas de valeur par défaut : vous devez l’initialiser vous-même.

1.2.2 – Variables

Une variable associe un nom à une valeur d’un certain type. Pour la déclarer, vous écrivez le type, puis le nom, puis éventuellement une valeur initiale. Choisissez un nom clair : il doit décrire ce que contient la variable.

int annee = 2026;
double prix = 12.5;
boolean dispo = true;
String titre = "Dune";

Nommage

Un nom de variable peut contenir des lettres, des chiffres, _ et $. Il ne doit pas commencer par un chiffre. Java distingue les majuscules et les minuscules : annee et Annee sont deux variables différentes. Par convention, vous écrivez les variables et les méthodes en camelCase : nbLivres, titreDuLivre, afficherTitre.

int nbLivres = 3;     // OK
int 2titres = 3;      // ❌ interdit : commence par un chiffre
int titre-livre = 1;  // ❌ interdit : tiret

Mots-clés à éviter

Un nom de variable ne peut pas être un mot réservé du langage. Des mots comme class, new ou int sont déjà pris par Java.

int class = 1;    // ❌ interdit
int new = 2;      // ❌ interdit
int classe = 1;   // OK : ce n’est pas le mot-clé class

1.2.3 – Conversions et cast

Un int tient facilement dans un double : Java fait la conversion tout seul. On parle d’élargissement. L’inverse est plus délicat : vous pouvez perdre de l’information. Dans ce cas, vous devez écrire un cast explicite.

int n = 10;
double d = n;          // OK : 10.0

double x = 3.9;
int k = (int) x;       // 3 : la partie décimale est perdue

int grand = 300;
byte b = (byte) grand; // débordement possible : résultat trompeur

1.2.4 – Références et null

Tout ce qui n’est pas un type primitif est un objet. Imaginez une fiche de bibliothèque : la fiche n’est pas le livre, elle indique où le trouver. Une variable objet fonctionne de la même façon : elle contient une référence (une adresse en mémoire), pas l’objet lui-même.

String a = "Java";   // a référence un objet String
String b = a;        // b référence le même objet
a = null;            // a ne référence plus rien ; l’objet peut rester atteint via b

Comme vous pouvez le voir sur le schéma, plusieurs variables peuvent pointer vers le même objet. null signifie « aucune référence ». Si vous utilisez une variable qui vaut null, Java lève une NullPointerException.

1.2.5 – Autoboxing (int / Integer)

Chaque type primitif a une version objet : int devient Integer, double devient Double, et ainsi de suite. Java convertit automatiquement dans les deux sens. On parle d’autoboxing (primitif → objet) et d’unboxing (objet → primitif).

Pourquoi est-ce utile ? Parce que les collections n’acceptent que des objets. Vous écrivez donc List<Integer>, et non List<int>.

Integer n = 3;     // autoboxing : int → Integer
int x = n;         // unboxing  : Integer → int

1.2.6 – String : immuabilité, == et equals

String est une classe. Une variable de type String est donc une référence. De plus, les chaînes sont immuables : vous ne modifiez pas une chaîne existante, vous en créez une nouvelle.

Sur un primitif, == compare la valeur. Sur un objet, == compare les références : est-ce le même objet en mémoire ? Pour comparer le contenu de deux chaînes, vous utilisez equals.

int a = 5, b = 5;
System.out.println(a == b);       // true : même valeur

String u = "Java";
String v = "Java";
String w = new String("Java");

System.out.println(u == v);       // souvent true (pool de littéraux) — ne pas s’y fier
System.out.println(u == w);       // false : deux objets
System.out.println(u.equals(w));  // true  : même contenu

String s = null;
System.out.println("Java".equals(s)); // false, sans exception
// s.equals("Java");                  // ❌ NullPointerException

1.2.7 – String vers un nombre

Quand l’utilisateur tape au clavier, ou quand vous passez un argument en ligne de commande, vous récupérez souvent un String — du texte, pas un nombre.

Or vous ne pouvez pas calculer directement avec du texte. Il faut d’abord le convertir. Java fournit pour cela des méthodes toutes faites :

int n = Integer.parseInt("42");
double p = Double.parseDouble("3.14");
long g = Long.parseLong("8000000000");

Comme vous pouvez le voir, parseInt donne un int, parseDouble un double, et parseLong un long.

1.2.8 – enum : un type à valeurs fixes

Parfois, une valeur ne peut prendre que quelques possibilités bien définies : par exemple roman, BD ou essai. Un enum vous permet de nommer ces constantes. Ce n’est pas un simple entier : c’est un type à part entière.

Par convention, le nom de l’enum s’écrit en PascalCase (Genre, comme une classe), et chaque constante en MAJUSCULES : ROMAN, BD, ESSAI.

enum Genre {
    ROMAN, BD, ESSAI
}

Genre g = Genre.ROMAN;

switch (g) {
    case ROMAN -> System.out.println("Récit");
    case BD    -> System.out.println("Bande dessinée");
    case ESSAI -> System.out.println("Essai");
}

for (Genre x : Genre.values()) {
    System.out.println(x);
}

1.2.9 – final, portée, valeurs par défaut

Le mot-clé final

Le mot-clé final s’applique à une variable pour dire : « cette variable ne pourra recevoir qu’une seule valeur ». Une fois cette valeur fixée, vous ne pouvez plus la changer.

La façon la plus simple consiste à donner la valeur dès la déclaration. Pour une constante nommée « une fois pour toutes », on écrit souvent le nom en MAJUSCULES_AVEC_UNDERSCORES : MAX_LIVRES, TAUX_TVA.

final int MAX_LIVRES = 10;
// MAX_LIVRES = 11; // ❌ interdit : la valeur est déjà fixée

Vous pouvez aussi déclarer une variable final sans l’initialiser tout de suite. Java accepte alors une première affectation plus loin dans le code. Après cette première écriture, toute nouvelle affectation est refusée.

final int annee;          // pas encore de valeur

if (choix == 1) {
    annee = 2026;         // première (et seule) affectation autorisée
} else {
    annee = 2025;         // première affectation dans l’autre branche
}

// annee = 2030;          // ❌ interdit : annee a déjà reçu sa valeur
System.out.println(annee);

Portée d’une variable locale

La portée d’une variable locale s’arrête à la fin du bloc { } où vous l’avez déclarée. En dehors de ce bloc, la variable n’existe plus.

if (true) {
    int x = 1;     // x n’existe que dans ce if
}
// System.out.println(x); // ❌ erreur : x hors de portée

Valeurs par défaut

Dernière distinction, essentielle. Un attribut de classe reçoit automatiquement une valeur par défaut. Une variable locale n’en a pas : le compilateur refuse de la lire tant que vous ne l’avez pas initialisée.

public class Demo {
    int n;          // 0
    boolean ok;     // false
    double d;       // 0.0
    String s;       // null

    void m() {
        int x;      // pas de valeur par défaut
        // System.out.println(x); // ❌ le compilateur refuse
        x = 1;
        System.out.println(x);
    }
}

1.3.1 – Opérateurs

Les opérateurs s’appliquent aux variables vues en 1.2.2. Deux pièges reviennent souvent : la division entre entiers, et la différence entre n++ et ++n.

int n = 5;
n += 2;          // 7
n++;             // 8  (post-incrément : utilise n puis ajoute 1)
++n;             // 9  (pré-incrément  : ajoute 1 puis utilise n)

int a = 3;
int b = a++;     // b = 3, puis a = 4
int c = ++a;     // a = 5, puis c = 5

Type du résultat

Quand vous mélangez des types dans une opération, Java ne « invente » pas un type au hasard. Le type du résultat correspond toujours au type le plus large parmi les opérandes.

Du plus étroit au plus large, retenez cette échelle :

byte  <  short  <  int  <  long  <  float  <  double  <  String

En pratique :

• byte et int → résultat en int
• int et long → résultat en long
• long et double → résultat en double
• un nombre et un String avec + → résultat en String (concaténation)

byte b = 2;
int n = 10;
// byte r = b + n;   // ❌ le résultat est un int, pas un byte
int r = b + n;       // OK : 12

int i = 5;
long L = 2L;
long s = i + L;      // OK : le résultat est un long

System.out.println(3 + " livres"); // "3 livres" : String

L’opérateur ternaire remplace un if / else qui choisit une valeur. Pratique, non ?

String statut = (annee >= 2000) ? "récent" : "ancien";

Exercice de réflexion

Avant de continuer, testez-vous. Sans exécuter le programme, essayez de trouver les valeurs finales. Souvenez-vous : * a priorité sur + et -, et ++a / --d se font avant d’utiliser la valeur, alors que c-- utilise d’abord la valeur, puis décrémente.

int a = 1, b = 2, c = 3, d = 4;
int x = ++a - ++b * c-- + --d;

1.3.2 – Affichage : print, println et printf

Pour afficher du texte à l’écran, Java vous propose trois méthodes courantes sur System.out.

System.out.println affiche un texte, puis passe à la ligne suivante. System.out.print affiche sans passer à la ligne. C’est utile pour une invite de saisie : le curseur reste juste à côté du message.

System.out.print("Titre : ");     // curseur reste sur la même ligne
System.out.println("Dune");       // affiche puis nouvelle ligne
System.out.println(2026);         // accepte aussi les primitifs
System.out.println("Dune" + " (" + 1965 + ")"); // message composé

Et si vous voulez formater proprement un message avec des variables ? Utilisez System.out.printf. Vous écrivez un modèle (une chaîne avec des emplacements), puis vous passez les valeurs à insérer.

String titre = "Dune";
int annee = 1965;
double prix = 12.5;

System.out.printf("Titre : %s%n", titre);
System.out.printf("Année : %d%n", annee);
System.out.printf("Prix : %.2f €%n", prix);
System.out.printf("%s (%d) coûte %.2f €%n", titre, annee, prix);
System.out.println(titre + " (" + annee + ") coûte " + prix + " €");

1.3.3 – if et switch

Quand vous devez tester une condition, vous utilisez un if. Quand vous devez choisir parmi quelques cas précis (int, String ou enum), un switch est souvent plus lisible.

if (annee >= 2000) {
    System.out.println("XXIe siècle");
} else if (annee >= 1900) {
    System.out.println("XXe siècle");
} else {
    System.out.println("Avant 1900");
}

Avec un switch « classique », chaque case se termine en général par break. Sans break, l’exécution continuerait dans le cas suivant (c’est le fall-through).

int choix = 2;
switch (choix) {
    case 1:
        System.out.println("Ajouter");
        break;
    case 2:
        System.out.println("Lister");
        break;
    case 3:
        System.out.println("Quitter");
        break;
    default:
        System.out.println("Inconnu");
        break;
}

Depuis Java récent, vous pouvez aussi écrire une forme plus courte avec des flèches ->. Dans ce cas, vous n’avez pas besoin de break :

switch (choix) {
    case 1 -> System.out.println("Ajouter");
    case 2 -> System.out.println("Lister");
    case 3 -> System.out.println("Quitter");
    default -> System.out.println("Inconnu");
}

1.3.4 – for, while, do-while, break, continue

Si vous connaissez à l’avance le nombre de tours, utilisez un for. Si le nombre de tours dépend d’une condition, utilisez un while : le test se fait avant chaque tour. Si vous devez exécuter le corps de la boucle au moins une fois, utilisez un do-while : le test se fait après le premier tour.

for (int i = 0; i < 3; i++) {
    System.out.println(i);
}

int n = 3;
while (n > 0) {                    // 0, 1 ou plusieurs tours
    System.out.println(n);
    n--;
}

int x = 0;
do {                               // au moins un tour
    System.out.println(x);
    x++;
} while (x < 3);

for (int i = 0; i < 10; i++) {
    if (i == 2) continue;          // saute la suite de ce tour
    if (i == 5) break;             // sort de la boucle
    System.out.println(i);         // 0 1 3 4
}

Exercice de réflexion

Maintenant que vous avez vu continue et break, testez votre lecture d’un programme un peu plus riche. Sans l’exécuter, essayez de prévoir exactement ce qui s’affiche à l’écran. Vous devez suivre à la fois la boucle, le test pair/impair et l’accumulation de total.

int total = 0;
for (int i = 1; i <= 8; i++) {
    if (i % 2 == 0) {
        continue;
    }
    total = total + i;
    System.out.println("i=" + i + " total=" + total);
    if (total >= 9) {
        break;
    }
}
System.out.println("fin total=" + total);

i=1 total=1
i=3 total=4
i=5 total=9
fin total=9

1.3.5 – Tableaux (1D et 2D)

Un tableau a une taille fixe, choisie au moment de sa création. Les index commencent à 0. La propriété length vous donne le nombre d’éléments.

Pour déclarer un tableau, vous avez deux écritures possibles. La plus courante place les crochets [] juste après le type, donc avant le nom de la variable : int[] tab. Java accepte aussi l’écriture int tab[], avec les crochets après le nom. Les deux formes créent le même type de variable.

int[] notes = new int[3];   // forme recommandée : [] avant le nom
int notes2[] = new int[3];  // forme aussi acceptée : [] après le nom

notes[0] = 12;
notes[1] = 15;
notes[2] = 9;

String[] titres = {"Dune", "1984", "Névrose"};

for (int i = 0; i < titres.length; i++) {
    System.out.println(i + " : " + titres[i]);
}

// Parcours sans index (foreach) : chaque élément du tableau, un par un
for (String t : titres) {
    System.out.println(t);
}

int[][] grille = {
    {1, 2, 3},
    {4, 5, 6}
};
for (int i = 0; i < grille.length; i++) {
    for (int j = 0; j < grille[i].length; j++) {
        System.out.print(grille[i][j] + " ");
    }
    System.out.println();
}

// Même parcours avec foreach
for (int[] ligne : grille) {
    for (int valeur : ligne) {
        System.out.print(valeur + " ");
    }
    System.out.println();
}

1.3.6 – Saisie console (Scanner)

Pour lire ce que l’utilisateur tape au clavier, Java fournit la classe Scanner, branchée sur System.in. Vous utilisez nextLine() pour lire du texte, nextInt() pour un entier, et nextDouble() pour un nombre décimal.

import java.util.Scanner;

public class App {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        System.out.print("Titre : ");
        String titre = in.nextLine();

        System.out.print("Année : ");
        int annee = in.nextInt();
        in.nextLine(); // consomme le retour à la ligne restant

        System.out.println(titre + " (" + annee + ")");
        in.close();
    }
}

Exemple filé

Mettons tout cela bout à bout : un petit catalogue de titres, lus au clavier puis affichés.

import java.util.Scanner;

public class App {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] titres = new String[3];

        for (int i = 0; i < titres.length; i++) {
            System.out.print("Titre " + (i + 1) + " : ");
            titres[i] = in.nextLine();
        }

        System.out.println("--- Catalogue ---");
        for (String t : titres) {
            System.out.println("- " + t);
        }
        in.close();
    }
}

Exercice de réflexion

import java.util.Scanner;

public class App {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n;

        do {
            System.out.print("Taille du tableau : ");
            n = in.nextInt();
        } while (n <= 0);
        in.nextLine(); // consomme le retour à la ligne restant

        String[] titres = new String[n];
        for (int i = 0; i < titres.length; i++) {
            System.out.print("Titre " + (i + 1) + " : ");
            titres[i] = in.nextLine();
        }

        System.out.println("--- Catalogue ---");
        for (String t : titres) {
            System.out.println("- " + t);
        }
        in.close();
    }
}

1.3.7 – Arguments de la ligne de commande

Vous vous souvenez de String[] args dans la méthode main ? C’est un tableau de String : le même type que String[] titres vu en 1.3.5.

La JVM remplit args avec ce que vous écrivez après le nom de la classe au lancement. Chaque mot séparé par un espace devient un élément du tableau.

Par exemple, si vous lancez :

java App Dune 1965

alors :

• args.length vaut 2 ;
• args[0] vaut "Dune" ;
• args[1] vaut "1965" (toujours du texte, même si ça ressemble à un nombre).

public class App {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Aucun argument");
            return;
        }
        for (String a : args) {
            System.out.println(a);
        }
        int n = Integer.parseInt(args[0]);
        System.out.println(n * 2);
    }
}

java App Dune 1965
java App 21

1.3.8 – Commentaires et Javadoc

Java propose trois formes de commentaires. Les deux premières servent à expliquer le code pour vous-même. La troisième, appelée Javadoc, documente une méthode pour les personnes qui liront le code plus tard — y compris vous dans six mois.

// commentaire de ligne

/*
 * commentaire
 * sur plusieurs lignes
 */

/**
 * Affiche le titre d’un livre.
 * @param titre le titre à afficher
 */
public static void afficher(String titre) {
    System.out.println(titre);
}