java.lang.Class class in Java

The java.lang.Class class serves as a fundamental element of Java's Reflective Application Programming Interface (API), enabling software engineers to examine and modify classes through their coding process. As part of the java.lang package, it specifically refers to a particular class within a Java application. Objects instantiated from the Class class represent classes and interfaces in a Java program which is presently running. The Java "Class" class provides basic data types like Boolean, Byte, Char, Short, Int, Long, and FloatingPoint values. In contrast to most other classes, "Class" does not have a public constructor, instead, it is created at runtime by the Java Virtual Machine (JVM) during execution.

The Class class in Java functions as a representation of both classes and interfaces present in a currently running Java program. It offers various methods for retrieving details about a class, including its name, superclass, implemented interfaces, and methods.

Methods of the Class class:

Method	Description
getName()	The `getName()` method, belonging to the `java.lang.Class` class, returns the fully qualified name of the class or interface represented by the Class object. It is frequently utilized in Reflection for acquiring the full class name, which includes the package name when applicable.
getSimpleName()	The getSimpleName() method is part of the java.lang.Class class retrieves the simple name of the class or interface represented by the Class object in the Reflection API.
getSuperclass()	It returns the Class object representing the superclass of the class or interface represented by this Class object.
getInterfaces()	It returns an array of Class objects representing the interfaces implemented by the class or interface represented by the current Class object.
getField(String name)	It is used to obtain a Field object representing a specific public field with the given name in the class or interface represented by the current Class object.
getMethod(String name, Class<?>… parameterTypes)	It is used to obtain a Method object that represents a specific public method with the given name and parameter types in the class or interface represented by the current Class object.
newInstance()	It creates a new instance of the class it represents, assuming it has a public, no-argument constructor.
isInstance(Object obj)	The isInstance(Object obj) method is part of the java.lang.Class class in the Reflection API checks whether the provided object is an instance of the class or interface represented by the current Class object, returning true or false accordingly.
isAssignableFrom(Class<?> cls)	It checks if the class or interface represented by the current Class object is assignable from the specified class or interface (cls), returning true or false accordingly.

Example

Filename: ClassInfoExample.java

import java.util.Arrays;

public class ClassInfoExample {
    public static void main(String[] args) throws Exception {
        // Obtain the Class object for the String class
        Class<?> stringClass = String.class;

        // Display information about the String class
        System.out.println("The class name is: " + stringClass.getName());
        System.out.println("The simple class name is: " + stringClass.getSimpleName());

        // Display the superclass of the String class
        System.out.println("The superclass is: " + stringClass.getSuperclass().getName());

        // Display the interfaces implemented by the String class
        System.out.println("The interfaces implemented are: " + Arrays.toString(stringClass.getInterfaces()));

        // Check if String is assignable from Object
        System.out.println("Is it possible to assign String to Object? " + String.class.isAssignableFrom(Object.class));
    }
}

Output:

The class name is: java.lang.String
The simple class name is: String
The superclass is: java.lang.Object
The interfaces implemented are: [interface java.io.Serializable, interface java.lang.Comparable, interface java.lang.CharSequence]
Is it possible to assign String to Object? false

Creating a Class object

Creating a Class object in Java can be accomplished through various methods. Here are three commonly used approaches:

1. Class.forName("className"):

The Class.forName(String className) method is a static factory method for the Class class. It creates a Class object for the specified class name provided as a string. The name of the class must include the complete path, known as the fully qualified name, for the specific class we want.

Syntax:

2. MyClass.class:

Appending .class after a class name references the Class object representing that class. The approach is used when the class name is known at compile-time. It is often used with primitive data types.

Syntax:

3. obj.getClass():

The `getClass()` method belongs to the Object class. It gives the actual class of the object when we use it. It is useful when we want to figure out the class type while the program is running.

Syntax:

MyClass obj = new MyClass();
Class<?> c = obj.getClass();

Methods:

String toString():

The method turns a Class object into a string by adding either "class" or "interface," then a space, and finally, the complete name of the class to which the object belongs. If the Class object shows a basic data type, the method gives back the name of that type; otherwise, it returns "void."

Syntax:

Parameters:

None

Return Type:

Returns a string representation of the current class object.

Overrides:

The method overrides the toString method in the Object class.

Filename: StringDemo.java

// Java program with updated variable names and print statements
public class StringDemo {

    public static void main(String args[]) {
        // Creating a String object
        String firstString = new String("Hello World");

        // Printing the string representation using toString()
        System.out.print("Output String 1: ");
        System.out.println(firstString.toString());

        // Creating another String object
        String secondString = new String("Welcome to javatpoint");

        // Printing the string representation using toString()
        System.out.print("Output String 2: ");
        System.out.println(secondString.toString());
    }
}

Output:

Output String 1: Hello World
Output String 2: Welcome to javatpoint

Class<?> forName(String className)

It returns the Class object associated with the class or interface with the given string name.

Syntax:

Parameters:

className: A String representing the fully qualified name of the class or interface to be loaded.

Returns:

Return the Class object associated with the class that has the provided name.

Exception: The method may throw the following exceptions:

