В чем разница между каноническим именем, простым именем и именем класса в Java Class?

getName () - возвращает имя объекта (класса, интерфейса, класса массива, примитивного типа или void), представленного этим объектом Class, в виде String.

getCanonicalName () - возвращает каноническое имя базового класса, как определено в Спецификации языка Java.

getSimpleName () - возвращает простое имя базового класса, то есть имя, данное ему в исходном коде.

package com.practice;

public class ClassName {
public static void main(String[] args) {

  ClassName c = new ClassName();
  Class cls = c.getClass();

  // returns the canonical name of the underlying class if it exists
  System.out.println("Class = " + cls.getCanonicalName());    //Class = com.practice.ClassName
  System.out.println("Class = " + cls.getName());             //Class = com.practice.ClassName
  System.out.println("Class = " + cls.getSimpleName());       //Class = ClassName
  System.out.println("Class = " + Map.Entry.class.getName());             // -> Class = java.util.Map$Entry
  System.out.println("Class = " + Map.Entry.class.getCanonicalName());    // -> Class = java.util.Map.Entry
  System.out.println("Class = " + Map.Entry.class.getSimpleName());       // -> Class = Entry 
  }
}

Одно отличие состоит в том, что если вы используете анонимный класс , вы можете получить нулевое значение при попытке получить имя класса с помощью getCanonicalName()

Другой факт заключается в том, что метод getName() ведет себя иначе, чем метод getCanonicalName() для внутренних классов . getName() использует доллар в качестве разделителя между каноническим именем включающего класса и простым именем внутреннего класса.

Чтобы узнать больше о получении имени класса в Java.

Интересно отметить, что getCanonicalName() и getSimpleName() могут вызывать InternalError, когда имя класса искажено. Это происходит с некоторыми языками JVM, отличными от Java, например Scala.

Рассмотрим следующее (Scala 2.11 на Java 8):

scala> case class C()
defined class C

scala> val c = C()
c: C = C()

scala> c.getClass.getSimpleName
java.lang.InternalError: Malformed class name
  at java.lang.Class.getSimpleName(Class.java:1330)
  ... 32 elided

scala> c.getClass.getCanonicalName
java.lang.InternalError: Malformed class name
  at java.lang.Class.getSimpleName(Class.java:1330)
  at java.lang.Class.getCanonicalName(Class.java:1399)
  ... 32 elided

scala> c.getClass.getName
res2: String = C

Это может быть проблемой для смешанных языковых сред или сред, которые динамически загружают байт-код, например серверы приложений и другое программное обеспечение платформы.

    public void printReflectionClassNames(){
    StringBuffer buffer = new StringBuffer();
    Class clazz= buffer.getClass();
    System.out.println("Reflection on String Buffer Class");
    System.out.println("Name: "+clazz.getName());
    System.out.println("Simple Name: "+clazz.getSimpleName());
    System.out.println("Canonical Name: "+clazz.getCanonicalName());
    System.out.println("Type Name: "+clazz.getTypeName());
}

outputs:
Reflection on String Buffer Class
Name: java.lang.StringBuffer
Simple Name: StringBuffer
Canonical Name: java.lang.StringBuffer
Type Name: java.lang.StringBuffer

это лучший документ, который я нашел, описывающий getName (), getSimpleName (), getCanonicalName ()

https://javahowtodoit.wordpress.com/2014/09/09/java-lang-class-what-is-the-difference-between-class-getname-class-getcanonicalname-and-class- getsimplename /

// Primitive type
int.class.getName();          // -> int
int.class.getCanonicalName(); // -> int
int.class.getSimpleName();    // -> int

// Standard class
Integer.class.getName();          // -> java.lang.Integer
Integer.class.getCanonicalName(); // -> java.lang.Integer
Integer.class.getSimpleName();    // -> Integer

// Inner class
Map.Entry.class.getName();          // -> java.util.Map$Entry
Map.Entry.class.getCanonicalName(); // -> java.util.Map.Entry
Map.Entry.class.getSimpleName();    // -> Entry     

