java百问总结（二）

1.Java Reflection Tutorial

    ①.What is reflection?

            Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java Virtual Machine. This concept is often mixed with introspection. The following are their definitions from Wiki(维基百科)：

|--Introspection is the ability of a program to examine the type or properties of an object at runtime.

|--Reflection is the ability of a program to examine and modify the structure and behavior of an object at runtime.

In Java, reflection is more about introspection, because you can not change structure of an object. There are some APIs to change accessibilities of methods and fields , but not structure.

    ②.Why do we need reflection?

  Reflection enables us to:

|-- 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

                |-- Change accessibility flag of Constructor, Method and Field

                |--Reflection is the common approach of famework.

|--for example, JUnit use reflection to look through methods tagged with the @Test annotation, and then call those methods when running the unit test.

                        |--for web frameworks, product developers define their own implementation of interfaces and classes and put is in the cofiguration files. Using reflection, it can quickly dynamically initialize the classes required.

<!-- Spring uses bean configuration such as:  -->
<bean id="someID" class="com.programcreek.Foo">
    <property name="someField" value="someValue" />
</bean>

           when the Spring context processes this <bean> element, it will use Class.forName(Spring) with the argument " com.programcreek.Foo" to instantiate the Class. It will then again use reflection to get the appropriate setter for the <property> element and set its value to specified value.

    ③.How to use reflection?

|-- Get class name form object.

package reflectionToDemo;
import java.lang.reflect.Method;
 
public class ReflectionHelloWorld {
	public static void main(String[] args){
		Foo f = new Foo();
		System.out.println(f.getClass().getName());	//reflectionToDemo.Foo		
	}
}
 
class Foo {
	public void print() {
		System.out.println("abc");
	}
}

|-- Invoke method on unknown object

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);  //abc
		} catch (Exception e) {
			e.printStackTrace();
		}			
	}
}
 
class Foo {
	public void print() {
		System.out.println("abc");
	}
}

|-- Cteate object form 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();  // In Class, just newInstance() invoke null paratmeter constructor
		} catch (Exception e) {
			e.printStackTrace();
		}	
 
		f.print();
	}
}
 
class Foo {
	public void print() {
		System.out.println("abc");
	}
}

|-- 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();  //null
		f2.print();  //abc
	}
}
 
class Foo {
	String s; 
 
	public Foo(){}
 
	public Foo(String s){
		this.s=s;
	}
 
	public void print() {
		System.out.println(s);
	}
}

|-- Change array size through 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|--