LinkageError: The exception is thrown if there is a failure in linking the class.
ExceptionInInitializerError: If the initialization triggered by this method encounters an error, this exception is thrown.
ClassNotFoundException: The exception is thrown if the specified class cannot be found.

Filename: ClassLoadingExample.java

public class ClassLoadingExample {

    public static void main(String[] args) throws ClassNotFoundException {
        // Fully qualified name of the class to load
        String className = "java.util.ArrayList";

        // Load the class dynamically
        Class<?> clazz = Class.forName(className);

        // Print the name of the loaded class
        System.out.println("Loaded Class Name: " + clazz.getName());
    }
}

Output:

Loaded Class Name: java.util.ArrayList

Class<?> forName(String className,boolean initialize, ClassLoader loader):

The method also provides the Class object linked to the class or interface identified by the given string name, utilizing the supplied class loader. The specified class loader is responsible for loading the class or interface. In the absence of a specified `loader` parameter or if it is null, the class will be loaded through the Bootstraps Class Loader during its initialization process, which occurs only when the `initialize` parameter is set to `true` and the class has not previously undergone initialization.

Syntax:

public static Class<?> forName(String className,boolean initialize, ClassLoader loader) throws ClassNotFoundException

Parameters:

className: A String representing the fully qualified name of the class to be loaded.
initialize: A boolean indicating whether the class should be initialized. If true, the class will be initialized; if false, it will not be initialized.
loader: A ClassLoader object used to load the class. If null, the default system class loader will be used.

Returns:

Retrieve the Class object representing the class with the provided name.

Throws:

LinkageError: Occurs if there is a failure in linking the class.
ExceptionInInitializerError: Arises if the initialization triggered by this method encounters an error.
ClassNotFoundException: Thrown if the specified class cannot be found.

Filename: DynamicClassLoadingDemo.java

// Java program illustrating the use of forName() method
public class DynamicClassLoadingDemo {

    public static void main(String[] args) throws ClassNotFoundException {
        // Obtain the Class object for the current class
        Class currentClass = Class.forName("DynamicClassLoadingDemo");

        // Get the ClassLoader associated with the current class
        ClassLoader classLoader = currentClass.getClassLoader();

        // Using the forName method to dynamically load the String class with the provided ClassLoader
        Class loadedClass = Class.forName("java.lang.String", true, classLoader);

        // Display the representation of the loaded class
        System.out.print("Class represented by loadedClass: " + loadedClass.toString());
    }
}

Output:

Class represented by loadedClass: class java.lang.String

T newInstance():

The `newInstance()` method creates a new instance of the class represented by the calling object. It is a way to dynamically instantiate an object without explicitly using the `new` keyword. The type of the new instance is based on the type of the object calling the method. Keep in mind that this method assumes the class has a default (parameterless) constructor, and it might throw exceptions if this condition is not met or if there are other instantiation issues.

Syntax:

Type Parameter:

T: Represents the class type for which an instance will be created.

Parameters:

No parameters are required.

Returns:

The object represents a newly allocated instance of the class.

Throws:

IllegalAccessException: If the class or its nullary constructor is not accessible.
InstantiationException: If this Class represents an abstract class, an interface, an array class, a primitive type, or void; or if the class has no nullary constructor; or if the instantiation fails for some other reason.
ExceptionInInitializerError: If the initialization provoked by this method fails.
SecurityException: If a security manager, s, is present.

boolean isInstance(Object obj)

The method checks if the given object can be assigned to the type represented by this Class. It is similarly to the instanceof operator in Java, verifying whether the specified object is compatible with the class it represents.

Syntax:

Parameters:

obj: The object to be checked for assignment compatibility with the class represented by the Class object.

Return Type:

boolean: It returns true if the specified object is an instance of the class or interface represented by the Class object, and false otherwise.

Filename: BooleanExample.java

// Java program to demonstrate the isInstance() method
public class BooleanExample {
    public static void main(String[] args) throws ClassNotFoundException {
        // Returns the Class object for the class 
        // with the specified name 
        Class<?> stringClass = Class.forName("java.lang.String");

        // Sample strings
        String sampleString = "javatpoint";
        Double sampleDouble = 10.5;

        // Checking for class instance using the isInstance method
        boolean isStringInstance = stringClass.isInstance(sampleString);
        boolean isDoubleInstance = stringClass.isInstance(sampleDouble);

        // Displaying results
        System.out.println("Is sampleString an instance of String? : " + isStringInstance);
        System.out.println("Is sampleDouble an instance of String? : " + isDoubleInstance);
    }
}

Output:

Is sampleString an instance of String? : true
Is sampleDouble an instance of String? : false

boolean isAssignableFrom(Class<?> cls)

The method boolean isAssignableFrom, checks if one class can be used in place of another. It returns true if the class represented by the current object is the same as, or is a superclass or superinterface of, the specified class (`cls`). Otherwise, it returns false.

Syntax:

Parameters:

cls: The class to check against.

Return Type:

boolean: It returns true if the class represented by the current Class object is assignable from the specified class (cls). Otherwise, it returns false.

Throws

NullPointerException: If the provided Class parameter is null, the method will throw a NullPointerException.

