Bonnes pratiques de nommage en Java

Les noms sont la documentation la moins coûteuse que vous écrirez jamais et la plus onéreuse à mal formuler. Java dispose d'un ensemble de conventions de nommage solides et quasi universelles — codifiées dans la Java Language Specification d'origine et renforcées par le JDK, chaque grande bibliothèque et des outils comme Checkstyle. Les suivre n'est pas une question de goût : elles permettent à tout lecteur Java de déduire ce qu'est une chose à partir de la façon dont elle est écrite, avant même de lire une seule ligne de son corps. Ce chapitre rassemble les règles de nommage qui importent et les illustre en pratique ; pour les espaces, le placement des accolades et la structure des fichiers, consultez les conventions de code Java.

Les conventions de casse en un coup d'œil

Java assigne un style de casse distinct à chaque type d'identifiant. La casse seule indique au lecteur la catégorie :

package com.w3docs.billing;          // lowercase, reverse-domain

public class InvoiceService {        // PascalCase class
  private static final int MAX_RETRY_COUNT = 3;  // UPPER_SNAKE_CASE constant
  private final TaxTable taxTable;   // camelCase field

  public BigDecimal calculateTotal(List<LineItem> lineItems) { ... } // camelCase method
}

Packages : minuscules et domaine inversé

Les noms de packages sont toujours en minuscules, sans tirets de soulignement, et commencent par un domaine que vous contrôlez, inversé — com.w3docs.billing, pas Billing ni w3docs_billing. Le préfixe à domaine inversé rend vos packages uniques au niveau mondial, afin qu'ils n'entrent jamais en collision avec une bibliothèque tierce dans le classpath. Évitez les mots-clés Java et les chiffres comme premier caractère d'un segment. Consultez la création de packages pour la structure de répertoires qu'impliquent ces noms.

package com.w3docs.billing.tax;   // good: lowercase, reverse-domain, dotted
// package Com.W3docs.Billing;    // bad: uppercase segments
// package com.w3docs.2024billing;// bad: segment starts with a digit

Les classes sont des noms, les méthodes sont des verbes

Une classe, une interface, un enum ou un record modélise une chose, donc son nom est un syntagme nominal en PascalCase : Order, PaymentGateway, OrderLine. Une méthode fait quelque chose, donc son nom est un syntagme verbal en camelCase : calculateTotal, sendInvoice, parseDate. Deux sous-conventions importantes en découlent :

• Les méthodes qui retournent un boolean se lisent comme une question : isEmpty, hasNext, canRetry.
• Les accesseurs classiques utilisent le préfixe get/set (getName, setName) — mais les records Java génèrent des accesseurs nommés d'après le champ sans préfixe (name(), pas getName()).

interface PaymentGateway {          // noun, PascalCase
  boolean isAvailable();            // boolean → question form
  Receipt charge(Money amount);     // verb phrase
}

record Customer(String name, String email) { }  // accessors: name(), email()

Constantes, variables et paramètres de type

Une constante static final dont la valeur est fixée à la compilation utilise UPPER_SNAKE_CASE pour se distinguer des variables ordinaires : MAX_RETRY_COUNT, DEFAULT_TAX_RATE. Les variables locales, les paramètres et les champs sont des noms en camelCase qui décrivent la valeur, pas son type — préférez taxRate à d ou theDouble. Les paramètres de type générique sont des lettres majuscules uniques par convention établie de longue date :

static final double DEFAULT_TAX_RATE = 0.20;        // constant
public <K, V> Map<K, V> copyOf(Map<K, V> source) { ... } // type params K, V

Éviter ces erreurs courantes

Quelques anti-patterns reviennent sans cesse. Ils compilent, mais ils compliquent la lecture :

• Noms hongrois / encodant le type — strName, iCount, lstOrders. Le type est déjà dans la déclaration ; le nom devrait décrire la signification.
• Variables locales à une seule lettre au-delà des compteurs de boucle — c, x, tmp pour une valeur métier cachent l'intention.
• Abréviations cryptiques — calcGrsTtl. Épelez les mots entièrement ; les IDE modernes font l'autocomplétion.
• l (L minuscule) et O comme noms de variables — ils sont visuellement indiscernables de 1 et 0.
• Noms de classe qui sont des verbes (ProcessData) ou noms de méthode qui sont des noms — préférez order.calculateTotal() pour quelque chose qui calcule, en réservant la forme nominale brute aux accesseurs purs.

Un exemple concret : les conventions dans un seul programme

Ce programme réunit toutes les règles ci-dessus dans un seul fichier — une constante, un record avec des accesseurs sans préfixe, une méthode de requête booléenne, une méthode en camelCase avec des paramètres descriptifs, et une liste générique. Lisez le source et la sortie ensemble pour voir comment la casse correspond à la catégorie.

Ce qu'il faut retenir de l'exécution :

• Les deux constantes UPPER_SNAKE_CASE s'affichent sous la forme max retry count : 3 et default tax rate: 0.2 — leur casse indique au site d'utilisation qu'il s'agit de valeurs fixes et partagées, et non de variables locales réassignables.
• OrderLine est un record en PascalCase, et la boucle lit ses données via productName(), quantity() et lineTotal() — notez qu'il n'y a pas de préfixe get, car les accesseurs de record sont nommés exactement d'après le composant.
• isBulk() affiche bulk=true pour la ligne de 12 unités et bulk=false pour celle d'1 unité : le préfixe is vous indiquait qu'il retournait un boolean avant même que vous lisiez son corps, et la sortie confirme que la convention porte ses fruits au site d'appel.
• calculateGrossTotal est une méthode à phrase verbale dont les paramètres orderLines et taxRate décrivent la signification, pas le type — le résultat gross total : 111.60 (93.00 net multiplié par 1.20) est exactement ce que le nom de la méthode promettait.
• La dernière ligne utilise List<String>, un générique paramétré avec un type concret, faisant écho à la convention des paramètres de type (E pour element) avec laquelle les collections JDK sont déclarées — le programme affiche [alpha, beta] pour montrer la liste typée en action.

Pratique