Java Class Name
How to write a class name?
The following considerations should be made while writing class names.
- The name of the current class shouldn't be based on a preset or existing class.
- Java keywords shouldn't be used as class names.
- The class name should begin with a capital letter and end with a tiny letter (mixed case).
class Example
Every word in the name should start with a capital letter, and the other characters should be small.
class Main
It is advised to keep interface names short and descriptive.
It is preferable to avoid acronyms when writing class names.
Example
Main.java
public class Main {
public void Method1 ( ) {
System . out . println ( " In Method1 " ) ;
}
public void Method2 ( ) {
System . out . println ( " In Method 2 " ) ;
}
public static void main ( String args [ ] ) {
Main o1 = new Main ( ) ;
o1 . Method1 ( ) ;
o1 . Method2 ( ) ;
}
}
Output
This is sample method
This is demo method
There are four methods on the Class API that can be used to get the name of a class: getSimpleName(), getName(), getTypeName(), and getCanonicalName ().
GetSimpleName() Method
There are two categories of names in Java: qualified and simple. A qualified name is a list of simple names separated by dots, whereas a simple name is an individual identifier.
GetSimpleName(), as its name implies, returns the underlying class's simple name, which is the name specified for it in the source code.
package com.baeldung.className;
public class RetrieveClassName {}
RetrieveClassName: would be its short name.
assertEquals("RetrieveClassName",RetrieveClassName.class.getSimpleName()));
Primitive types and arrays can also be given short names. For primitive types like int, boolean, and float, that will just be their names.
Additionally, the method will return an array's type in its simplest form, followed by opening and closing braces for each dimension ([]):
RetrieveClassName[] n = new RetrieveClassName[];
assertEquals("RetrieveClassName[]", n.getClass().getSimpleName());
Finding Additional Names
We should now examine how we might discover a class's name, type name. These names seek to provide more details about the class than getSimpleName() does.
The canonical name as specified in the Java Language Specification is always returned by the getCanonicalName() function.
In terms of the other ways, the results may vary slightly depending on the use cases. We'll explore what that means for various object and primitive types.
Primitive Types
Since primitive types are the most basic, let's start with them. The results of the three methods getName(), getTypeName(), and getCanonicalName() for primitive types are identical to those of getSimpleName().
Object Types
We'll see how these techniques function with object types in a moment. They all return the class's canonical name, which is normally how they behave.
Most of the time, this is a qualified name that also includes the class simple name and all of the class package simple names.
Inner Classes
The majority of these method calls behave as we've seen in the previous section, but there are a few outliers.
One of them is inner classes. When used to inner classes, the getName() and getTypeName() methods act differently than the getCanonicalName() method.
The canonical name of the class, which is the canonical name of the enclosing class plus the simple name of the inner class separated by a dot, is still returned by the getCanonicalName() method.
Anonymous Classes
They lack a canonical name as well as a simple name, as we have already shown. Consequently, getCanonicalName() returns nothing. When invoked on an anonymous class, getCanonicalName() will return null rather than an empty string, in contrast to getSimpleName().
The canonical name of the calling class, a dollar amount, and a number denoting the anonymous class's position among all other anonymous classes formed in the calling class are returned by the getName() and getTypeName() functions, respectively.
Arrays
Finally, let's look at how the aforementioned three approaches deal with arrays.Each method will adjust its typical result to reflect the fact that we are working with arrays. The results of the getTypeName() and getCanonicalName() functions will have bracketed pairs appended to them.To distinguish the inner class portion from the remainder of the name, the first call utilises a dollar sign in place of a dot.