Filename: ExampleBoolean.java

public class ExampleBoolean extends Thread {
    public static void main(String[] args) throws ClassNotFoundException {
        // Returns the Class object for this class
        Class<?> myClass = ExampleBoolean.class;

        // Returns the Class object for the class with the specified name
        Class<?> threadClass = Class.forName("java.lang.Thread");
        Class<?> stringClass = Class.forName("java.lang.String");

        // isAssignableFrom method on threadClass
        // It checks whether the Thread class is assignable from ExampleBoolean
        boolean isThreadAssignable = threadClass.isAssignableFrom(myClass);

        // isAssignableFrom method on stringClass
        // It checks whether the String class is assignable from ExampleBoolean
        boolean isStringAssignable = stringClass.isAssignableFrom(myClass);

        System.out.println("Is ExampleBoolean assignable from Thread class? : " + isThreadAssignable);
        System.out.println("Is ExampleBoolean assignable from String class? : " + isStringAssignable);
    }
}

Output:

Is ExampleBoolean assignable from Thread class? : true
Is ExampleBoolean assignable from String class? : false

boolean isInterface()

The boolean isInterface() method determines whether the class or interface represented by the Class object is an interface.

Syntax:

Return Type:

boolean: It returns true if the class or interface represented by the Class object is an interface. Otherwise, it returns false.

Filename: booleanisInterface.java

public class booleanisInterface {
    public static void main(String[] args) {
        // Get the class object for String and Runnable
        Class<?> stringClass = String.class;
        Class<?> runnableClass = Runnable.class;

        // Check if String is an interface
        boolean isStringInterface = stringClass.isInterface();
        System.out.println("Is String an interface? : " + isStringInterface);

        // Check if Runnable is an interface
        boolean isRunnableInterface = runnableClass.isInterface();
        System.out.println("Is Runnable an interface? : " + isRunnableInterface);
    }
}

Output:

Is String an interface? : false
Is Runnable an interface? : true

boolean isPrimitive()

The boolean isPrimitive() method determines whether the class represented by the Class object is a primitive data type.

Syntax:

Return Type:

boolean: It returns true if the class represented by the Class object is a primitive data type. Otherwise, it returns false.

Filename: booleanisPrimitive.java

public class booleanisPrimitive {
    public static void main(String[] args) {
        // Get the class object for int and String
        Class<?> intClass = int.class;
        Class<?> stringClass = String.class;

        // Check if int is a primitive type
        boolean isIntPrimitive = intClass.isPrimitive();
        System.out.println("Is int a primitive type? : " + isIntPrimitive);

        // Check if String is a primitive type
        boolean isStringPrimitive = stringClass.isPrimitive();
        System.out.println("Is String a primitive type? : " + isStringPrimitive);
    }
}

Output:

Is int a primitive type? : true
Is String a primitive type? : false

boolean isArray()

It is used to determine whether the Class object represents an array class or not. The method returns true if the class is an array class and false otherwise.

Syntax:

Parameters:

The method takes no parameters.

Return Type:

boolean: It returns true if the class represents an array class; otherwise, it returns false.

Filename: ArrayCheckExample.java

public class ArrayCheckExample {
    public static void main(String[] args) {
        int numbers[] = new int[2];

        // Obtain the Class object for the array class of 'numbers'
        Class<?> arrayClass = numbers.getClass();

        // Obtain the Class object for the Test class
        Class<?> testClass = ArrayCheckExample.class;

        // Check if the classes represent array types

        // Using isArray method on the arrayClass
        boolean isArray1 = arrayClass.isArray();

        // Using the isArray method on the testClass
        boolean isArray2 = testClass.isArray();

        // Output the results in a clearer way
        System.out.println("The class represented by " + arrayClass.getName() + " is an array: " + isArray1);
        System.out.println("The class represented by " + testClass.getName() + " is an array: " + isArray2);
    }
}

Output:

