Core Java

Java Reflection Tutorial

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.
Subscribe
Notify of
guest

This site uses Akismet to reduce spam. Learn how your comment data is processed.

3 Comments
Oldest
Newest Most Voted
Inline Feedbacks
View all comments
Rafael Risso
Rafael Risso
9 years ago

Great tuto. I could learn only reading. Thanks !

Java learner
Java learner
9 years ago

Nice post. Easy example to understand the concepts.

Albert Ng
Albert Ng
8 years ago

nice tutorial. It’s easy to understand the concept.

Back to top button