Formateur Java

Formatez votre code Java selon les conventions standard.

Java Source

Formatage

Options

Java Formaté

Guide complet : Formatage et conventions Java professionnelles

L'importance du formatage dans l'écosystème Java

Java est historiquement l'un des langages les plus stricts en matière de conventions de code. Depuis les "Code Conventions for the Java Programming Language" publiées par Sun Microsystems en 1997, puis le "Google Java Style Guide" devenu la référence moderne, la communauté Java a toujours valorisé la cohérence et la lisibilité du code.

Après des années à travailler sur des projets Java d'entreprise, j'ai constaté que les équipes qui appliquent rigoureusement ces conventions ont des revues de code plus rapides, moins de bugs, et une meilleure intégration des nouveaux développeurs. Le formatage n'est pas une question esthétique — c'est un investissement dans la maintenabilité à long terme.

Les deux standards de référence

  • Oracle Code Conventions : Le standard historique (anciennement Sun). Indentation 4 espaces, ligne max 80 caractères. Très répandu dans les entreprises traditionnelles et les projets legacy.
  • Google Java Style : Plus moderne, adopté par de nombreuses startups et projets open source. Indentation 2 espaces, ligne max 100 caractères, règles plus détaillées.

Les deux sont parfaitement valides. L'essentiel est de choisir un standard et de l'appliquer à 100% du projet.

Règles de formatage essentielles

📏 Indentation 4 espaces

Standard Oracle classique. Chaque niveau de bloc (classe, méthode, if, for...) ajoute 4 espaces. Google utilise 2 espaces. Jamais de tabulations pour éviter les incohérences.

🏛️ Accolades égyptiennes (K&R)

public class Foo { — L'accolade ouvrante sur la même ligne que la déclaration. L'accolade fermante seule sur sa ligne, alignée avec le début du bloc.

📐 Longueur de ligne

Maximum 100-120 caractères (80 pour Oracle strict). Coupez après les opérateurs, avant les points, ou après les parenthèses ouvrantes.

↔️ Espacement cohérent

Espaces autour des opérateurs binaires (a + b), après les virgules, après les mots-clés (if (), pas avant les parenthèses de méthode (method()).

Conventions de nommage Java

  • Classes et interfaces : PascalCase (UserService, Comparable)
  • Méthodes et variables : camelCase (getUserById, firstName)
  • Constantes : SCREAMING_SNAKE_CASE (MAX_SIZE, DEFAULT_TIMEOUT)
  • Packages : tout en minuscules, domaine inversé (com.example.myapp)
  • Génériques : Lettres majuscules simples (T, E, K, V)

Organisation des fichiers Java

  • Ordre des sections : Package → Imports → Classe/Interface
  • Ordre des imports : Imports statiques d'abord, puis par groupe (java.*, javax.*, org.*, com.*), ordre alphabétique dans chaque groupe
  • Pas de wildcards : import java.util.List; pas import java.util.*;
  • Ordre des membres : Champs → Constructeurs → Méthodes (publiques puis privées)

Traitement local : confidentialité assurée

Ce formateur utilise js-beautify pour embellir votre code Java directement dans votre navigateur. Aucune donnée n'est envoyée à un serveur. Vous pouvez formater du code propriétaire ou sensible en toute confiance.

Questions fréquentes sur le formatage Java

Tabs ou espaces : quel est le standard en Java ?

Espaces, sans hésitation. Les deux standards majeurs (Oracle et Google) spécifient explicitement des espaces.

  • Oracle : 4 espaces par niveau d'indentation
  • Google : 2 espaces par niveau

Pourquoi pas les tabs ?

  • Affichage incohérent selon l'éditeur (tab = 2, 4 ou 8 espaces)
  • Problèmes d'alignement quand on mélange tabs et espaces
  • Diffs Git pollués par des changements invisibles

Conseil : Configurez votre IDE pour insérer des espaces quand vous appuyez sur Tab.

Google Style ou Oracle Style : lequel choisir ?

Principales différences :

  • Indentation : Google = 2 espaces, Oracle = 4 espaces
  • Largeur de ligne : Google = 100 caractères, Oracle = 80
  • Ordre des imports : Règles légèrement différentes

Recommandations :

  • Projet d'entreprise existant → Suivez le style déjà en place
  • Nouveau projet → Google Style (plus moderne, meilleur outillage)
  • Projet open source → Vérifiez les guidelines du projet

L'important n'est pas quel style, mais que tout le monde utilise le même.

Comment gérer les longues signatures de méthode ?

Stratégies de coupure :

  • Coupez après la parenthèse ouvrante, un paramètre par ligne, alignés
  • Ou indentez de 8 espaces (double indentation) les paramètres
  • L'accolade ouvrante reste sur la ligne de la parenthèse fermante

Signal d'alerte : Si une signature dépasse 3-4 lignes, c'est un "code smell". Considérez :

  • Créer un objet paramètre (Pattern Builder)
  • Décomposer la méthode en plusieurs
  • Utiliser des valeurs par défaut (Java 8+ avec Optional ou surcharge)

Où placer les annotations Java ?

Annotations de classe/méthode :

  • Chaque annotation sur sa propre ligne
  • Avant les modificateurs (public, static...)
  • Ordre : annotations de framework (@Service), puis @Override, puis @Deprecated

Annotations de paramètre :

  • Sur la même ligne que le paramètre : void save(@NotNull User user)

Annotations de champ :

  • Sur ligne séparée pour les annotations longues (@Column, @OneToMany)
  • Inline pour les annotations courtes (@NotNull)

Comment automatiser le formatage dans un projet Java ?

Outils recommandés :

  • google-java-format : Formateur officiel Google, intégrable dans Maven/Gradle
  • Spotless : Plugin Maven/Gradle multi-format (Java, Kotlin, etc.)
  • Checkstyle : Vérification du style sans modification automatique

Intégration CI/CD :

  • Ajoutez mvn spotless:check ou gradle spotlessCheck au pipeline
  • Rejetez les PRs avec du code mal formaté

IDE : Configurez IntelliJ/Eclipse avec le même profil de formatage et activez "Format on Save".

Quelles sont les règles pour les imports en Java ?

Règles fondamentales :

  • Pas de wildcards : import java.util.List; pas import java.util.*;
  • Pas d'imports inutilisés : Supprimez-les (votre IDE peut le faire automatiquement)
  • Pas d'imports statiques excessifs : Limités aux constantes et méthodes très utilisées

Ordre (Google Style) :

  1. Imports statiques (groupés, alphabétiques)
  2. Ligne vide
  3. Imports non-statiques (groupés par domaine, alphabétiques)

Mon code Java est-il sécurisé avec cet outil ?

Oui, totalement. Le formatage s'exécute entièrement dans votre navigateur :

  • js-beautify fonctionne localement en JavaScript
  • Aucune requête réseau n'envoie votre code
  • Votre code Java ne quitte jamais votre machine
  • L'outil fonctionne même hors ligne après chargement

Vérifiez dans l'onglet Network des DevTools : aucune donnée n'est transmise. Formatez votre code propriétaire en toute confiance.