Structure d’un programme Java, méthode main

1. Introduction

Quand on commence à programmer, on a l’impression qu’il suffit d’écrire du code ligne après ligne et que tout fonctionnera. Mais dès que le programme devient plus complexe, la confusion s’installe : où se trouve quoi, pourquoi cela a été écrit, et si l’on doit changer une ligne — où est‑elle au juste ?

C’est pourquoi Java, comme la plupart des langages modernes, propose une façon d’« organiser » le code pour que l’on puisse à tout moment comprendre ce que fait le programme et retrouver rapidement l’endroit voulu.

Imaginez une entreprise. Il y a les ressources humaines, la comptabilité, le service informatique, la logistique, etc. Chaque service a sa zone de responsabilité, ses employés et ses tâches.

Dans un programme Java, chaque « service » est une classe. Une classe gère, par exemple, les utilisateurs, une autre — les calculs, une troisième — le travail avec les fichiers.

Voici la structure typique d’un petit projet :

• Main.java — siège principal : c’est ici que se trouve le « point d’entrée », d’où tout commence.
• User.java — service où sont stockées et traitées les données utilisateur.
• Calculator.java — service des calculs.
• FileHelper.java — spécialistes des fichiers.

Même dans un tout petit programme, il y a en général au moins une classe. Et les grands projets — c’est déjà un véritable « gratte-ciel » de centaines de classes !

2. Une classe, c’est une boîte à outils

Java est un langage orienté objet, et tout y est objet. Les types d’objets s’appellent des classes.

Une classe, c’est comme une boîte ou un casier où l’on range ce dont on a besoin : des variables, des méthodes. Imaginez une boîte étiquetée « Marteaux » : à l’intérieur, il n’y a que des outils liés aux marteaux.

class Example 
{
    // Ici se trouveront nos outils : variables et méthodes
}

Les classes contiennent généralement des variables et des fonctions. En Java, on appelle les variables d’une classe des champs, et les fonctions d’une classe — des méthodes. Mais le sens ne change pas.

Vous vous souvenez de notre premier code ?

System.out.println("Bonjour à tous !");

Dans ce code, il y a à la fois une classe et des méthodes :

• System — c’est une classe qui contient des méthodes pour travailler avec le système.
• out — c’est un champ qui est un objet de la classe PrintStream.
• println — c’est une méthode de la classe PrintStream qui affiche du texte à l’écran.

En un sens, la programmation revient à écrire ses propres classes et méthodes, qui appellent les méthodes d’autres classes.

3. Syntaxe abrégée de la méthode main()

En réalité, le programme minimal en Java ressemble à ceci :

class Program 
{
    public static void main(String[] args) 
    {
        // Votre code ici
    }
}

Il contient au minimum une classe, qui doit définir une méthode main avec l’en-tête (signature) suivant :

public static void main(String[] args)

Cependant, avec Java 21, il est possible d’écrire la méthode main() de manière abrégée. Puis le compilateur Java (à la compilation) la transformera en la bonne méthode main().

C’est pourquoi, chaque fois que vous écrivez un code de ce type :

void main() 
{
    Scanner console = new Scanner(System.in);
    int age = console.nextInt();
    System.out.println("Âge : " + age);
}

le compilateur Java le transforme en code :

class Program 
{
    public static void main(String[] args) 
    {
        Scanner console = new Scanner(System.in);
        int age = console.nextInt();
        System.out.println("Âge : " + age);
    }
}

4. Une classe Java typique

Voici à quoi ressemble une classe Java typique :

public class MathUtils 
{
    // Variables statiques (globales pour la classe)
    static final double PI = 3.14159;
    static int callCounter = 0;

    // Méthode statique : calcul de l’aire d’un cercle
    public static double circleArea(double radius) 
    {
        callCounter++;
        return PI * radius * radius;
    }

    // Méthode statique : trouver le maximum de deux nombres
    public static int max(int a, int b) 
    {
        callCounter++;
        return (a > b) ? a : b;
    }

    // Méthode statique : combien de fois les méthodes ont été appelées
    public static int getCallCount() 
    {
        return callCounter;
    }

    // Accès aux champs et méthodes depuis la méthode main() 
    public static void main(String[] args) 
    {
        System.out.println("Aire du cercle : " + circleArea(5));
        System.out.println("Maximum : " + max(10, 42));
        System.out.println("Les méthodes ont été appelées " + getCallCount() + " fois");
    }
}

Ce que l’on observe ici :

