Canonical vs Simple vs Class Name en Java : Analyse complète

Introduction : Trois noms pour une classe – comment ne pas s’y perdre ?

Chaque développeur Java qui s’est un jour aventuré dans le monde de la réflexion a rencontré trois méthodes apparemment identiques : getName(), getSimpleName() et getCanonicalName(). À première vue, elles renvoient toutes le nom de la classe. Mais dès que les classes internes, les tableaux ou les classes anonymes entrent en jeu, la confusion s’installe. C’est précisément cette question qui a rassemblé des milliers de vues sur Stack Overflow, et aujourd’hui nous allons enfin comprendre la différence.

Dans cet article, nous ne nous contenterons pas d’énumérer les définitions, mais nous montrerons avec des exemples de code concrets comment ces méthodes fonctionnent. Vous apprendrez quand utiliser chacune d’elles et quels pièges vous attendent. C’est parti !

1. Concepts de base : que renvoie chaque méthode ?

Avant de plonger dans les détails, définissons ce que signifient ces termes dans le contexte de l’API Java Class.

• Simple Name (getSimpleName()) : Le nom le plus court. C’est simplement le nom de la classe sans le package. Pour les classes internes, seul le nom de la classe la plus imbriquée.
• Class Name (getName()) : Le nom complet, mais tenant compte de la structure interne de la JVM. Pour les classes ordinaires, c’est package + classe. Pour les classes internes, le séparateur $ est utilisé. Pour les tableaux, des crochets sont ajoutés.
• Canonical Name (getCanonicalName()) : Le nom « canonique », qui peut être utilisé dans le code source pour déclarer une variable. Il se rapproche au maximum de la façon dont vous écrivez le code : avec des points au lieu de dollars.

Cela semble abstrait ? Illustrons-le avec du code.

2. Exemple avec une classe ordinaire

Commençons par le plus simple : une classe ordinaire sans imbrication.

// Fichier : com/example/MyClass.javapackage com.example;

public class MyClass {    public static void main(String[] args) {        System.out.println("Simple Name : " + MyClass.class.getSimpleName());        System.out.println("Class Name : " + MyClass.class.getName());        System.out.println("Canonical Name : " + MyClass.class.getCanonicalName());    }}

Résultat :

Simple Name : MyClassClass Name : com.example.MyClassCanonical Name : com.example.MyClass

Comme vous le voyez, pour une classe ordinaire, getName() et getCanonicalName() sont absolument identiques. getSimpleName() supprime le package. Pas de magie.

3. Classes internes (imbriquées) : là où la magie commence

Imaginez maintenant que nous ayons une classe interne. C’est là que la différence clé apparaît.

package com.example;

public class OuterClass {    public static class InnerClass {        public void printNames() {            System.out.println("Simple : " + getClass().getSimpleName());            System.out.println("Class : " + getClass().getName());            System.out.println("Canonical : " + getClass().getCanonicalName());        }    }

    public static void main(String[] args) {        InnerClass inner = new InnerClass();        inner.printNames();    }}

Résultat :

Simple : InnerClassClass : com.example.OuterClass$InnerClassCanonical : com.example.OuterClass.InnerClass

Le voilà ! La différence devient évidente :

• getSimpleName() a renvoyé simplement InnerClass.
• getName() utilise le symbole $ pour séparer la classe parente et la classe interne. C’est la représentation interne de la JVM.
• getCanonicalName() utilise un point – comme vous l’écririez dans le code : OuterClass.InnerClass.

C’est précisément à cause de ce symbole $ que de nombreux débutants rencontrent des bugs en essayant de charger une classe via <