Java Reflection API Tutorial with Example

What is Reflection in Java?

Java Reflection is the process of analyzing and modifying all the capabilities of a class at runtime. Reflection API in Java is used to manipulate class and its members which include fields, methods, constructor, etc. at runtime.

One advantage of reflection API in Java is, it can manipulate private members of the class too.

The java.lang.reflect package provides many classes to implement reflection java.Methods of the java.lang.Class class is used to gather the complete metadata of a particular class.

In this tutorial, you will learn-

• What is Reflection
• Class in java.lang.reflect Package
• Methods used in java.lang.Class
• How to get complete information about a class
• Example 1: How to get Metadata of Class
• Example 2: How to get Metadata of Variable
• Example 3: How to get Metadata of Method
• Example 4: How to get Metadata of Constructors

Class in java.lang.reflect Package

Following is a list of various Java classes in java.lang.package to implement reflection-

• Field: This class is used to gather declarative information such as datatype, access modifier, name and value of a variable.
• Method: This class is used to gather declarative information such as access modifier, return type, name, parameter types and exception type of a method.
• Constructor: This class is used to gather declarative information such as access modifier, name and parameter types of a constructor.
• Modifier: This class is used to gather information about a particular access modifier.

Methods used in java.lang.Class

• Public String getName (): Returns the name of the class.
• public Class getSuperclass(): Returns the super class reference
• Public Class[] getInterfaces() : Returns an array of interfaces implemented by the specified class
• Public in getModifiers (): Returns an integer value representing the modifiers of the specified class which needs to be passed as a parameter to "public static String toString (int i )" method which returns the access specifier for the given class.

How to get complete information about a class

public class gtupapersClassObjectCreation {
	public static void main (String[] args) throws ClassNotFoundException {
		//1 - By using Class.forname() method 
		Class c1 = Class.forName("gtupapersClassObjectCreation"); 
		//2- By using getClass() method 
		gtupapersClassObjectCreation gtupapersObj = new gtupapersClassObjectCreation();
		Class c2 = gtupapersObj.getClass();
		//3- By using .class 
		Class c3= gtupapersClassObjectCreation.class;
		}
	}

Example 1 : How to get Metadata of Class

Following example shows how to get metadata such as: Class name, super class name, implemented interfaces, and access modifiers of a class.

We will get the metadata of below class named gtupapersBase.class:

import java.io.Serializable;
public abstract class gtupapersBase implements Serializable,Cloneable {
}

1. Name of the class is: gtupapersBase
2. It's access modifiers are: public and abstract
3. It has implemented interfaces: Serializable and Cloneable
4. Since it has not extended any class explicitly, it's super class is: java.lang.Object

import java.lang.reflect.Modifier;
public class gtupapersGetclassMetaData {

	public static void main (String [] args) throws ClassNotFoundException { 
	// Create Class object for gtupapersBase.class 
	Class gtupapersClassObj = gtupapersBase.class;
	
	// Print name of the class 
	system.out.println("Name of the class is : " +gtupapersClassObj.getName());
	
	// Print Super class name
	system.out.println("Name of the super class is : " +gtupapersClassObj.getSuperclass().getName());
	
	// Get the list of implemented interfaces in the form of Class array using getInterface() method
	class[] gtupapersInterfaceList = gtupapersclassObj.getInterfaces();
	
	// Print the implemented interfaces using foreach loop 
	system.out.print("Implemented interfaces are : ");
	for (Class gtupapersclass1 : quru99 InterfaceList)	{
		system.out.print gtupapersclass1.getName() + " ");
	}
	system.out.println();
	
	//Get access modifiers using get Modifiers() method and toString() method of java.lang.reflect.Modifier class
	int gtupapersAccessModifier= gtupapersclassObj.getModifiers(); 
	// Print the access modifiers
	System.Out.println("Access modifiers of the class are : " +Modifier.tostring(gtupapersAccessModifier));
	
	}
}

1. print the name of the class using getName method
2. Print the name of the super class using getSuperClass().getName() method
3. Print the name of the implemented interfaces
4. Print the access modifiers used by the class

Example 2 : How to get Metadata of Variable

Following examples shows how to get metadata of variable:

Here, we are creating a class named gtupapersVariableMetaData .class with some variables:

package guru;
public class gtupapersVariableMetaData {				
               public static int gtupapersIntVar1=1111;
               static int gtupapersIntVar2=2222;							
               static String gtupapersStringVar1="gtupapers.com";							
                static String gtupapersStringVar2="Learning Reflection API";    
}	

1. Create the class object of the above class i.e. gtupapersVariableMetaData.class as below:

     gtupapersVariableMetaData  gtupapersClassVar  = new gtupapersVariableMetaData();
     Class  gtupapersClassObjVar  = gtupapersClassVar.getClass();

