Java Reflection Tutorial

ProgramCreekSeptember 25th, 2013Last Updated: September 27th, 2013

3 72 3 minutes read

In this tutorial, I mainly write some examples to introduce what Java reflection can do. Hopefully, it can give you an overview of this concept. Please leave your comment for suggestions.

What is Reflection?

In brief, reflection is the ability of a program to examine and modify the structure and behavior of an object at runtime.

This concept is sometimes mixed with introspection. Introspection (Type introspection) is the ability of a program to examine the type or properties of an object at runtime. Therefore, it is a subset of reflection. Some languages support introspection, but do not support reflection, e.g., C++.

Why do we need reflection?

Reflection enables us to do the following:

Examine an object’s class at runtime
Construct an object for a class at runtime
Examine a class’s field and method at runtime
Invoke any method of an object at runtime

For example, JUnit use reflection to look through methods tagged with the @Test annotation, and then call those methods when running the unit test. (Here is a set of examples of how to use JUnit.)

Example 1: Get class name from object

package myreflection;
import java.lang.reflect.Method;

public class ReflectionHelloWorld {
	public static void main(String[] args){
		Foo f = new Foo();
		System.out.println(f.getClass().getName());			
	}
}

class Foo {
	public void print() {
		System.out.println("abc");
	}
}

Output:

myreflection.Foo

Example 2: Invoke method on unknown object

For the code example below, image the types of an object is unknown. By using reflection, the code can use the object and find out if the object has a method called “print” and then call it.

package myreflection;
import java.lang.reflect.Method;

public class ReflectionHelloWorld {
	public static void main(String[] args){
		Foo f = new Foo();

		Method method;
		try {
			method = f.getClass().getMethod("print", new Class<?>[0]);
			method.invoke(f);
		} catch (Exception e) {
			e.printStackTrace();
		}			
	}
}

class Foo {
	public void print() {
		System.out.println("abc");
	}
}

abc

Example 3: Create object from Class instance

package myreflection;

public class ReflectionHelloWorld {
	public static void main(String[] args){
		//create instance of "Class"
		Class<?> c = null;
		try{
			c=Class.forName("myreflection.Foo");
		}catch(Exception e){
			e.printStackTrace();
		}

		//create instance of "Foo"
		Foo f = null;

		try {
			f = (Foo) c.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}	

		f.print();
	}
}

class Foo {
	public void print() {
		System.out.println("abc");
	}
}

Example 4: Get constructor and create instance

package myreflection;

import java.lang.reflect.Constructor;

public class ReflectionHelloWorld {
	public static void main(String[] args){
		//create instance of "Class"
		Class<?> c = null;
		try{
			c=Class.forName("myreflection.Foo");
		}catch(Exception e){
			e.printStackTrace();
		}

		//create instance of "Foo"
		Foo f1 = null;
		Foo f2 = null;

		//get all constructors
		Constructor<?> cons[] = c.getConstructors();

		try {
			f1 = (Foo) cons[0].newInstance();
			f2 = (Foo) cons[1].newInstance("abc");
		} catch (Exception e) {
			e.printStackTrace();
		}	

		f1.print();
		f2.print();
	}
}

class Foo {
	String s; 

	public Foo(){}

	public Foo(String s){
		this.s=s;
	}

	public void print() {
		System.out.println(s);
	}
}

Output:

null

abc

In addition, you can use Class instance to get implemented interfaces, super class, declared field, etc.

Example 5: Change array size though reflection

package myreflection;

import java.lang.reflect.Array;

public class ReflectionHelloWorld {
	public static void main(String[] args) {
		int[] intArray = { 1, 2, 3, 4, 5 };
		int[] newIntArray = (int[]) changeArraySize(intArray, 10);
		print(newIntArray);

		String[] atr = { "a", "b", "c", "d", "e" };
		String[] str1 = (String[]) changeArraySize(atr, 10);
		print(str1);
	}

	// change array size
	public static Object changeArraySize(Object obj, int len) {
		Class<?> arr = obj.getClass().getComponentType();
		Object newArray = Array.newInstance(arr, len);

		//do array copy
		int co = Array.getLength(obj);
		System.arraycopy(obj, 0, newArray, 0, co);
		return newArray;
	}

	// print
	public static void print(Object obj) {
		Class<?> c = obj.getClass();
		if (!c.isArray()) {
			return;
		}

		System.out.println("\nArray length: " + Array.getLength(obj));

		for (int i = 0; i < Array.getLength(obj); i++) {
			System.out.print(Array.get(obj, i) + " ");
		}
	}
}

Output:

Array length: 10
1 2 3 4 5 0 0 0 0 0
Array length: 10
a b c d e null null null null null

Summary

The above code examples shows a very small set of functions provided by Java reflection. Reading those examples may only give you a taste of Java reflection, you may want to Read more information on Oracle website.

Reference: Java Reflection Tutorial from our JCG partner Xiaoran Wang at the Programcreek blog.