[java] Java 클래스에서 표준 이름, 단순 이름 및 클래스 이름의 차이점은 무엇입니까?

로컬 클래스, 람다 및 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 클래스 이름은 일반적으로 예측할 수 없으므로 어쨌든 신경 쓰지 않아야합니다. 정확하게 그들의 이름은 다음에 오는 클래스의 이름입니다.$$Lambda$ , 뒤에, 숫자, 슬래시, 다른 숫자가옵니다.
4. 프리미티브의 클래스 기술자는 Z위해 boolean, B위해 byte, S위해 short, C위해 char, I위해 int, 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()경우이 메소드는 구성 요소 클래스의 단순 이름과 그 뒤에 오는 이름을 리턴합니다 []. 이것은 구성 요소 유형이 익명 클래스 인 배열 클래스가 []단순한 이름과 같은 재미있는 부작용을 가지고 있습니다.

답변

//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[]

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

// 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[]

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