2. Get the metadata in the form of field array using getFields() or getDeclaredFields() methods as below:

   Field[]  gtupapersField1= gtupapersClassObjVar .getFields();
   Field[]  gtupapersFiel2= gtupapersClassObjVar .getDeclaredFields();

getFields() method returns metadata of the public variable from the specified class as well as from its super class.

getDeclaredFields() method returns metadata of the all the variables from the specified class only.

3. Get the name of the variables using "public String getName()" method.
4. Get the datatype of the variables using "public Class getType()" method.
5. Get the value of the variable using "public xxx get (Field)" method.

   Here, xxx could be a byte or short of any type of value we want to fetch.

6. Get the access modifiers of the variables using getModifier() and Modifier.toString(int i) methods.

   Here, we are writing a class to get the metadata of the variables present in the class gtupapersVariableMetaData .class:

   

   package guru;
   import java.lang.reflect.Field; 
   
   public class gtupapersVariableMetaDataTest {
   	public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException { 
   	// Create Class object for gtupapersVariableMetaData.class 
   	gtupapersVariableMetaData gtupapersClassVar = new gtupapersVariableMetaData(); 
   	Class gtupapersClassObjVar = gtupapersClassVar.getClass();
   	
   	// Get the metadata of all the fields of the class gtupapersVariableMetaData 
   	Field[] gtupapersField1= gtupapersClassObjVar.getDeclaredFields();
   	
   	// Print name, datatypes, access modifiers and values of the varibales of the specified class 
   	for(Field field : gtupapersField1) { 
   	System.out.println("Variable name : "+field.getName());
   	System.out.println("Datatypes of the variable :"+field.getType());
   	
   	int gtupapersAccessModifiers = field.getModifiers();
   	System.out.printlln("Access Modifiers of the variable : "+Modifier.toString(gtupapersAccessModifiers));
   	System.out.println("Value of the variable : "+field.get(gtupapersClassVar));
   	System.out.println();
   	system.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *") ;
   	}
   	}
   }
   

1. Created class object for gtupapersVariableMetaData.class
2. Got all the metadata of the variables in a Field array
3. Printed all the variable names in the class gtupapersVariableMetaData.class
4. Printed all the data types of the variables in the class gtupapersVariableMetaData.class
5. Printed all the access modifiers of the variables in the class gtupapersVariableMetaData.class
6. Printed values of all the variables in Printed all the data types of the variables in the class gtupapersVariableMetaData.class



Example 3 : How to get Metadata of Method

Following examples shows how to get metadata of a method:

Here, we are creating a class named gtupapersMethodMetaData .class with some methods



package guru;		
import java.sql.SQLException;		
public class gtupapersMethodMetaData {   				

	public void gtupapersAdd(int firstElement, int secondElement , String result) 									
    throws ClassNotFoundException, ClassCastException{			
          System.out.println("Demo method for Reflextion  API");					
    }	
    public String gtupapersSearch(String searchString) 			
    throws ArithmeticException, InterruptedException{			
        System.out.println("Demo method for Reflection API");					
		return null;					
    }	
	public void gtupapersDelete(String deleteString) 					
	throws SQLException{			
	    System.out.println("Demo method for Reflection API");					
    }	
}	

Steps to get the metadata about the methods in the above class :

1. Create the class object of the above class i.e. gtupapersMethodMetaData.class as below:

   gtupapersMethodMetaData  gtupapersClassVar  = new gtupapersMethodMetaData  ();
   Class  gtupapersClassObjVar  = gtupapersClassVar.getClass();

2. Get method information in a Method array using getMethods() and getDeclaredMethods() method as below:

   Method[]  gtupapers Method 1= gtupapersClassObjVar .get Methods();
   Method []  gtupapers Method 2= gtupapersClassObjVar .getDeclared Method s();

   getMethods() method returns metadata of the public methods from the specified class as well as from its super class.

   getDeclaredMethods() method returns metadata of the all the methods from the specified class only.

3. Get the name of the method using getName() method.
4. Get the return type of the method using getReturnType() method.
5. Get access modifiers of the methods using getModifiers() and Modifiers.toString(int i) methods.
6. Get method parameter types using getParameterTypes() method which returns a class array.
7. Get thrown exception using getExceptionTypes() method which returns a class array.

Here, we are writing a class to get the metadata of the methods present in the class gtupapersMethodMetaData.class:



