HOWTO · Java

Comment inspecter la classe d’exécution d’un objet en Java

Utilisez getClass(), getSimpleName() et getTypeName() pour examiner la classe d’exécution d’un objet Java, et non le type déclaré de sa variable.

Sur cette page

Utilisez getClass() pour examiner la classe d’exécution d’un objet non null, jamais le type déclaré de la variable. Appelez getSimpleName() pour le nom de la classe sans son paquetage, getName() pour le nom qualifié par le paquetage, ou getTypeName() pour un nom de type tel que java.lang.String. Utilisez instanceof lorsque vous n’avez besoin que d’un test par oui ou non plutôt que d’un nom.

Utiliser getClass().getSimpleName() pour vérifier le type d’une variable en Java

Appelez getClass() sur un objet pour obtenir son objet Class<?>, puis appelez getSimpleName() pour obtenir le nom de la classe sans les informations de paquetage. Le résultat reflète la classe d’exécution de l’objet, même lorsque la variable est déclarée comme Object.

Exécutez cet exemple :

public class RuntimeSimpleNames {
  public static void main(String[] args) {
    Object value = "Hello, Java!";
    String[] names = {"Ada", "Lin"};
    int count = 3;
    Object boxedCount = count;

    System.out.println(value.getClass().getSimpleName());
    System.out.println(names.getClass().getSimpleName());
    System.out.println(boxedCount.getClass().getSimpleName());
  }
}

Sortie:

String
String[]
Integer

Les tableaux sont des objets, donc getClass() fonctionne aussi sur eux ; une valeur de type String[] a pour nom simple String[]. Un primitif comme int n’a aucune méthode getClass() — la section sur les primitifs ci-dessous explique pourquoi, et ce que l’empaquetage (boxing) rapporte à la place.

Utiliser getClass().getName() pour vérifier le type d’une variable en Java