The class represented by [I is an array: true
The class represented by ArrayCheckExample is an array: false

boolean isAnonymousClass()

The method yields a true result only if the current class is an anonymous class. An anonymous class is similar to a local class, with the key distinction that it does not possess a specified name.

Syntax:

Parameters:

The method does not take any parameters.

Return Type:

The return type is boolean, indicating that the method returns a true/false value. It returns true if the current class is anonymous and false otherwise.

Filename: AnonymousExample.java

import java.lang.*;
public class AnonymousExample {
   public static void main(String[] args) {
      // Creating an instance of the AnonymousExample class
      AnonymousExample myInstance = new AnonymousExample();

      // Obtaining the Class object associated with the instance
      Class<?> myClass = myInstance.getClass();

      // Retrieving the name of the class
      String className = myClass.getName();
      System.out.println("Class Name = " + className);
     
      // Checking if this class is an anonymous class
      boolean isAnonymous = myClass.isAnonymousClass();
      System.out.println("Is this an Anonymous Class? " + isAnonymous);
   }
}

Output:

Class Name = AnonymousExample
Is this an Anonymous Class? false

boolean isLocalClass()

The isLocalClass() method determines whether a class is declared within a method, making it a local class. It returns true if the class is local and false otherwise.

Syntax:

Parameters:

The method does not take any parameters.

Return:

The return type is boolean, indicating that the method returns a true/false value. It returns true if the class is a local class and false otherwise.

Filename: LocalClassExample.java

import java.lang.*;
public class LocalClassExample {
   public static void main(String[] args) {

      // Creating an instance of the LocalClassExample class
      LocalClassExample myInstance = new LocalClassExample();
      
      // Obtaining the Class object associated with the instance
      Class myClass = myInstance.getClass();

      // Retrieving the name of the class
      String className = myClass.getName();
      System.out.println("Class Name = " + className);
     
      // Checking if and only if this class is a local class
      boolean isLocal = myClass.isLocalClass();
      System.out.println("Is this a LocalClass? " + isLocal);
   }
}

Output:

Class Name = LocalClassExample
Is this a LocalClass? false

boolean isMemberClass()

The isMemberClass() method is part of the Class class in Java and is used to determine whether the class represents a member (non-local and non-anonymous) class. A member class is a class that is directly defined within another class or interface.

Syntax:

Parameters:

The method takes no parameters.

Return:

The return type is boolean, indicating that the method returns a true/false value. It returns true if the class represents a member (non-local and non-anonymous) class and false otherwise.

Filename: MemberClassExample.java

import java.lang.*;
public class MemberClassExample {
   public static void main(String[] args) {
      // Creating an instance of the MemberClassExample class
      MemberClassExample myInstance = new MemberClassExample();
      Class myClass = myInstance.getClass();

      // Retrieving the name of the class
      String className = myClass.getName();
      System.out.println("The class name is: " + className);
     
      // Checking if and only if this class is a member class
      boolean isMember = myClass.isMemberClass();
      System.out.println("Is this class a member class? " + isMember);
   }
}

Output:

The class name is: MemberClassExample
Is this class a member class? false

boolean isEnum()

It is used to determine whether the Class object represents an enumeration type or not.

Syntax:

Parameters:

The above method takes no parameters.

Return Type:

boolean: It returns true if the class represents an enumeration type; otherwise, it returns false.

Filename: EnumCheckExample.java

// Java program to demonstrate the isEnum() method

// Enum definition with different values
enum TrafficLight {
    RED, YELLOW, GREEN;
}

public class EnumCheckExample {
    public static void main(String[] args) {
        // Obtain the Class object associated with TrafficLight (an enum class)
        Class<?> trafficLightClass = TrafficLight.class;

        // Obtain the Class object associated with the EnumCheckExample class
        Class<?> testClass = EnumCheckExample.class;

        // Checking if the classes are Enum classes using isEnum method
        boolean isEnum1 = trafficLightClass.isEnum();
        boolean isEnum2 = testClass.isEnum();

        // Output the results with modified print statements
        System.out.println(trafficLightClass.getSimpleName() + " is an Enum class: " + isEnum1);
        System.out.println(testClass.getSimpleName() + " is an Enum class: " + isEnum2);
    }
}

Output:

TrafficLight is an Enum class: true
EnumCheckExample is an Enum class: false

boolean isAnnotation()

It is used to determine whether the Class object represents an annotation type or not. The method returns true if the class is an annotation type and false otherwise.

Syntax:

Parameters:

The above method takes no parameters.

Return Type:

boolean: It returns true if the class represents an annotation type; otherwise, it returns false.

Filename: AnnotationCheckExample.java

// Java program to demonstrate the isAnnotation() method

// Declaring an Annotation Type
@interface MyAnnotation {
    // Annotation element definitions (if any)
}

public class AnnotationCheckExample {
    public static void main(String[] args) throws ClassNotFoundException {
        // Obtain the Class object associated with MyAnnotation (an annotation)
        Class<?> annotationClass = MyAnnotation.class;

        // Obtain the Class object associated with the AnnotationCheckExample class
        Class<?> testClass = AnnotationCheckExample.class;

        // Checking if the classes are Annotation types using the isAnnotation method
        boolean isAnnotation1 = annotationClass.isAnnotation();
        boolean isAnnotation2 = testClass.isAnnotation();

        // Output the results with modified print statements
        System.out.println(annotationClass.getSimpleName() + " is an annotation type: " + isAnnotation1);
        System.out.println(testClass.getSimpleName() + " is an annotation type: " + isAnnotation2);
    }
}

Output:

MyAnnotation is an annotation type: true
AnnotationCheckExample is an annotation type: false

String getName()

It is used to obtain the fully qualified name of the class, interface, array, or primitive type represented by the Class object. The method returns a String that contains the name.

Syntax:

Parameters:

The method takes no parameters.

Return Type:

String: It returns the fully qualified name of the class or type represented by the Class object.

Filename: GetNameExample.java

public class GetNameExample {
    public static void main(String[] args) {
        // Obtain the Class object for the String class
        Class<?> stringClass = String.class;

        // Output the name using getName() method
        System.out.println("Name of class String: " + stringClass.getName());
    }
}

Output:

Name of class String: java.lang.String

String getSimpleName()

The getSimpleName() method, belonging to the java.lang.Class class in Java retrieves the name of the underlying class as specified in the source code. If the underlying class is anonymous, the method returns an empty string. In the case of an array, the simple name is derived from the component type, followed by "[]" to indicate an array. Specifically, the simple name is represented as "[]" for an array with an anonymous component type.

Syntax:

Parameters:

The method takes no parameters.

Return Type:

String: It returns the simple name of the class or interface represented by the Class object.

Filename: GetSimpleNameExample.java

public class GetSimpleNameExample {
    public static void main(String[] args) {
        // Obtain the Class object for the String class
        Class<?> stringClass = String.class;

        // Obtain the Class object for the Integer class
        Class<?> integerClass = Integer.class;

        // Output the simple names using getSimpleName() method
        System.out.println("Simple name of class String: " + stringClass.getSimpleName());
        System.out.println("Simple name of class Integer: " + integerClass.getSimpleName());
    }
}

Output:

Simple name of class String: String
Simple name of class Integer: Integer

ClassLoader getClassLoader()

It is used to obtain the class loader for the class or interface represented by the Class object. The method returns the ClassLoader object that loaded the class or interface.

Syntax:

Parameters:

The method takes no parameters.

Return Type:

ClassLoader: It returns the class loader for the class or interface represented by the Class object.

Throws:

SecurityException: The getClassLoader() method can throw a SecurityException if a security manager restricts access to the class loader for the respective class.

Filename: GetClassLoaderExample.java

public class GetClassLoaderExample {
    public static void main(String[] args) {
        // Obtain the Class object for the String class
        Class<?> stringClass = String.class;

        // Obtain the ClassLoader object using getClassLoader() method
        ClassLoader classLoader = stringClass.getClassLoader();

        // Output the class loader information
        System.out.println("Class loader for String class: " + classLoader);

        // Attempting to access the class loader for the current class
        Class<?> currentClass = GetClassLoaderExample.class;
        ClassLoader currentClassLoader = currentClass.getClassLoader();
        System.out.println("Class loader for current class: " + currentClassLoader);
    }
}

Output:

Class loader for String class: null
Class loader for current class: jdk.internal.loader.ClassLoaders$AppClassLoader@5cb0d902

TypeVariable<Class<T>>[ ] getTypeParameters()

It is used to obtain an array of TypeVariable objects representing the type parameters declared by the generic class or interface represented by the Class object.

Syntax:

Parameters:

The method takes no parameters.

Return Type:

TypeVariable<Class<T>>[]: It returns an array of TypeVariable objects representing the type parameters of the generic class or interface.

Throws:

GenericSignatureFormatError: if the generic signature of the class or interface does not follow the prescribed format specified by the Java Virtual Machine (JVM).

Filename: TypeVariableDemo.java

import java.lang.reflect.TypeVariable;
import java.util.List;

public class TypeVariableDemo {

    public static void main(String[] args) throws Exception {
        // returns an array of TypeVariable objects for the List class
        TypeVariable[] typeParameters = List.class.getTypeParameters();

        // Output the name of the first type parameter
        System.out.println("Type parameter of List class: " + typeParameters[0].getName());
    }
}

Output:

Type parameter of List class: E

Class<? super T> getSuperclass()

It is used to obtain the Class object representing the superclass of the class or interface represented by the Class object. If the class represented by this Class object is an interface, the method returns null.

Syntax:

Parameters:

The method takes no parameters.

Return Type:

Class<? super T>: It returns the Class object representing the superclass of the class or interface represented by the Class object.

Filename: GetSuperclassExample.java

import java.lang.*;
class SuperClass {
    // super class
}
class SubClass extends SuperClass {
    // sub class
}
public class GetSuperclassExample {
    public static void main(String args[]) {
        SuperClass instance1 = new SuperClass();
        SubClass instance2 = new SubClass();
        Class<?> classInfo;
        // Get the class of instance1
        classInfo = instance1.getClass();
        System.out.println("Instance 1 is an object of type: " + classInfo.getName());
        // Get the superclass of the class represented by instance1
        classInfo = classInfo.getSuperclass();
        System.out.println("Superclass of Instance 1: " + classInfo.getName());

        // Get the class of instance2
        classInfo = instance2.getClass();
        System.out.println("Instance 2 is an object of type: " + classInfo.getName());

        // Get the superclass of the class represented by instance2
        classInfo = classInfo.getSuperclass();
        System.out.println("Superclass of Instance 2: " + classInfo.getName());
    }
}

Output:

Instance 1 is an object of type: SuperClass
Superclass of Instance 1: java.lang.Object
Instance 2 is an object of type: SubClass
Superclass of Instance 2: SuperClass

Type getGenericSuperclass()

The Type getGenericSuperclass() method retrieves the Type that represents the immediate superclass of the entity, which can be a class, interface, primitive type, or void, as encapsulated by this Class instance.

Syntax:

Parameters:

The method takes no parameters.

Return Type:

Type: It returns the Type object representing the generic superclass of the class or interface.

Throws:

GenericSignatureFormatError: The generic class signature deviates from the prescribed format outlined in the Java Virtual Machine Specification, 3rd edition
TypeNotPresentException: If the generic superclass refers to a type declaration that doesn't exist, a TypeNotPresentException may be thrown.
MalformedParameterizedTypeException: If the generic superclass refers to a parameterized type that cannot be instantiated for any reason.

Filename: GenericTypeDemo.java

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;

public class GenericTypeDemo {

    public static void main(String[] arguments) {

        // Get the superclass
        Type genericSuperclass = IntegerListClass.class.getGenericSuperclass();
        System.out.println(genericSuperclass);

        // Extract the actual type argument using ParameterizedType
        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
        Type actualTypeArgument = parameterizedType.getActualTypeArguments()[0];
        System.out.println(actualTypeArgument);
    }
}

class IntegerListClass extends ArrayList<Integer> {
    public IntegerListClass() {
        // No-argument constructor
    }
}

Output:

java.util.ArrayList
class java.lang.Integer

Class<?>[] getInterfaces()

The `java.lang.Class.getInterfaces()` method identifies the interfaces implemented by the class or interface that this object represents.

Syntax:

Return Type:

Class<?>[]: It returns an array of Class objects representing the interfaces implemented by the class or interface.

Filename: GetInterfacesExample.java

import java.lang.reflect.*;
public class GetInterfacesExample {
    public static void main(String[] args) {
        // Obtain the Class object for a specific class
        Class<?> myClass = String.class;

        // Get the interfaces using getInterfaces() method
        Class<?>[] interfaces = myClass.getInterfaces();

        // Output the names of the interfaces
        System.out.println("Interfaces implemented by " + myClass.getName() + ":");
        for (Class<?> interfaceClass : interfaces) {
            System.out.println(interfaceClass.getName());
        }
    }
}

Output:

Interfaces implemented by java.lang.String:
java.io.Serializable
java.lang.Comparable
java.lang.CharSequence

Type[] getGenericInterfaces()

It is used to obtain the array of Type objects that represent the generic interfaces implemented by the class or interface represented by the current Class object.

Syntax:

Return Type:

Type[]: It returns an array of Type objects representing the generic interfaces implemented by the class or interface.

Throws:

GenericSignatureFormatError occurs when the generic class signature doesn't adhere to the specified format in the Java Virtual Machine Specification, 3rd edition.
TypeNotPresentException: Thrown if any generic superinterfaces refer to a type declaration that doesn't exist.
MalformedParameterizedTypeException: Raised when any of the generic superinterfaces refer to a parameterized type that cannot be instantiated.

Filename: GetGenericInterfacesExample.java

import java.lang.reflect.Type;

public class GetGenericInterfacesExample {
    public static void main(String[] args) throws ClassNotFoundException {
        // Returns the Class object for the class with the specified name
        Class<?> c1 = Class.forName("java.util.Set");

        // getGenericInterfaces() on c1
        // It returns the interfaces implemented by the Set interface
        Type[] c1GenericInterfaces = c1.getGenericInterfaces();

        System.out.println("Interfaces implemented by Set interface:");

        // Iterating through Set class interfaces
        for (Type type : c1GenericInterfaces) {
            System.out.println(type);
        }
    }
}

Output:

Interfaces implemented by Set interface:
java.util.Collection

Package getPackage()

It is used to retrieve the package for the class or interface represented by the current Class object.

Syntax:

Return Type:

Package: It returns the Package object representing the package of the class or interface.

Filename: GetPackageExample.java

public class GetPackageExample {
    public static void main(String[] args) {
        // Obtain the Class object for a specific class
        Class<?> myClass = String.class;

        // Get the package using getPackage() method
        Package classPackage = myClass.getPackage();

        // Output the name of the package
        System.out.println("Package of " + myClass.getName() + ": " + classPackage.getName());
    }
}

Output:

Package of java.lang.String: java.lang

Field[] getFields()

The `getFields()` method in Java is a part of the `Field` class and is used to retrieve an array of `Field` objects that represent the fields of a particular class or interface.

Syntax:

Parameters:

The method does not contain any parameters

Return:

The return type of getFields() is Field[]. It returns an array of Field objects representing the public fields of the class or interface.

Throws:

SecurityException: If a security manager, s, is present.

Filename: GetFieldsExample.java

import java.lang.reflect.Field;

public class GetFieldsExample {
    public static void main(String[] customArgs) throws SecurityException, ClassNotFoundException {
        // Returns the Class object for the class with the specified name
        Class<?> customClass = Class.forName("java.lang.Integer");

        // getFields method on customClass
        // It returns an array of fields of the Integer class
        Field[] customFields = customClass.getFields();

        System.out.println("Below are the fields of Integer class:");

        // Iterating through all fields of the Integer class
        for (Field customField : customFields) {
            System.out.println(customField);
        }
    }
}

Output:

Below are the fields of Integer class:
public static final int java.lang.Integer.MIN_VALUE
public static final int java.lang.Integer.MAX_VALUE
public static final java.lang.Class java.lang.Integer.TYPE
public static final int java.lang.Integer.SIZE
public static final int java.lang.Integer.BYTES

Class<?>[ ] getClasses()

It is used to get an array of Class objects representing the public member classes and interfaces of the current Class object class.

Syntax:

Return:

The method returns an array of Class<?> objects, representing the public member classes and interfaces of the class.

Throws:

SecurityException: If a security manager, s, is present.

Filename: GetClassesExample.java

import java.lang.reflect.*;

public class GetClassesExample {
    public static void main(String[] args) {
        try {
            // Get the Class object for the current class (GetClassesExample)
            Class<?> thisClass = GetClassesExample.class;

            // Retrieve the public member classes of the class
            Class<?>[] classes = thisClass.getClasses();

            // Display information about each public member class
            System.out.println("Public Member Classes of GetClassesExample:");
            for (Class<?> cls : classes) {
                System.out.println(cls.getName());
            }
        } catch (SecurityException e) {
            e.printStackTrace();
        }
    }
}

Output:

Public Member Classes of GetClassesExample:

Method[] getMethods()

It is used to retrieve an array of Method objects reflecting the public methods of the class or interface represented by the current Class object. It includes public methods from the class itself and its superclasses and interfaces.

Syntax:

Return:

The method returns an array of Method objects representing the public methods of the class or interface.

Throws:

SecurityException: If a security manager, s, is present.

Filename: GetMethodsExample.java

import java.lang.reflect.Method;

public class GetMethodsExample {
    public static void main(String[] args) {
        try {
            // Get the Class object for a specific class (e.g., MyClass)
            Class<?> myClass = Class.forName("MyClass");

            // Retrieve the public methods of the class
            Method[] methods = myClass.getMethods();

            // Display information about each public method
            System.out.println("Public Methods of MyClass:");
            for (Method method : methods) {
                System.out.println(method.getName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class MyClass {
    // Public methods
    public void method1() {
    }

    public int method2(String param) {
        return 0;
    }
}

Output:

Public Methods of MyClass:
method1
method2
wait
wait
wait
equals
toString
hashCode
getClass
notify
notifyAll

Constructor<?>[] getConstructors()

It is used to retrieve an array of Constructor objects reflecting all the public constructors of the class or interface represented by the current Class object.

Syntax:

Return:

The method returns an array of Constructor<?> objects, representing the public constructors of the class or interface.

Throws:

SecurityException: If a security manager, s, is present.

Filename: ConstructorsExample.java

import java.lang.reflect.Constructor;

public class ConstructorsExample {
    public static void main(String[] args) {
        try {
            // Get the Class object for a specific class (e.g., Boolean)
            Class<?> booleanClass = Class.forName("java.lang.Boolean");

            // Retrieve the public constructors of the class
            Constructor<?>[] constructors = booleanClass.getConstructors();

            // Display information about each public constructor
            System.out.println("Constructors of Boolean class:");
            for (Constructor<?> constructor : constructors) {
                System.out.println(constructor);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Output:

Constructors of Boolean class:public java.lang.Boolean(boolean)
public java.lang.Boolean(java.lang.String)

Field getField(String fieldName)

It is used to get a Field object that reflects the specified public member field of the class or interface represented by the current Class object.

Syntax:

public Field getField(String fieldName) throws NoSuchFieldException, SecurityException

Parameters:

fieldName: The name of the field.

Return Type:

The method returns a Field object representing the specified public field.

Throws:

NoSuchFieldException: Occurs if the specified field name is not found or accessible.
NullPointerException: Arises when the provided field name is null.
SecurityException: It may be thrown if a security manager is present and certain security conditions related to package access and definition are not met.

Filename: ExampleGetField.java

// Java program demonstrating the use of the getField() method

import java.lang.reflect.Field;

public class ExampleGetField {
    public static void main(String[] args)
            throws SecurityException, ClassNotFoundException,
            NoSuchFieldException {
        // Obtains the Class object for the specified class name (java.lang.Integer)
        Class<?> classObj = Class.forName("java.lang.Integer");

        // Retrieves a public field named "MIN_VALUE" from the Integer class
        Field fieldObj = classObj.getField("MIN_VALUE");

        // Displays information about the public field in the Integer class with MIN_VALUE name
        System.out.println("Public field in Integer class with MIN_VALUE name:");
        System.out.println(fieldObj);
    }
}

Output:

Public field in Integer class with MIN_VALUE name:
public static final int java.lang.Integer.MIN_VALUE

Method getMethod(String methodName,Class… parameterTypes)

The method retrieves a `Method` object, providing comprehensive reflection details about a specific public method associated with the class or interface represented by the current Class object.

Syntax:

Parameters:

methodName: A string representing the name of the method we want to retrieve.
parameterTypes: A variable number of Class objects representing the method's parameter types.

Returns:

The method returns the method object of the class specified by the given name.

Throws:

NoSuchMethodException: Thrown if a method with the specified name is not found.
NullPointerException: Thrown if the provided method name is null.
SecurityException: Thrown if a security manager (s) is present.

Filename: ExampleMethodGetMethod.java

import java.lang.reflect.Method;

public class ExampleMethodGetMethod {
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, ClassNotFoundException {
        // Obtain the Class object for the specified class name (for example, java.lang.String)
        Class<?> classObj = Class.forName("java.lang.String");

        // Retrieve the method named "length" with no parameters from the String class
        Method methodObj = classObj.getMethod("length");

        // Display information about the retrieved method
        System.out.println("Details of the 'length' method in the String class:");
        System.out.println("Method Name: " + methodObj.getName());
        System.out.println("Return Type: " + methodObj.getReturnType());
    }
}

Output:

Details of the 'length' method in the String class:
Method Name: length
Return Type: int

Constructor<?> getConstructor(Class<?>… parameterTypes)

The method fetches a Constructor object that represents a particular public constructor of the class indicated by the current Class object. The parameterTypes parameter is an array of Class objects, specifying the types of parameters for the constructor, arranged in the order they are declared.

Syntax:

public Constructor<?> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException,SecurityException

Parameters:

parameterTypes: An array of Class objects representing the formal parameter types of the constructor, in declared order.

Return:

Returns a Constructor object reflecting the specified public constructor of the class represented by this Class object.

Throws:

NoSuchMethodException: If a constructor with the specified parameter types is not found.
SecurityException: If a security manager is present.

Filename: ExampleConstructor.java

import java.lang.reflect.Constructor;

public class ExampleConstructor {
    public static void main(String[] args) throws Exception {
        // Obtain Class objects for Integer and String classes
        Class<?> integerClass = Integer.class;
        Class<?> stringClass = String.class;

        try {
            // Get a public constructor in the Integer class with a String parameter
            Constructor<?> constructor = integerClass.getConstructor(stringClass);

            // Display information about the retrieved constructor
            System.out.println("Constructor in Integer class with String parameter:");
            System.out.println(constructor);
        } catch (NoSuchMethodException e) {
            System.err.println("No such constructor found.");
        }
    }
}

Output:

Constructor in Integer class with String parameter:
public java.lang.Integer(java.lang.String) throws java.lang.NumberFormatException

T cast(Object obj)

The method converts an object to the class or interface this `Class` object indicates.

Syntax:

Parameters:

obj: The object to be cast.

Return:

Returns the object after casting it to the generic type T. The result type (T) is inferred based on the context in which the method is called.

Filename: ExampleTCast.java

import java.util.List;

public class ExampleTCast {
    public static void main(String[] args) {
        Object anyObject = "Hello, World!";
        
        // Using cast to dynamically cast anyObject to String
        String outputResult = String.class.cast(anyObject);

        // Display the result after casting
        System.out.println("Casting Result: " + outputResult);
    }
}

Output:

Casting Result: Hello, World!

<U> Class<? extends U> asSubclass(Class<U> clazz)

The method casts this Class object to represent a subclass of the class represented by the specified class object.

Syntax:

Parameters:

<U>: A generic type representing the target type.
clazz: A Class object indicating the target class or interface.

Return Type:

Class<? extends U>: The method returns a Class object representing the specified class or a subclass, ensuring it is a subclass of the target type U.

Throws:

ClassCastException: If the current Class object doesn't genuinely represent a subclass (including the class itself).

Filename: ExampleClassExtends.java

public class ExampleClassExtends {
    public static void main(String[] args) {
        // Create a Class object representing the Integer class
        Class<?> integerClass = Integer.class;

        // Attempt to cast the Integer class as a subclass of Number
        Class<? extends Number> numberSubclass = integerClass.asSubclass(Number.class);

        // Display the result
        System.out.println("Integer class cast as a subclass of Number: " + numberSubclass.getName());
    }
}

Output:

Integer class cast as a subclass of Number: java.lang.Integer

Next TopicReverse Level Order Traversal in Java

← prev next →

Latest Courses

We provides tutorials and interview questions of all technology like java tutorial, android, java frameworks

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

[email protected].

Python

AI, ML and Data Science

Java

B.Tech and MCA

Web Technology

Software Testing

Technical Interview

Java Interview

Web Interview

Database Interview

Company Interviews

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java String

Java String Methods

Java Regex

Exception Handling

Java Inner Class

Java Multithreading

Java Synchronization

Java Networking

Java Applet

Java Reflection

Java Conversion

Java JDBC

RMI

Internationalization

Java Array Class

Java AtomicInteger Class

Java AtomicLong Methods

Java Authenticator

Java BigDecimal class

Big Integer Class

Java Boolean class

Java Byte Class

Java Class

Java Collections class

Java Compiler Class

CopyOnWriteArrayList

Java Math Methods

LinkedBlockingDeque

Java Long class

LinkedTransferQueue

Java List

Java MulticastSocket

Java Number Class

Java Phaser Class

ArrayList Methods

Java Thread Methods

Java Projects

Java Programs

Java Misc

Java Date Class

Java ListIterator Class

Java NIO Tutorial

HttpURLConnection

Java Deque

Java HttpCookie Class

Java URL class

Java List Methods

Java Vector class

Java Collection Methods

Java Socket Class

Java Executors

java.lang.Class class in Java

Methods of the Class class:

Example

Creating a Class object

Methods:

String toString():

Class<?> forName(String className)

Class<?> forName(String className,boolean initialize, ClassLoader loader):

T newInstance():