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 <[e-mail]>
*/
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;
    }
}