java 反射的学习demo

package dxm.com.Reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Stack;

import org.junit.Test;

import dxm.com.test.TestEncode;

/**
* 测试反射机制
*
* @author bsat
*
*/
public class TestReflect {

public static void main(String[] args) {

}

@Test
public void whatFanXing() {
try {
ArrayList a1 = new ArrayList();
ArrayList<String> a2 = new ArrayList<String>();
Class c2 = a1.getClass();
Class c1 = a2.getClass();
System.out.println(c1 == c2);// true
System.out.println(c1.getName());
System.out.println(c2.getName());
Method m = c1.getMethod("add", Object.class);
m.invoke(a2, 30);
m.invoke(a2, 40);
m.invoke(a2, 50);
System.out.println(a2);
} catch (Exception e) {
e.printStackTrace();
}
}


//测试获取到类类型的三种方式 类的类类型相等
@Test
public void testReflect() {
try {

Class reflect = TestReflect.class;
Class reflect2 = reflect.getClass();
Class reflect3 = Class.forName("dxm.com.test.TestReflect");
System.out.println(reflect == reflect2);
System.out.println(reflect3 == reflect2);
System.out.println(reflect);
System.out.println(reflect2);
System.out.println(reflect3 );
} catch (Exception e) {
e.printStackTrace();
}

}
@Test
public void test2() {
try {
Class list = Class.forName("java.util.ArrayList");
//通过类类型创建对象
ArrayList<String> strs =(ArrayList<String>)list.newInstance();
strs.add("dxm");
System.out.println(strs.get(0));
strs.set(0, "ddd");

Class[] ps = new Class[1];
ps[0] = Integer.TYPE;

//获取到构造函数
Constructor cons = list.getConstructor(ps);

Integer[] os = { 3 };
//构造函数new一个实例 newInstance
ArrayList t = (ArrayList) cons.newInstance(os);
t.add(1);
t.add("dxm");
t.add(new TestEncode());
System.out.println(t.size() + "=" + t.get(0));// 2
for (Object object : t) {
System.out.println(object);
}


Class[] ps3 = new Class[1];
ps3[0] = Object.class;
//成员方法 getDeclaredMethod
Method method1 = list.getDeclaredMethod("add", ps3);
method1.invoke(t, 2);// list.add(2)??
method1.invoke(t, "test");

Class[] ps2 = new Class[1];
ps2[0] = Collection.class;
Constructor con2 = list.getConstructor(ps2);
//构造函数获取一个实例
ArrayList t2 = (ArrayList)con2.newInstance(t);

System.out.println(t2);

} catch (Exception e) {
e.printStackTrace();
}
}

//测试获取成员方法 修饰符，名称，参数，
@Test
public void test1() {
try {
Class<Stack> c = (Class<Stack>) Class.forName("java.util.Stack");
//获取成员方法
Method[] ms = c.getDeclaredMethods();
//判断是否是stack类型
System.out.println(c.isInstance(new Stack()));

for (Method m : ms) {
System.out.print(m.getModifiers() + " " + m.getReturnType() + " " + m.getName());
// 获得方法的参数类
Class[] cc = m.getParameterTypes();
for (Class type : cc) {
System.out.print("(" + type.getName()+")");
}
System.out.println();
// 获得异常类
Class[] exs = m.getExceptionTypes();
for (Class ex : exs) {
System.out.println("getExceptionTypes======" + ex.getName());
}
}

System.out.println("*****************************");



} catch (Exception e) {
e.printStackTrace();
}

}

@Test //测试成员变量
public void TestFeild() {
Class<Stack> c;
try {
c = (Class<Stack>) Class.forName("java.util.Stack");
// 获得域
Field [] fields=c.getFields();
Field [] declaredfields=c.getDeclaredFields();
for(Field f:fields){
System.out.println("Field"+f.getName());
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

//测试获取构造方法
@Test
public void printConstructor() {
Class<Stack> obj;
try {
obj = (Class<Stack>) Class.forName("java.util.Stack");
Class c = obj.getClass();
// 获得class构造器方法
Constructor<Stack>[] con = (Constructor<Stack>[]) c.getDeclaredConstructors();
for (Constructor cd : con) {
System.out.println("getDeclaredConstructors" + cd);
}
System.out.println("*****************************");
// 获得Stack构造器方法
Constructor<Stack>[] stackConstructor = (Constructor<Stack>[]) obj.getDeclaredConstructors();
for (Constructor cd : stackConstructor) {
System.out.println("getDeclaredConstructors" + cd);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

}
}