// Anonymous inner class
Class<?> anonymousInnerClass = new Cloneable() {}.getClass();
anonymousInnerClass.getName();          // -> somepackage.SomeClass$1
anonymousInnerClass.getCanonicalName(); // -> null
anonymousInnerClass.getSimpleName();    // -> // An empty string

// Array of primitives
Class<?> primitiveArrayClass = new int[0].getClass();
primitiveArrayClass.getName();          // -> [I
primitiveArrayClass.getCanonicalName(); // -> int[]
primitiveArrayClass.getSimpleName();    // -> int[]

// Array of objects
Class<?> objectArrayClass = new Integer[0].getClass();
objectArrayClass.getName();          // -> [Ljava.lang.Integer;
objectArrayClass.getCanonicalName(); // -> java.lang.Integer[]
objectArrayClass.getSimpleName();    // -> Integer[]

Меня также смутил широкий спектр различных схем именования, и я как раз собирался задать и ответить на свой вопрос по этому поводу, когда нашел здесь этот вопрос. Я думаю, что мои выводы достаточно хорошо подходят и дополняют то, что уже здесь. Я ищу документацию по различным терминам и добавляю еще несколько связанных терминов, которые могут возникнуть в других местах.

Рассмотрим следующий пример:

package a.b;
class C {
  static class D extends C {
  }
  D d;
  D[] ds;
}

• Простое имя для D - D. Это как раз та часть, которую вы написали при объявлении класса. Анонимные классы не имеют простого имени. Class.getSimpleName() возвращает это имя или пустую строку. Простое имя может содержать $, если вы напишете его так, поскольку $ является допустимой частью идентификатора в соответствии с разделом 3.8 JLS (даже если это несколько не рекомендуется) .

• Согласно разделу 6.7 JLS, и a.b.C.D, и a.b.C.D.D.D будут полностью квалифицированными именами <512>, но только <273653> каноническое имя из D. Таким образом, каждое каноническое имя является полностью определенным именем, но обратное не всегда верно. Class.getCanonicalName() вернет каноническое имя или null.

