- Introduction
- Reflection of Java Classes
- Reflecting Constructors, Methods and Fields
- Advantages of Reflection
Introduction
Reflection in java is an Application Programming Interface (API) that is used for examining or modifying the behaviour of interfaces, methods, classes at runtime.
The java. lang. Class classes provide many different methods that can be used for metadata, examine and change the behaviour of interfaces, methods, classes at run time. The java. lang and java. lang.reflect package provide required classes for the reflection.
Were Reflection Application Programming Interface (API) is mainly used :
- IDE (Integrated Development Environment) like MyEclipse, Eclipse, NetBeans, etc.
- Debugger
- Test Tools, etc.
With the help of reflection we can invoke methods at runtime regardless of the access specifier used in them.
Fig : Reflection in Java
Reflection can be used to get the information about :
- Class : To know the name of the class to which that particular object belongs we can use the getClass() method.
- Constructors : To know the public constructors of the class to which that particular object belongs we can use the getConstructors() method.
- Methods : To know the public methods of the class to which that particular object belongs we can use the getMethods() method.
Check Out
- Palindrome in JAVA
- Methods in Java
- Constructors in Java
- 160+ Top Java Interview Questions and Answers in 2021
Reflection of Java Classes
- Using forName() method : This method is used to load the class dynamically and return the instance of the Class class. The forName() method cannot be used for primitive types.
Example :
class Animal {}
class Dog
{
public static void main ( String args[] )
{
Class a = Class.forName ( "Animal" );
System.out.println ( a.getName() );
}
}
Output :
Animal
- Using getClass() method : This method is used to return the instance of the Class class. The getClass() method is used if you know the tyoe and it can be also used with primitive types.
Example :
class Animal {}
class Dog
{
void printName ( Object obj )
{
Class b = obj.getClass();
System.out.println ( b.getName() );
}
public static void main ( String args[] )
{
Animal s = new Animal();
Dog t = new Dog ();
t.printName ( s );
}
}
Output :
Animal
- Using .class extension : In java, if the type is available but there is no instance then we can obtain the Class by appending “.class” to the name of the type. This method is also useful for primitive data types.
Example :
class Dog
{
public static void main ( String args[] )
{
Class c1 = boolean.class;
System.out.println ( c1.getName() );
Class c2 = Dog.class;
System.out.println ( c2.getName() );
} }
Output :
Boolean
Animal
Example of Java Class Reflection
In this example, there is a superclass “Animal” and a subclass “Cat”. In this, we are trying to inspect the class “Cat”.
import java.lang.Class;
import java.lang.reflect.*;
class Animal {
}
// put this class in different Cat.java file
public class Cat extends Animal
{
public void display ()
{
System.out.println ( "It’s a Cat." );
}
}
// put this in Main.java file
class Main
{
public static void main ( String[] args )
{
try {
// creating an object of Cat
Cat a1 = new Cat();
// creating an object of Class
// by using getClass()
Class obj = a1.getClass();
// get the name of the class
String name = obj.getName();
System.out.println ( "Name : " + name );
// get the access modifier of the class
int modifier = obj.getModifiers();
// converting the access modifier into the string
String mod = Modifier.toString ( modifier );
System.out.println ( "Modifier : " + mod );
// get the superclass of Cat
Class superClass = obj.getSuperclass();
System.out.println ( "Superclass : " + superClass.getName() );
}
catch ( Exception e )
{
e.printStackTrace();
}
}
}
Output :
Name : Cat
Modifier : public
Superclass : Animal
In the above example, the statement : Class obj = a1.getClass();
In this statement we are trying to create an object “obj” of “Class” using the method “getClass()”. With the help of the object, the different methods of “Class” can be called.
- obj.getName() : This method is used to return the name of the class.
- obj.getModifiers() : This method is used to return the access modifier of the class.
- obj.getSuperclass() : This method is used to return the superclass of the class.
Reflecting Constructors, Methods and Fields
In java, we can inspect the constructors of an object’s class, methods and fields by using java reflection. This can be done by using the package java.lang.reflect which provides classes that can be used for manipulating the class members.
- Constructor Class It is used to give information about constructors in the class.
- Method Class : It is used to give information about methods in the class.
- Field Class : It is used to give information about fields in the class.
- Reflection of Constructors in Java
In Java, we can inspect various constructors using different methods provided by the Constructor class. It can be easily done by the java.lang.reflect.Constructor class.
Example :
In this example, there are two constructors, each having the class name “Bird”.
import java.lang.Class;
import java.lang.reflect.*;
class Bird
{
// defining public constructor without parameter
public Bird () {
}
// defining private constructor with a single parameter
private Bird ( int age ) {
}
}
class Main
{
public static void main(String[] args)
{
try
{
// create an object of Bird
Bird a1 = new Bird ();
// create an object of Class
// by using getClass()
Class obj = a1.getClass();
// get all constructors of Bird
Constructor[] constructors = obj.getDeclaredConstructors();
for ( Constructor b : constructors )
{
// get the name of constructors
System.out.println ( "Constructor Name : " + b.getName() );
// getting the access modifier of constructors
// converting it into string form
int modifier = b.getModifiers();
String mod = Modifier.toString ( modifier );
System.out.println ( "Modifier : " + b.getModifiers() );
// getting the number of parameters in constructors
System.out.println ( "Parameters : " + b.getParameterCount() );
System.out.println ("");
}
}
catch ( Exception e )
{
e.printStackTrace ();
}
}
}
Output :
Constructor Name : Bird
Modifier : public
Parameters : 0
Constructor Name : Bird
Modifier : private
Parameters : 1
In the above example the statement : Constructor[] constructors = obj.getDeclaredConstructors(); we can access all the constructor in the class Bird and assign them in an array of constructors of Constructor type.
To fetch the information about the constructor we are using object ‘b’.
- b.getName() : It returns the name of the constructor.
- b.getModifiers() : It is used to return the access modifier of the constructor.
- b.getParameterCount() : It is used to return the number of parameters passed in each constructor.
- Reflection of Methods in Java
To get the information about different methods present in the class, we can use the Method Class that provides various methods.
Example :
In this example, we are trying to get all the information about the method present in the “Bird” class.
import java.lang.Class;
import java.lang.reflect.*;
class Bird
{
// methods of the class
public void display() {
System.out.println ( "It’s a Bird." );
}
private void type() {
System.out.println ( “sparrow" );
}
}
class Main
{
public static void main ( String args[] )
{
try
{
// creating an object of Bird
Bird d1 = new Bird ();
// creating an object of Class by using getClass()
Class obj = d1.getClass();
// using object of Class to get all the declared methods of Bird
Method[] methods = obj.getDeclaredMethods();
// create an object of the Method class
for ( Method c : methods )
{
// getting the names of methods
System.out.println ( "Method Name : " + c.getName() );
// getting the access modifier of methods
int modifier = m.getModifiers();
System.out.println( "Modifier : " + Modifier.toString(modifier) );
// getting the return types of method
System.out.println ( "Return Type : " + c.getReturnType() );
System.out.println (" ");
}
}
catch ( Exception e ) {
e.printStackTrace();
}
}
}
Output :
Method Name : display
Modifier : public
Return Type : void
Method Name : type
Modifier : private
Return Type : void
The expression Method[] methods = obj.getDeclaredMethods(); returns all the methods present inside the class.
To fetch the information about the constructor we are using object ‘c’.
- c.getName() : It returns the name of the method.
- c.getModifiers() : It is used to return the access modifier of the method.
- c.getReturnType() : It is used to return the type of the method.
- Reflection of Fields in Java
Using the method of Field Class we can also inspect and modify the various field of the class.
Example :
In this example, we have a class named “Bird”, that has a public field name “type”.
import java.lang.Class;
import java.lang.reflect.*;
class Bird
{
public String type;
}
class Main
{
public static void main ( String args[] )
{
try
{
// creating an object of Dog
Bird d1 = new Bird ();
// creating an object of Class by using getClass()
Class obj = d1.getClass();
// accessing and setting the type field
Field field1 = obj.getField ( "type" );
field1.set ( d1, " sparrow " );
// getting the value of the field type
String typeValue = (String) field1.get(d1);
System.out.println ( "Value : " + typeValue );
// getting the access modifier of the field type
int mod = field1.getModifiers();
// convert the modifier to String form
String modifier1 = Modifier.toString (mod);
System.out.println ( "Modifier : " + modifier1 );
System.out.println (" ");
}
catch (Exception e) {
e.printStackTrace();
}
}
}
Output :
Value : sparrow
Modifier : public
The expression Field field1 = obj.getField ( “type” ); is accessing the public field of the “Bird” class and assigning the value to the object “field1” of the “Field” class.
To fetch the information about the constructor we are using object ‘field1’.
- field1.set () : It is used to set the value of the field.
- field1.getModifiers() : It is used to return the value of the field in the form of an integer.
- field1.get () : It is used to return the value of the field.
Advantages of Reflection
In Java, reflection is helpful because it helps in dynamic retrieval of information of class and data structure by name. It also allows their manipulation within an executing program. This is an extremely powerful feature that is not available in other conventional languages like Pascal, C, Fortran or C++.
Java Reflection API helps to inspect interfaces, methods, classes at runtime without any prior information of their internals by compile time.