Java get class null object

Guide: java.lang.Class java.lang.Object.getClass()’ on a null object reference

The `java.lang.Class java.lang.Object.getClass()` method is used to get the runtime class of an object. However, when this method is called on a null object reference, it throws a `NullPointerException`. In this guide, we will discuss what causes this exception and how to avoid it.

Understanding the Exception

When we call the `getClass()` method on a null object reference, the Java Virtual Machine (JVM) tries to dereference the null pointer to find the object’s class. Since a null reference doesn’t point to any object, the JVM throws a `NullPointerException`.

Example Code

public class NullReferenceDemo < public static void main(String[] args) < String str = null; Class clazz = str.getClass(); // Throws NullPointerException >> 

In the above code, we have declared a `String` variable `str` and assigned a null value to it. When we call the `getClass()` method on the `str` object, it throws a `NullPointerException`.

Avoiding the Exception

To avoid this exception, we need to check if the object reference is null before calling the `getClass()` method. We can use the `instanceof` operator to check if the object is not null and is an instance of the expected class.

public class AvoidNullPointerExceptionDemo < public static void main(String[] args) < String str = null; Class clazz = (str != null) ? str.getClass() : null; System.out.println(clazz); // Prints null >> 

In the above code, we have added a null check before calling the `getClass()` method. If the `str` object is not null, then we call the `getClass()` method, otherwise we assign a null value to `clazz`.

Conclusion

In this guide, we have discussed the `java.lang.Class java.lang.Object.getClass()` method and the `NullPointerException` that can occur when calling this method on a null object reference. We have also shown how to avoid this exception by adding a null check before calling the `getClass()` method.

Источник

Retrieving Class Objects

The entry point for all reflection operations is java.lang.Class . With the exception of java.lang.reflect.ReflectPermission , none of the classes in java.lang.reflect have public constructors. To get to these classes, it is necessary to invoke appropriate methods on Class . There are several ways to get a Class depending on whether the code has access to an object, the name of class, a type, or an existing Class .

Object.getClass()

If an instance of an object is available, then the simplest way to get its Class is to invoke Object.getClass() . Of course, this only works for reference types which all inherit from Object . Some examples follow.

Class c = System.console().getClass();

There is a unique console associated with the virtual machine which is returned by the static method System.console() . The value returned by getClass() is the Class corresponding to java.io.Console .

enum E < A, B >Class c = A.getClass();

A is an instance of the enum E ; thus getClass() returns the Class corresponding to the enumeration type E .

byte[] bytes = new byte[1024]; Class c = bytes.getClass();

Since arrays are Objects , it is also possible to invoke getClass() on an instance of an array. The returned Class corresponds to an array with component type byte .

import java.util.HashSet; import java.util.Set; Set s = new HashSet(); Class c = s.getClass();

In this case, java.util.Set is an interface to an object of type java.util.HashSet . The value returned by getClass() is the class corresponding to java.util.HashSet .

The .class Syntax

If the type is available but there is no instance then it is possible to obtain a Class by appending «.class» to the name of the type. This is also the easiest way to obtain the Class for a primitive type.

boolean b; Class c = b.getClass(); // compile-time error Class c = boolean.class; // correct

Note that the statement boolean.getClass() would produce a compile-time error because a boolean is a primitive type and cannot be dereferenced. The .class syntax returns the Class corresponding to the type boolean .

Class c = java.io.PrintStream.class;

The variable c will be the Class corresponding to the type java.io.PrintStream .

The .class syntax may be used to retrieve a Class corresponding to a multi-dimensional array of a given type.

Class.forName()

If the fully-qualified name of a class is available, it is possible to get the corresponding Class using the static method Class.forName() . This cannot be used for primitive types. The syntax for names of array classes is described by Class.getName() . This syntax is applicable to references and primitive types.

Class c = Class.forName("com.duke.MyLocaleServiceProvider");

This statement will create a class from the given fully-qualified name.

Class cDoubleArray = Class.forName("[D"); Class cStringArray = Class.forName("[[Ljava.lang.String;");

The variable cDoubleArray will contain the Class corresponding to an array of primitive type double (that is, the same as double[].class ). The cStringArray variable will contain the Class corresponding to a two-dimensional array of String (that is, identical to String[][].class ).

TYPE Field for Primitive Type Wrappers

The .class syntax is a more convenient and the preferred way to obtain the Class for a primitive type; however there is another way to acquire the Class . Each of the primitive types and void has a wrapper class in java.lang that is used for boxing of primitive types to reference types. Each wrapper class contains a field named TYPE which is equal to the Class for the primitive type being wrapped.

There is a class java.lang.Double which is used to wrap the primitive type double whenever an Object is required. The value of Double.TYPE is identical to that of double.class .

Void.TYPE is identical to void.class .

Methods that Return Classes

There are several Reflection APIs which return classes but these may only be accessed if a Class has already been obtained either directly or indirectly.

Class.getSuperclass() Returns the super class for the given class.

Class c = javax.swing.JButton.class.getSuperclass();

The super class of javax.swing.JButton is javax.swing.AbstractButton . Class.getClasses() Returns all the public classes, interfaces, and enums that are members of the class including inherited members.