• Class.getName() задокументировано для возврата двоичного имени , как указано в разделе JLS 13.1 <3652627390229 В этом случае он возвращает a.b.C$D для D и [La.b.C$D; для D[].

• Этот ответ демонстрирует, что два класса, загруженные одним и тем же загрузчиком классов, могут иметь одинаковое каноническое имя , но разные двоичные имена . Ни одного имени недостаточно для надежного вывода другого: если у вас есть каноническое имя, вы не знаете, какие части имени являются пакетами, а какие содержат классы. Если у вас есть двоичное имя, вы не знаете, какие $ были введены как разделители, а какие были частью какого-то простого имени. (В файле класса хранится двоичное имя самого класса и его включающего его класса, что позволяет среде выполнения сделать это различие <4227390>. )

• Анонимные классы и локальные классы не имеют полных имен , но имеют двоичное имя <36527390422953>. То же самое и для классов, вложенных в такие классы. Каждый класс имеет двоичное имя.

• Запуск javap -v -private на a/b/C.class показывает, что байт-код относится к типу d как La/b/C$D;, а к типу массива ds как [La/b/C$D;. Они называются дескрипторами , и они указаны в разделе 4.3 JVMS.

• Имя класса a/b/C$D, используемое в обоих этих дескрипторах, - это то, что вы получите, заменив . на / в двоичном имени. Спецификация JVM, очевидно, называет это внутренней формой двоичного имени . Раздел 4.2.1 JVMS описывает это и заявляет, что отличие от двоичного имени объясняется историческими причинами.

• Имя файла класса в одном из типичных загрузчиков классов на основе имени файла - это то, что вы получите, если интерпретируете / во внутренней форме двоичного имени как каталог разделитель и добавьте к нему расширение имени файла .class. Он разрешен относительно пути к классам, используемого загрузчиком классов.

Добавление локальных классов, лямбда-выражений и метода toString() для завершения двух предыдущих ответов. Далее я добавляю массивы лямбд и массивы анонимных классов (хотя на практике это не имеет никакого смысла):

package com.example;

public final class TestClassNames {
    private static void showClass(Class<?> c) {
        System.out.println("getName():          " + c.getName());
        System.out.println("getCanonicalName(): " + c.getCanonicalName());
        System.out.println("getSimpleName():    " + c.getSimpleName());
        System.out.println("toString():         " + c.toString());
        System.out.println();
    }

    private static void x(Runnable r) {
        showClass(r.getClass());
        showClass(java.lang.reflect.Array.newInstance(r.getClass(), 1).getClass()); // Obtains an array class of a lambda base type.
    }

    public static class NestedClass {}

    public class InnerClass {}

    public static void main(String[] args) {
        class LocalClass {}
        showClass(void.class);
        showClass(int.class);
        showClass(String.class);
        showClass(Runnable.class);
        showClass(SomeEnum.class);
        showClass(SomeAnnotation.class);
        showClass(int[].class);
        showClass(String[].class);
        showClass(NestedClass.class);
        showClass(InnerClass.class);
        showClass(LocalClass.class);
        showClass(LocalClass[].class);
        Object anonymous = new java.io.Serializable() {};
        showClass(anonymous.getClass());
        showClass(java.lang.reflect.Array.newInstance(anonymous.getClass(), 1).getClass()); // Obtains an array class of an anonymous base type.
        x(() -> {});
    }
}

enum SomeEnum {
   BLUE, YELLOW, RED;
}

@interface SomeAnnotation {}

Это полный вывод:

getName():          void
getCanonicalName(): void
getSimpleName():    void
toString():         void

getName():          int
getCanonicalName(): int
getSimpleName():    int
toString():         int

getName():          java.lang.String
getCanonicalName(): java.lang.String
getSimpleName():    String
toString():         class java.lang.String

getName():          java.lang.Runnable
getCanonicalName(): java.lang.Runnable
getSimpleName():    Runnable
toString():         interface java.lang.Runnable

getName():          com.example.SomeEnum
getCanonicalName(): com.example.SomeEnum
getSimpleName():    SomeEnum
toString():         class com.example.SomeEnum

getName():          com.example.SomeAnnotation
getCanonicalName(): com.example.SomeAnnotation
getSimpleName():    SomeAnnotation
toString():         interface com.example.SomeAnnotation

getName():          [I
getCanonicalName(): int[]
getSimpleName():    int[]
toString():         class [I

getName():          [Ljava.lang.String;
getCanonicalName(): java.lang.String[]
getSimpleName():    String[]
toString():         class [Ljava.lang.String;

getName():          com.example.TestClassNames$NestedClass
getCanonicalName(): com.example.TestClassNames.NestedClass
getSimpleName():    NestedClass
toString():         class com.example.TestClassNames$NestedClass

getName():          com.example.TestClassNames$InnerClass
getCanonicalName(): com.example.TestClassNames.InnerClass
getSimpleName():    InnerClass
toString():         class com.example.TestClassNames$InnerClass

getName():          com.example.TestClassNames$1LocalClass
getCanonicalName(): null
getSimpleName():    LocalClass
toString():         class com.example.TestClassNames$1LocalClass

getName():          [Lcom.example.TestClassNames$1LocalClass;
getCanonicalName(): null
getSimpleName():    LocalClass[]
toString():         class [Lcom.example.TestClassNames$1LocalClass;

getName():          com.example.TestClassNames$1
getCanonicalName(): null
getSimpleName():    
toString():         class com.example.TestClassNames$1

getName():          [Lcom.example.TestClassNames$1;
getCanonicalName(): null
getSimpleName():    []
toString():         class [Lcom.example.TestClassNames$1;

getName():          com.example.TestClassNames$$Lambda$1/1175962212
getCanonicalName(): com.example.TestClassNames$$Lambda$1/1175962212
getSimpleName():    TestClassNames$$Lambda$1/1175962212
toString():         class com.example.TestClassNames$$Lambda$1/1175962212

getName():          [Lcom.example.TestClassNames$$Lambda$1;
getCanonicalName(): com.example.TestClassNames$$Lambda$1/1175962212[]
getSimpleName():    TestClassNames$$Lambda$1/1175962212[]
toString():         class [Lcom.example.TestClassNames$$Lambda$1;

Итак, вот правила. Во-первых, давайте начнем с примитивных типов и void:

1. Если объект класса представляет примитивный тип или void, все четыре метода просто возвращают его имя.

Теперь правила для метода getName():

2. Каждый класс или интерфейс, не являющийся лямбда и не массивом (т. Е. Верхний уровень, вложенный, внутренний, локальный и анонимный), имеет имя (которое возвращается с помощью getName()), которое представляет собой имя пакета, за которым следует точка (если есть пакет), за которым следует имя его класс-файла, сгенерированного компилятором (без суффикса .class). Если пакета нет, это просто имя файла класса. Если класс является внутренним, вложенным, локальным или анонимным, компилятор должен сгенерировать по крайней мере один $ в своем имени файла класса. Обратите внимание, что для анонимных классов имя класса будет заканчиваться знаком доллара, за которым следует число.
3. Имена классов лямбда, как правило, непредсказуемы, и вам все равно не нужно о них заботиться. Точно, их имя - это имя включающего класса, за которым следует $$Lambda$, за которым следует число, за которым следует косая черта, за которым следует другой номер.
4. Дескриптор класса примитивов: Z для boolean, B для byte, S для short, C для short, C для <5330581153> J для long, F для float и D для double. Для классов и интерфейсов, не являющихся массивами, дескриптор класса - L, за которым следует getName(), за которым следует ;. Для классов массивов дескриптор класса [, за которым следует дескриптор класса типа компонента (который сам может быть другим классом массива).
5. Для классов массивов метод getName() возвращает дескриптор своего класса. Это правило, похоже, не работает только для классов массивов, тип компонента которых является лямбда (что, возможно, является ошибкой), но, надеюсь, это не имеет значения в любом случае, потому что нет смысла даже в существовании классов массивов, тип компонента которых является лямбда.

Теперь метод toString():

6. Если экземпляр класса представляет интерфейс (или аннотацию, которая является особым типом интерфейса), toString() возвращает "interface " + getName(). Если это примитив, он просто возвращает getName(). Если это что-то еще (тип класса, даже если он довольно странный), он возвращает "class " + getName().

Метод getCanonicalName():

7. Для классов и интерфейсов верхнего уровня метод getCanonicalName() возвращает только то, что возвращает метод getName().
8. Метод getCanonicalName() возвращает null для анонимных или локальных классов и для их классов массивов.
9. Для внутренних и вложенных классов и интерфейсов метод getCanonicalName() возвращает то, что метод getName() заменил бы введенные компилятором знаки доллара точками.
10. Для классов массивов метод getCanonicalName() возвращает null, если каноническое имя типа компонента null. В противном случае возвращается каноническое имя типа компонента, за которым следует [].

Метод getSimpleName():

11. Для вложенных, внутренних и локальных классов верхнего уровня getSimpleName() возвращает имя класса, как написано в исходном файле.
12. Для анонимных классов getSimpleName() возвращает пустой String.
13. Для лямбда-классов getSimpleName() просто возвращает то, что getName() вернет без имени пакета. Это не имеет особого смысла и выглядит для меня как ошибка, но нет смысла вызывать getSimpleName() в лямбда-классе для начала.
14. Для классов массивов метод getSimpleName() возвращает простое имя класса компонента, за которым следует []. Это имеет забавный / странный побочный эффект: классы массивов, тип компонента которых является анонимным, имеют только [] в качестве своих простых имен.

В дополнение к наблюдениям Ника Холта я проверил несколько случаев для типа данных Array:

//primitive Array
int demo[] = new int[5];
Class<? extends int[]> clzz = demo.getClass();
System.out.println(clzz.getName());
System.out.println(clzz.getCanonicalName());
System.out.println(clzz.getSimpleName());       

System.out.println();


//Object Array
Integer demo[] = new Integer[5]; 
Class<? extends Integer[]> clzz = demo.getClass();
System.out.println(clzz.getName());
System.out.println(clzz.getCanonicalName());
System.out.println(clzz.getSimpleName());

Надпись фрагмента кода:

[I
int[]
int[]

[Ljava.lang.Integer;
java.lang.Integer[]
Integer[]