getName() renvoie le nom entièrement qualifié de la classe d’exécution, paquetage compris — utilisez-la lorsque le paquetage est nécessaire pour distinguer des classes portant le même nom. Pour les tableaux, en revanche, elle renvoie le nom interne de la JVM au lieu d’une syntaxe lisible : chaque [ en tête marque une dimension du tableau, et L<classe>; encode le type des composants.

Exécutez cet exemple :

public class RuntimeName {
  public static void main(String[] args) {
    Object value = "Hello, Java!";
    String[] names = {"Ada", "Lin"};

    System.out.println(value.getClass().getName());
    System.out.println(names.getClass().getName());
  }
}

Sortie:

java.lang.String
[Ljava.lang.String;

La deuxième ligne décrit un tableau à une dimension de java.lang.String. Comme cet encodage est difficile à lire, préférez getSimpleName() ou getTypeName() pour les tableaux.

Utiliser getClass().getTypeName() pour vérifier le type d’une variable en Java

getTypeName() renvoie le nom du type sous forme de String. Pour un objet String, il inclut le nom du paquetage, contrairement à getSimpleName().

Exécutez cet exemple :

public class RuntimeTypeName {
  public static void main(String[] args) {
    Object value = "Hello, Java!";
    String typeName = value.getClass().getTypeName();
    System.out.println(typeName);
  }
}

Sortie:

java.lang.String

Choisissez getSimpleName() pour le nom court, getName() pour le nom de classe qualifié par le paquetage et getTypeName() pour un nom de type lisible qui formate aussi les tableaux de façon lisible. Aucune de ces méthodes ne rapporte le type déclaré d’une variable.

Utiliser instanceof pour vérifier si un objet est une instance d’un type

L’opérateur instanceof répond à une question par oui ou non au lieu de renvoyer un nom : cet objet est-il une instance du type indiqué ou de l’un de ses sous-types ? Il suit donc toute la hiérarchie des types, alors que comparer getClass() avec == ne teste qu’une seule classe d’exécution exacte.

Exécutez cet exemple :

import java.util.ArrayList;
import java.util.List;

public class InstanceofCheck {
  public static void main(String[] args) {
    Object value = new ArrayList<String>();

    System.out.println(value instanceof ArrayList);
    System.out.println(value instanceof List);
    System.out.println(value instanceof String);
    System.out.println(value.getClass() == ArrayList.class);
    System.out.println(value.getClass() == List.class);
  }
}

Sortie:

true
true
false
true
false

L’objet est une instance à la fois de ArrayList et de l’interface List qu’elle implémente, donc les deux tests instanceof renvoient true ; la dernière comparaison renvoie false parce que la classe d’exécution exacte est ArrayList, et non List. Règle pratique : instanceof accepte les sous-types, l’égalité de getClass() n’accepte que la classe exacte.

Utiliser le filtrage par motif d’instanceof pour tester et convertir en une seule étape

Depuis Java 16, instanceof peut aussi déclarer une variable de motif du type testé. Quand le test réussit, la variable est déjà convertie pour vous, et elle ne reste en portée que là où le test est connu pour avoir réussi — la conversion séparée qu’exigeait l’ancien code disparaît.

Exécutez cet exemple :

public class InstanceofPattern {
  public static void main(String[] args) {
    Object value = "Hello, Java!";

    if (value instanceof String text) {
      System.out.println(text.toUpperCase());
    }

    Object number = 42;
    if (number instanceof String text) {
      System.out.println(text);
    } else {
      System.out.println("Not a string");
    }
  }
}

Sortie:

HELLO, JAVA!
Not a string

Le premier test lie text comme un String prêt à l’emploi. Le second échoue — le 42 empaqueté est un Integer — donc la branche else s’exécute.

Vérifier le type d’une variable qui peut être null

Une référence null ne pointe vers aucun objet, donc elle n’a pas de classe d’exécution. Appeler getClass() sur elle lève une NullPointerException. L’opérateur instanceof est le test sûr face à null : il renvoie simplement false pour null au lieu de lever une exception.

Exécutez cet exemple :

public class NullTypeCheck {
  public static void main(String[] args) {
    Object value = null;

    System.out.println(value instanceof String);

    try {
      System.out.println(value.getClass().getSimpleName());
    } catch (NullPointerException e) {
      System.out.println("getClass() failed: value is null");
    }
  }
}

Sortie:

false
getClass() failed: value is null

Protégez le code par un test explicite value == null ou par un test instanceof avant d’appeler une quelconque méthode getClass() sur une valeur qui pourrait être null.

Vérifier le type d’une valeur primitive en Java

Les valeurs primitives comme int et double sont de simples valeurs, pas des objets : elles n’ont pas de méthodes et ne portent aucune classe d’exécution. Leur type est fixé à la compilation, et à l’exécution la JVM ne travaille qu’avec la valeur brute — c’est pourquoi count.getClass() ne compile pas.

Pour en inspecter une à l’exécution, laissez-la être empaquetée dans sa classe enveloppe ; le type rapporté est alors l’enveloppe, jamais le primitif lui-même. Un littéral de classe existe tout de même pour le type primitif — int.class, le même objet que Integer.TYPE — mais il nomme le type dans l’abstrait, pas une valeur particulière.

Exécutez cet exemple :

public class PrimitiveTypeCheck {
  public static void main(String[] args) {
    int count = 3;
    double price = 9.99;

    Object boxedCount = count;
    Object boxedPrice = price;

    System.out.println(boxedCount.getClass().getSimpleName());
    System.out.println(boxedPrice.getClass().getSimpleName());
    System.out.println(int.class.getSimpleName());
    System.out.println(double.class == Double.TYPE);
  }
}

Sortie:

Integer
Double
int
true

En résumé : le type d’un primitif n’est un fait qu’à la compilation. Tant que l’empaquetage n’a pas créé d’objet, il n’y a rien à l’exécution que getClass() ou instanceof puissent inspecter.

Conclusion

Utilisez getClass().getSimpleName(), getClass().getName() ou getClass().getTypeName() lorsque vous avez besoin du nom de la classe d’exécution exacte d’un objet. Utilisez instanceof — avec une variable de motif sous Java 16 ou ultérieur lorsque vous avez aussi besoin de la conversion — lorsque n’importe quel sous-type doit réussir le test, et fiez-vous à lui pour les valeurs qui pourraient être null. Les valeurs primitives n’ont pas de type d’exécution à rapporter ; empaquetez-les d’abord et attendez-vous à la classe enveloppe, comme Integer pour un int.