java reflection

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

自己一个简单的应用:(实践过程中的一个错误,利用带参数构造函数获取实例的时候,抛出NoSuchMethodException,原因是我的购造函数里面用的是int，是一个类型，不是一个对象，改成Integer就没问题。)

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package net.kingbit.javaLearn;

import java.awt.Button;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Hashtable;

/**
*
* @author yankang <yankang.nd@163.com>
*/
public class ReflectionTest {
public static void main(String[] args) throws Exception {


Class cls=Class.forName("net.kingbit.javaLearn.TestBean");
// TestBean ts=(TestBean) cls.newInstance();
// System.out.println("cls name:"+cls.getName());
// Method[] methods=cls.getMethods();
// for(int i=0;i<methods.length;i++)
// {
//
// if(methods[i].getName().equalsIgnoreCase("setS"))
// {
// System.out.println("methods["+i+"]: "+methods[i].getName());
// methods[i].invoke(ts,new Object[]{"oo"});
// System.out.println("ts s:"+ts.getS());
//
// }
// if(methods[i].getName().equalsIgnoreCase("getS"))
// {
// System.out.println("methods["+i+"]: "+methods[i].getName());
// System.out.println("get s: "+methods[i].invoke(ts));
//
//
// }
// }
//
// Field[] fiels=cls.getDeclaredFields();//这个方法可以获取私有成员属性
// System.out.println("fiels length: "+fiels.length);
// for(int i=0;i<fiels.length;i++)
// {
// System.out.println("fiels["+i+"]: "+fiels[i].getName());
// }
// Field field=fiels[0];

//
// TestBean tb=new TestBean();
// System.out.println("className:"+tb.getClass().getName());
// ReflectionTest rt=new ReflectionTest();
// rt.getProperty(tb, "str");
int i=4;
String s="yk";
Object[] parameters=new Object[]{s,i};
Class[] classTypes=new Class[parameters.length];
for(int l=0;l<parameters.length;l++)
{
classTypes[l]=parameters[l].getClass();
System.out.println("classTypes["+l+"] :"+classTypes[l]);
}
Constructor con=cls.getConstructor(classTypes);
TestBean tb1=(TestBean) con.newInstance(parameters);
System.out.println("tb1 s:"+tb1.getS());
System.out.println("tb1 i: "+tb1.getI());
}

public Object getProperty(Object ownerClass,String fieldName) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException
{
Class cls=ownerClass.getClass();

Field[] fields=cls.getDeclaredFields();
Field field=null;
for(int i=0;i<fields.length;i++)
{
if(fields[i].getName().equalsIgnoreCase(fieldName))
{
System.out.println("fiels["+i+"]: "+fields[i].getName());
field=fields[i];
break;
}

}
Object property=field.get(ownerClass);
System.out.println("property :"+property);
return property;
}

}
class TestBean{
private String s;
private Integer i;


//public TestBean()
//{}
public TestBean(String s,Integer i)
{
this.s=s;
this.i=i;
}
public Integer getI() {
return i;
}

public void setI(Integer i) {
this.i = i;
}

public String getS() {
return s;
}

public void setS(String s) {
this.s = s;
}
}