In Java, the class java.lang.Class<\/em><\/a> is the entry point of all reflection operations<\/strong>. Once we have an object of java.lang.Class<\/em>, we can then call the corresponding methods to get the objects of the reflection classes.<\/p>\n In this tutorial, we’ll discuss the differences between two different ways to get an object of java.lang.Class<\/em>:<\/p>\n The\u00a0Object.getClass()<\/em> method is an instance method of the\u00a0Object<\/em> class. If we have an object, we can call object.getClass()<\/em> to get the Class<\/em> object of its type.<\/p>\n Similarly, we can use the ClassName.class<\/em> syntax to get the Class<\/em> object of the type. An example can explain it clearly:<\/p>\n In the test method above, we try to obtain the\u00a0Class\u00a0<\/em>object of the\u00a0String<\/em> class using the two ways we’ve mentioned. Finally, the assertion method tells us that the two Class<\/em> objects are the same instance.<\/p>\n However, there are differences between the two approaches. Let’s take a closer look at them.<\/p>\n Let’s review the previous example quickly. When we call the str.getClass()<\/em> method, we get the runtime type of the str<\/em> object. On the other hand, String.class <\/em>evaluates the\u00a0String<\/em> class statically<\/strong>. In this example, the runtime type of\u00a0str<\/em> and the\u00a0String.class<\/em> are the same.<\/p>\n However, they can be different if class inheritance joins the party. Let’s see two simple classes:<\/p>\n Now let’s instantiate an object of the Animal<\/em> class and do another test:<\/p>\n If we run the test above, we’ll get a test failure:<\/p>\n In the test method, even if we instantiated the\u00a0animal<\/em> object by Animal animal = new Monkey();<\/em> instead of Monkey animal = new Monkey();<\/em>, the runtime type of the\u00a0animal<\/em> object is still\u00a0Monkey.\u00a0<\/em>This is because the\u00a0animal<\/em> object is an instance of\u00a0Monkey<\/em> at runtime.<\/p>\n However, when we get the static type of the\u00a0Animal<\/em> class, the type is always\u00a0Animal<\/em>.<\/p>\n When we write Java code, we use primitive types quite often. Let’s try to get a Class<\/em> object of a primitive type using the\u00a0object.getClass()<\/em> approach:<\/p>\n If we try to compile the code above, we’ll get a compilation error:<\/p>\n The compiler can’t dereference the number<\/em> variable since it is a primitive variable. Therefore, the object.getClass()<\/em> method can’t help us to get the Class<\/em> object of a primitive type.<\/strong><\/p>\n Let’s see if we can get the primitive type using the .class<\/em> syntax:<\/p>\n So, we can obtain the Class<\/em> object of the int <\/em>primitive type through\u00a0int.class<\/em>.\u00a0 In Java version 9 and later, a Class<\/em> object of primitive type belongs to the java.base <\/em>module.<\/p>\n As the test shows, the .class<\/em> syntax is an easy way to get the Class<\/em> object of a primitive type.<\/strong><\/p>\n We’ve learned that the object.getClass()<\/em> method can give us the Class<\/em> object of its runtime type.<\/p>\n Now, let’s consider the case where we want to obtain a Class<\/em> object of a type, but we can’t get an instance of the target type because it’s an abstract<\/em> class, an interface,\u00a0<\/em>or some class doesn’t allow instantiation:<\/p>\n In these cases, we can’t get the Class<\/em> objects of those types using the\u00a0object.getClass()<\/em> method, but we can still use the .class<\/em> syntax to obtain the\u00a0Class<\/em> objects<\/strong> of them:<\/p>\n As the test above shows, the\u00a0.class<\/em> syntax can obtain the Class<\/em> objects for those types.<\/p>\n Therefore, when we want to have the\u00a0Class<\/em> object, but we cannot get an instance of the type, the .class<\/em> syntax is the way to go.<\/strong><\/p>\n In this article, we learned two different ways to get the Class<\/em> object of a type: the object.getClass()<\/em> method and the .class<\/em> syntax.<\/p>\n Later, we discussed the difference between the two approaches. The following table can give us a clear overview:<\/p>\n\n
2. Short Introduction to the Two Approaches<\/h2>\n
@Test\r\npublic void givenObjectAndType_whenGettingClassObject_thenTwoMethodsHaveTheSameResult() {\r\n String str = \"I am an object of the String class\";\r\n Class fromStrObject = str.getClass();\r\n Class clazz = String.class;\r\n assertSame(fromStrObject, clazz);\r\n}\r\n<\/code><\/pre>\n3. The Runtime Type vs. the Static Type<\/h2>\n
public class Animal {\r\n protected int numberOfEyes;\r\n}\r\npublic class Monkey extends Animal {\r\n \/\/ monkey stuff\r\n}<\/code><\/pre>\n@Test\r\npublic void givenClassInheritance_whenGettingRuntimeTypeAndStaticType_thenGetDifferentResult() {\r\n Animal animal = new Monkey();\r\n Class runtimeType = animal.getClass();\r\n Class staticType = Animal.class;\r\n assertSame(staticType, runtimeType);\r\n}\r\n<\/code><\/pre>\njava.lang.AssertionError: ....\r\nExpected :class com.baeldung.getclassobject.Animal\r\nActual :class com.baeldung.getclassobject.Monkey<\/code><\/pre>\n4. Handling Primitive Types<\/h2>\n
int number = 7;\r\nClass numberClass = number.getClass();<\/code><\/pre>\nError: java: int cannot be dereferenced<\/code><\/pre>\n@Test\r\npublic void givenPrimitiveType_whenGettingClassObject_thenOnlyStaticTypeWorks() {\r\n Class intType = int.class;\r\n assertNotNull(intType);\r\n assertEquals(\"int\", intType.getName());\r\n assertTrue(intType.isPrimitive());\r\n}\r\n<\/code><\/pre>\n5. Getting the Class Without an Instance<\/h2>\n
public abstract class SomeAbstractClass {\r\n \/\/ ...\r\n}\r\ninterface SomeInterface {\r\n \/\/ some methods ...\r\n}\r\npublic class SomeUtils {\r\n private SomeUtils() {\r\n throw new RuntimeException(\"This Util class is not allowed to be instantiated!\");\r\n }\r\n \/\/ some public static methods...\r\n}\r\n<\/code><\/pre>\n@Test\r\npublic void givenTypeCannotInstantiate_whenGetTypeStatically_thenGetTypesSuccefully() {\r\n Class interfaceType = SomeInterface.class;\r\n Class abstractClassType = SomeAbstractClass.class;\r\n Class utilClassType = SomeUtils.class;\r\n assertNotNull(interfaceType);\r\n assertTrue(interfaceType.isInterface());\r\n assertEquals(\"SomeInterface\", interfaceType.getSimpleName());\r\n assertNotNull(abstractClassType);\r\n assertEquals(\"SomeAbstractClass\", abstractClassType.getSimpleName());\r\n assertNotNull(utilClassType);\r\n assertEquals(\"SomeUtils\", utilClassType.getSimpleName());\r\n}\r\n<\/code><\/pre>\n6. Conclusion<\/h2>\n
![](\"https:\/\/assets.feedblitz.com\/i\/fblike20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/googleplus20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/pinterest20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/twitter20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/email20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/rss20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/comments20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/commentsrss20.png\")
<\/a> <\/div>\n\n![\\\"IT\u96fb\u8166\u88dc\u7fd2](\\\"http:\/\/itteacheritfreelance.hk\/test\/wordpress\/wp-content\/uploads\/2016\/05\/logo2-2.png\\\"){kind=logo}