Class[] c = Character.class.getClasses();

Character contains two member classes Character.Subset and Character.UnicodeBlock . Class.getDeclaredClasses() Returns all of the classes interfaces, and enums that are explicitly declared in this class.

Class[] c = Character.class.getDeclaredClasses();

import java.lang.reflect.Field; Field f = System.class.getField("out"); Class c = f.getDeclaringClass();

public class MyClass < static Object o = new Object() < public void m() <>>; static Class = o.getClass().getEnclosingClass(); >

The declaring class of the anonymous class defined by o is null . Class.getEnclosingClass() Returns the immediately enclosing class of the class.

Class c = Thread.State.class().getEnclosingClass();

public class MyClass < static Object o = new Object() < public void m() <>>; static Class = o.getClass().getEnclosingClass(); >

Источник

getClass() on Object with null value

posted 20 years ago

Hi
I have a function looking somewhat like this:

throws a NullPointerException — nothing wront with that, but the way I figure, ‘i’ has the type Integer even if it’s value is null. When calling ‘func’ ‘value’ gets the type Integer, even if the value is null — is this a correct assumption? If ‘i’ was not null, clazz would of course be ‘java.lang.Integer’
So what I would like to archive, is being able to tell what object-type value is, even if it’s null — is this possible?

posted 20 years ago

throws a NullPointerException — nothing wront with that, but the way I figure, ‘i’ has the type Integer even if it’s value is null. When calling ‘func’ ‘value’ gets the type Integer, even if the value is null — is this a correct assumption? If ‘i’ was not null, clazz would of course be ‘java.lang.Integer’

Welcome to JavaRanch S�ren. You must remember that ‘i’ is not an object but a mere reference to that object. It’s class would actually be java.lang.Reference if I am not mistaken. So when you call ‘i.getClass()’, ‘i’ is derefernced and now the runtime is attempting to access the underlying object and if that points to an invalid heap address, then naturally a NPE is going to be thrown.

Any intelligent fool can make things bigger, more complex, and more violent. It takes a touch of genius — and a lot of courage — to move in the opposite direction. — Ernst F. Schumacher

posted 20 years ago

Perhaps you can use i.class to get the Class object instead. I’ve seen this mentioned here a few times, but I’m not sure if it will work. It may only work on class names rather than reference names.

Источник

Метод getClass(), объект класс, знакомство с Reflection

А теперь самое интересное. Мы познакомимся с классом Class и немного с Reflection.
Как ты уже, наверное, успел понять, в Java все является объектом. А что нужно для объекта? Что есть у каждого объекта и определяет саму его суть?

— Правильно! Молодец. У каждого объекта есть класс. Но вернемся к объектам. Некоторые объекты полностью содержат какую-то сущность, другие же просто помогают ей управлять.

Ко вторым можно отнести FileOutputStream или Thread. Когда ты создаешь объект Thread, новая нить не создается. Ее создает Java-машина после вызова метода start(). Этот объект просто помогает управлять процессом.

Так же и FileOutputStream: файл хранится на диске и его хранением и доступом к нему управляет ОС. Но мы можем взаимодействовать с ним посредством объектов типа File, при опять-таки помощи Java-машины.

— Так вот, для взаимодействия с классами есть специальный класс и называется он — Class.

— Не трудно было догадаться.

— Ага. Каждый раз, когда Java-машина загружает в память новый класс, она создает объект типа Class, посредством которого можно получить некоторую информацию о загруженном классе.

К каждому классу и объекту привязан такой «объект класса».

Class clazz = Integer.class;

Class clazz = new Object().getClass();

А почему ты пишешь clazz, а не class?

— А ты помнишь, что слово class – это ключевое слово в Java и использовать его для именования переменных нельзя?

— Да, я это знаю, знаю. Только забыл.

— Ты где-нибудь уже использовал объект Class?

— Да, мы использовали его, когда писали свою реализацию метода equals.

— Да, можно сравнить – одинаковые ли у объектов классы, если воспользоваться методом getClass().

— А что можно делать с этим объектом?

Class s = int.class; String name = s.getName();

Class s = Class.forName("java.lang.String");

Object o1 = String.valueOf(1); Object o2 = 123 + "T"; o1.getClass() == o2.getClass();

— Интересно, но не так круто, как я думал.

— Хочешь, чтобы было круто? Есть еще Reflection. Reflection – это очень круто.

— А что такое Reflection?

— Reflection – это способность класса получить информацию о самом себе. В Java есть специальные классы: Field – поле, Method – метод, по аналогии с Class для классов. Т.к. объект типа Class дает возможность получить информацию о классе, то объект типа Field–получить информацию о «поле класса», а Method–о «методе класса». И вот что с ними можно делать:

Class[] interfaces = List.class.getInterfaces();

Class parent = String.class.getSuperclass();

Method[] methods = List.class.getMethods();

String s = String.class.newInstance();

String s = String.class.newInstance(); Method m = String.class.getMethod("length"); int length = (int) m.invoke(s);

— Вау! Вот это реально круто!

Источник