Exemples Java clairs - Codez mieux, du débutant à l'expert

Un bon exemple en Java doit faire plus que “tourner” : il doit montrer la structure minimale, donner une logique lisible et rester assez simple pour être modifié sans effort. Ici, je vais aller droit au but avec des snippets progressifs, depuis le premier programme jusqu’aux cas où il faut gérer des variables, des entrées utilisateur et des erreurs courantes.

Je garde volontairement des blocs courts, mais exploitables. L’objectif est de vous laisser quelque chose que vous pouvez reprendre, adapter et faire évoluer, sans tomber dans le code décoratif qu’on lit une fois puis qu’on oublie.

Ce qu’un bon exemple Java doit montrer

Quand je sélectionne un extrait de code Java, je regarde d’abord s’il enseigne quelque chose de stable. En 2026, les bons exemples restent ceux qui se compilent vite, se lisent en une minute et montrent une habitude correcte dès la première ligne utile.

Je préfère donc un exemple un peu plus court mais honnête, plutôt qu’un bloc long qui mélange tout. Avec cette grille, le premier programme devient un point d’ancrage utile, pas un rite de passage vide. La suite logique, c’est de commencer par le classique le plus propre possible.

Commencer par un programme Hello World propre

Le premier extrait doit être limpide. Il sert à vérifier que l’environnement est prêt, que la syntaxe est correcte et que la relation entre le fichier, la classe et l’exécution est bien comprise.

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

Si vous lancez ce fichier depuis le terminal, vous obtenez le résultat en deux commandes simples :

javac HelloWorld.java
java HelloWorld

Ce snippet est utile parce qu’il montre trois choses à la fois : la déclaration d’une classe, le point d’entrée du programme et l’affichage standard. Il faut aussi retenir une règle pratique : le nom du fichier doit correspondre au nom de la classe publique. C’est un détail qui bloque encore beaucoup de débutants, alors qu’il suffit d’y faire attention une fois.

Quand ce premier exemple fonctionne, vous avez validé la base. À partir de là, on peut ajouter de la logique sans perdre la simplicité du départ.

Ajouter des variables, des conditions et des boucles

Le passage le plus utile après Hello World, c’est l’introduction d’une vraie logique. C’est souvent là que l’on comprend enfin ce que Java apporte : un typage clair, des règles explicites et un code qui devient plus prévisible quand on le structure correctement.

public class ControleAge {
    public static void main(String[] args) {
        int age = 17;

        if (age >= 18) {
            System.out.println("Accès autorisé");
        } else {
            System.out.println("Accès refusé");
        }

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

Ce type d’exemple est intéressant parce qu’il met en scène trois notions à la fois :

• les variables, pour stocker une valeur précise ;
• les conditions, pour prendre une décision ;
• les boucles, pour répéter une action de manière contrôlée.

Je vois souvent les mêmes erreurs à ce stade. La première consiste à confondre l’opérateur d’affectation = et l’opérateur de comparaison ==. La deuxième consiste à tester une chaîne avec == au lieu de equals(). La troisième, plus subtile, est de faire des boucles sans borne claire, ce qui produit un code difficile à vérifier. Quand ces trois points sont maîtrisés, on peut passer à une vraie structure objet.

Passer d’un script à une vraie classe métier

Le saut qualitatif en Java, ce n’est pas seulement “écrire plus de lignes”. C’est apprendre à regrouper le comportement et les données dans des objets simples. C’est là que le langage devient vraiment intéressant, parce qu’on quitte le programme jetable pour quelque chose de plus durable.

public class Produit {
    private final String nom;
    private final double prixHT;

    public Produit(String nom, double prixHT) {
        this.nom = nom;
        this.prixHT = prixHT;
    }

    public double prixTTC(double tva) {
        return prixHT * (1 + tva);
    }

    public String resume() {
        return nom + " : " + prixHT + " € HT";
    }
}

public class DemoProduit {
    public static void main(String[] args) {
        Produit clavier = new Produit("Clavier mécanique", 49.90);

        System.out.println(clavier.resume());
        System.out.println("Prix TTC : " + clavier.prixTTC(0.20));
    }
}

Cette version est plus utile qu’un simple calcul isolé, parce qu’elle montre la logique objet en situation réelle. Le mot-clé private protège l’état interne, le constructeur initialise proprement l’objet et les méthodes exposent seulement ce qu’il faut. C’est une habitude qui change tout dès que le projet grossit.

En pratique, je conseille d’utiliser ce type d’exemple dès qu’une donnée a plusieurs usages. Si vous n’avez qu’un calcul ponctuel, une méthode suffit. Si vous manipulez une entité comme un produit, un client ou un capteur, une classe dédiée devient bien plus lisible. Une fois cette base posée, la question suivante est presque toujours la même : comment gérer des données venant de l’extérieur sans casser le programme ?

Lire une entrée et sécuriser les erreurs

Un exemple Java devient nettement plus crédible dès qu’il accepte une entrée utilisateur. C’est souvent là qu’on voit la différence entre un code théorique et un petit outil vraiment exploitable.

import java.util.Scanner;

public class SaisieAge {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            System.out.print("Votre âge : ");
            String saisie = scanner.nextLine();

            try {
                int age = Integer.parseInt(saisie.trim());

                if (age < 0) {
                    System.out.println("L'âge ne peut pas être négatif.");
                } else {
                    System.out.println("Âge enregistré : " + age);
                }
            } catch (NumberFormatException e) {
                System.out.println("Entrez un entier valide.");
            }
        }
    }
}

Je préfère ici lire la ligne complète avec nextLine() puis convertir manuellement la valeur. Cette approche évite plusieurs surprises liées au comportement de Scanner, surtout quand on mélange plusieurs types de lecture. Le bloc try/catch n’est pas là pour faire joli : il protège le programme contre une saisie imprévue, ce qui est la norme dès qu’un humain intervient.

Le point clé, c’est de ne pas laisser croire que l’entrée sera toujours correcte. Un exemple solide doit montrer la route normale, mais aussi la sortie de secours. C’est exactement ce que recherchent les lecteurs qui veulent progresser sans apprendre de mauvaises habitudes.

Faire passer ces exemples du cahier d’exercices au vrai projet

À ce stade, il ne manque généralement pas de syntaxe, mais de méthode. Les snippets les plus utiles sont ceux que l’on peut faire évoluer sans réécrire la moitié du fichier. C’est aussi la logique que j’applique quand je veux transformer un exercice en base de projet.

Je recommande aussi de garder un niveau de complexité bas tant que l’objectif est pédagogique. Si un extrait mélange collection, fichiers, réseau et interface graphique, il devient vite illisible pour un débutant. Mieux vaut progresser par couches : d’abord une méthode, puis une classe, ensuite une collection, puis un test. C’est plus lent au début, mais beaucoup plus solide.

Les exemples qui font vraiment progresser après les bases

Si je devais choisir les trois variantes qui apportent le plus, je retiendrais la calculatrice simple, la gestion d’une liste d’objets et la lecture d’un fichier texte. Ces cas couvrent déjà une grande partie des besoins courants, sans vous faire basculer trop tôt dans une architecture trop lourde.

• Refaire HelloWorld avec un package pour apprendre l’organisation des fichiers.
• Transformer Produit en panier avec une ArrayList pour manipuler plusieurs objets.
• Ajouter une validation plus stricte sur la saisie pour mieux gérer les cas invalides.
• Écrire un test unitaire sur prixTTC() pour vérifier que le calcul reste stable.