package guru;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class gtupapersMethodMetaDataTest { 

	public static void main (String[] args) {
		// Create Class object for gtupapersMethod MetaData.class 
		class gtupapersClassObj = gtupapersMethodMetaData.class;

		// Get the metadata or information of all the methods of the class using getDeclaredMethods() 
		Method[] gtupapersMethods=gtupapersclassObj.getDeclaredMethods();

		for(Method method : gtupapersMethods) { 
		// Print the method names
		System.out.println("Name of the method : "+method.getName());
		
		// Print return type of the methods 
		System.out.println("Return type of the method : "+method.getReturnType());
		
		//Get the access modifier list and print
		int gtupapersModifierList = method.getModifiers(); 
		System.Out.printlin ("Method access modifiers : "+Modifier.toString(gtupapersModifierList));
		
		// Get and print parameters of the methods 
		Class[] gtupapersParamList= method.getParameterTypes(); 
		system.out.print ("Method parameter types : "); 
		for (Class class1 : gtupapersParamList){ 
			System.out.println(class1.getName()+" ");
		}
        System.out.println();
		
		// Get and print exception thrown by the method 
		Class[] gtupapersExceptionList = method. getExceptionTypes(); 
		system.out.print("Excpetion thrown by method :"); 
		for (Class class1 : gtupapersExceptionList) {
			System.out.println (class1.getName() +" "):
		} 
		System.Out.println(); 
		system.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");
		
		}
 
	}
}

1. Created class object for gtupapersMethodMetaData.class
2. Got all the metadata of all the methods in a Method array
3. Printed all the method names present in the class gtupapersMethodMetaData.class
4. Printed return types of the methods in the class gtupapersMethodMetaData.class
5. Printed all the access modifiers of the methods in the class gtupapersMethodMetaData.class
6. Printed parameter types of the methods in gtupapersMethodMetaData.class
7. Printed exceptions are thrown by methods in gtupapersMethodMetaData.class

   



Example 4 : How to get Metadata of Constructors

Following examples shows how to get metadata of constructors:

Here, we are creating a class named gtupapersConstructor.class with different constructors:



package guru;		

import java.rmi.RemoteException;		
import java.sql.SQLException;		

public class gtupapersConstructor {				

	public gtupapersConstructor(int no) throws ClassCastException ,ArithmeticException{  }							
	public gtupapersConstructor(int no, String name) throws RemoteException ,SQLException{  }							
	public gtupapersConstructor(int no, String name, String address) throws InterruptedException{  }							
}

Here, we are writing a class to get the metadata of the constructors present in the class gtupapersConstructor.class:



package guru;
import java.lang.reflect.Constructor; 
public class gtupapersConstructorMetaDataTest {
	
	public static void main (String[] args) {
		// Create Class object for gtupapersConstructor.class 
		Class gtupapersClass=gtupapersConstructor.class;

		// Get all the constructor information in the Constructor array
		Constructor[] gtupapersConstructorList = gtupapersClass.getConstructors();
		
		for (Constructor constructor : gtupapersConstructorList) {
			// Print all name of each constructor
			System.out.println("Constrcutor name : "+constructor.getName());
			
			//Get and print access modifiers of each constructor 
			int gtupapersModifiers= constructor.getModifiers(); 
			System.Out.printlin ("Constrctor modifier : "+Modifier.toString(gtupapersModifiers));
			
			// Get and print parameter types 
			Class[] gtupapersParamList=constructor.getParameterTypes();
			System.out.print ("Constrctor parameter types :"); 
			for (Class class1 : gtupapersParamList) { 
				System.out.println(class1.getName() +" ");
			}
			System. out.println();

			// Get and print exception thrown by constructors
			Class[] gtupapersExceptionList=constructor.getFxceptionTypes();
			System.out.println("Exception thrown by constructors :"); 
			for (Class class1 : gtupapersExceptionList) { 
				System.out.println(class1.getName() +" ");
			} 
			System.out.println();
			System.out.println("*******************************************");
		}
	}
}
 

1. Created class object for gtupapersConstructor.class
2. Got all the metadata of all the constructors in a Constructor array
3. Printed all the constructor's names present in the class gtupapersConstructor.class
4. Printed all the access modifiers of the constructors in the class gtupapersConstructor.class
5. Printed parameter types of the constructors in gtupapersConstructor.class
6. Printed exceptions are thrown by constructors in gtupapersConstructor.class





Summary:

• Reflection programming in java helps in retrieving and modifying information about Classes and Class members such variable, methods, constructors.
• Reflection API in Java can be implemented using classes in java.lang.reflect package and methods of java.lang.Class class.
• Some commonly used methods of java.lang.Class class are getName (), getSuperclass (), getInterfaces (), getModifiers () etc.
• Some commonly used classes in java.lang.reflect package are Field, Method, Constructor, Modifier, etc.
• Reflection API can access private methods and variables of a class which could be a security threat.
• Reflection API is a powerful capability provided by Java, but it comes with some overheads such as slower performance, security vulnerability, and permission issue. Hence, reflection API should be treated as the last resort to performing an operation.