1. Overview
In this tutorial, we’ll learn about four ways to retrieve a class’s name from methods on the Class API: getSimpleName(), getName(), getTypeName() and getCanonicalName().
These methods can be confusing because of their similar names and their somewhat vague Javadocs. They also have some nuances when it comes to primitive types, object types, inner or anonymous classes, and arrays.
2. Retrieving Simple Name
Let’s begin with the getSimpleName() method.
In Java, there are two kinds of names: simple and qualified. A simple name consists of a unique identifier while a qualified name is a sequence of simple names separated by dots.
As its name suggests, getSimpleName() returns the simple name of the underlying class, that is the name it has been given in the source code.
Let’s imagine the following class:
package com.baeldung.className;
public class RetrieveClassName {}
Its simple name would be RetrieveClassName:
assertEquals("RetrieveClassName", RetrieveClassName.class.getSimpleName());
We can also get primitive types and arrays simple names. For primitive types that will simply be their names, like int, boolean or float.
And for arrays, the method will return the simple name of the type of the array followed by a pair opening and closing brackets for each dimension of the array ([]):
RetrieveClassName[] names = new RetrieveClassName[];
assertEquals("RetrieveClassName[]", names.getClass().getSimpleName());
Consequently, for a bidimensional String array, calling getSimpleName() on its class will return String[][].
Finally, there is the specific case of anonymous classes. Calling getSimpleName() on an anonymous class will return an empty string.
3. Retrieving Other Names
Now it’s time to have a look at how we would obtain a class’s name, type name, or canonical name. Unlike getSimpleName(), these names aim to give more information about the class.
The getCanonicalName() method always returns the canonical name as defined in the Java Language Specification.
As for the other methods, the output can differ a little bit according to the use cases. We’ll see what that means for different primitive and object types.
3.1. Primitive Types
Let’s start with primitive types, as they are simple. For primitive types, all three methods getName(), getTypeName() and getCanonicalName() will return the same result as getSimpleName():
assertEquals("int", int.class.getName());
assertEquals("int", int.class.getTypeName());
assertEquals("int", int.class.getCanonicalName());
3.2. Object Types
We’ll now see how these methods work with object types. Their behavior is generally the same: they all return the canonical name of the class.
In most cases, this is a qualified name which contains all the class packages simple names as well as the class simple name:
assertEquals("com.baeldung.className.RetrieveClassName", RetrieveClassName.class.getName());
assertEquals("com.baeldung.className.RetrieveClassName", RetrieveClassName.class.getTypeName());
assertEquals("com.baeldung.className.RetrieveClassName", RetrieveClassName.class.getCanonicalName());
3.3. Inner Classes
What we’ve seen in the previous section is the general behavior of these method calls, but there are a few exceptions.
Inner classes are one of them. The getName() and getTypeName() methods behave differently than the getCanonicalName() method for inner classes.
getCanonicalName() still returns the canonical name of the class, that is the enclosing class canonical name plus the inner class simple name separated by a dot.
On the other hand, the getName() and getTypeName() methods return pretty much the same but use a dollar as the separator between the enclosing class canonical name and the inner class simple name.
Let’s imagine an inner class InnerClass of our RetrieveClassName:
public class RetrieveClassName {
public class InnerClass {}
}
Then each call denotes the inner class in a slightly different way:
assertEquals("com.baeldung.RetrieveClassName.InnerClass",
RetrieveClassName.InnerClass.class.getCanonicalName());
assertEquals("com.baeldung.RetrieveClassName$InnerClass",
RetrieveClassName.InnerClass.class.getName());
assertEquals("com.baeldung.RetrieveClassName$InnerClass",
RetrieveClassName.InnerClass.class.getTypeName());
3.4. Anonymous Classes
Anonymous classes are another exception.
As we’ve already seen they have no simple name, but they also don’t have a canonical name. Therefore, getCanonicalName() doesn’t return anything. In opposition to getSimpleName(), getCanonicalName() will return null and not an empty string when called on an anonymous class.
As for getName() and getTypeName() they will return the calling class canonical name followed by a dollar and a number representing the position of the anonymous class among all anonymous classes created in the calling class.
Let’s illustrate this with an example. We’ll create here two anonymous classes and call getName() on the first and getTypeName() on the second, declaring them in com.baeldung.Main:
assertEquals("com.baeldung.Main$1", new RetrieveClassName() {}.getClass().getName());
assertEquals("com.baeldung.Main$2", new RetrieveClassName() {}.getClass().getTypeName());
We should note that the second call returns a name with an increased number at its end, as it’s applied on the second anonymous class.
3.5. Arrays
Finally, let’s see how arrays are handled by the above three methods.
To indicate we’re dealing with arrays, each method will update its standard result. The getTypeName() and getCanonicalName() methods will append pairs of brackets to their result.
Let’s see the following example where we call getTypeName() and getCanonicalName() on a bidimensional InnerClass array:
assertEquals("com.baeldung.RetrieveClassName$InnerClass[][]",
RetrieveClassName.InnerClass[][].class.getTypeName());
assertEquals("com.baeldung.RetrieveClassName.InnerClass[][]",
RetrieveClassName.InnerClass[][].class.getCanonicalName());
Note how the first call uses a dollar instead of a dot to separate the inner class part from the rest of the name.
Let’s now see how the getName() method works. When called on a primitive type array, it will return an opening bracket and a letter representing the primitive type. Let’s check that with the following example, calling that method on a bidimensional primitive integers array:
assertEquals("[[I", int[][].class.getName());
On the other hand, when called on an object array it will add an opening bracket and the L letter to its standard result and finish with a semi-colon. Let’s try it on an array of RetrieveClassName:
assertEquals("[Lcom.baeldung.className.RetrieveClassName;", RetrieveClassName[].class.getName());
4. Conclusion
In this article, we looked at four methods to access a class name in Java. These methods are: getSimpleName(), getName(), getTypeName() and getCanonicalName().
We learned that the first just returns the source code name of a class while the others provide more information such as package name and an indication of whether the class is inner or an anonymous class.
The code of this article can be found over on GitHub.