• Une classe peut avoir de nombreuses méthodes.
• Une classe peut avoir ses propres variables.
• Les méthodes d’une classe peuvent s’appeler entre elles.
• Les méthodes d’une classe peuvent accéder à des variables communes.
• Avant chaque méthode, on retrouve les mêmes « mots magiques » : public static.
• Chaque méthode a un type (différent) : int, double, void.

Nous détaillerons tous ces points ci‑dessous.

5. Les champs (variables) d’une classe — sa mémoire

À l’intérieur d’une classe, on peut stocker des variables, souvent appelées champs (fields). Ce sont comme des cellules mémoire où l’on dépose des données.

public class MathUtils 
{
    // Variables statiques (globales pour la classe)
    static final double PI = 3.14159;
    static int callCounter = 0;
}    

Les champs permettent à la classe de se souvenir de quelque chose entre différents appels de méthodes. Par exemple, compter combien de fois on a appuyé sur un bouton. Ou combien de fois une méthode a été appelée (callCounter). On peut avoir autant de champs que nécessaire.

6. Les méthodes — les actions qu’une classe peut effectuer

Les méthodes sont les « compétences » de notre classe. Si la classe est un employé, les méthodes sont ses savoir‑faire : ce qu’elle sait faire.

Par exemple, une méthode peut :

• afficher quelque chose à l’écran,
• calculer la somme de deux nombres,
• recevoir des données « en entrée » et renvoyer un résultat.

Structure d’une méthode :

1. Type de retour (par exemple, void — s’il ne renvoie rien, ou int — s’il renvoie un nombre).
2. Nom de la méthode (par exemple, circleArea).
3. Paramètres entre parenthèses (peuvent être absents).
4. Accolades { ... } — le corps de la méthode.

public class MathUtils 
{
    // Méthode statique : calcul de l’aire d’un cercle
    public static double circleArea(double radius) 
    {
        callCounter++;
        return PI * radius * radius;
    }

    // Méthode statique : trouver le maximum de deux nombres
    public static int max(int a, int b) 
    {
        callCounter++;
        return (a > b) ? a : b;
    }
}    

Vous en apprendrez davantage sur les méthodes et toutes leurs subtilités dans les prochaines leçons.

7. Modificateurs d’accès

En Java, on peut décider quelles parties d’une classe sont accessibles depuis d’autres classes, et lesquelles restent internes. Pour cela, on utilise des modificateurs d’accès.

• public — visible par tous. De telles méthodes et de tels champs peuvent être utilisés/appelés depuis n’importe où dans le programme.
• private — visible uniquement à l’intérieur de la classe elle‑même. Ce sont des détails internes qui ne doivent pas être accessibles aux autres. Comme s’ils n’existaient pas.

public class MathUtils 
{
    // Variables statiques (globales pour la classe)
    private static final double PI = 3.14159;
    private static int callCounter = 0;

    // Méthode statique : calcul de l’aire d’un cercle
    public static double circleArea(double radius) 
    {
        callCounter++;
        return PI * radius * radius;
    }
}    

Règle d’or : on met généralement les champs en private, et on « expose » seulement les méthodes nécessaires avec le modificateur public. Plus de détails sur la visibilité — dans les prochaines leçons.

8. Méthodes et variables statiques

Habituellement, en Java, une classe est utilisée comme modèle pour créer des objets. Vous écrivez votre classe, puis vous créez des objets de cette classe avec le mot‑clé new. Et ensuite seulement, vous appelez des méthodes sur ces objets.

Cependant, il existe un deuxième usage d’une classe : un conteneur de variables et méthodes globales, que l’on peut appeler depuis n’importe où dans le programme. C’est précisément à cela que sert le mot‑clé static. Il indique au compilateur Java que les méthodes et les champs sont rattachés non pas à une instance de la classe, mais à la classe elle‑même. On peut donc les appeler sans créer le moindre objet.

Vous utilisez d’ailleurs souvent de telles méthodes :

Integer.parseInt();     // Méthode statique parseInt() de la classe Integer
String.valueOf();       // Méthode statique valueOf() de la classe String 
Double.isInfinite();    // Méthode statique isInfinite() de la classe Double 
Arrays.copy();          // Méthode statique copy() de la classe Arrays 

La méthode main() est toujours déclarée statique, car l’exécution de votre programme Java commence par elle. Avant toute création d’objet.

9. Astuce dans IDEA

La signature complète de la méthode main() est la suivante :

public static void main(String[] args) 

Et pour éviter de l’écrire à chaque fois dans IntelliJ IDEA, il existe un raccourci clavier. Tapez simplement psvm puis appuyez sur Tab, et IntelliJ IDEA écrira ce code pour vous :

public static void main(String[] args) 
{
    
}

Facile à retenir — psvm — ce sont les premières lettres de public static void main.