java 的反射机制是使其具有动态特性的非常关键的一种机制，也是在javabean 中广泛应用的一种特性。
运用javabean 的最常见的问题是：根据指定的类名，类字段名和所对应的数据，得到该类的实例，下面的一个例子演示了这一实现。
-|base.java //抽象基类
 |son1.java //基类扩展1
 |son2.java //基类扩展2
 |util.java 
/**
 * @author metaphy
 * create 2005-4-14 9:06:56
 * 说明：
 */
（1）base.java 抽象基类只是一个定义
public abstract class base {
}
（2）son1.java /son2.java 是已经实现的javabean
public class son1 extends base{
    private int id ;
    private string name ;
    
    public int getid() {
        return id;
    }
    public void setid(int id) {
        this.id = id;
    }
    public string getname() {
        return name;
    }
    public void setname(string name) {
        this.name = name;
    }
    
    public void son1method(string s){
        system.out.println(s) ; 
    }
}
（3）
public class son2 extends base{
    private int id;
    private double salary;
    
    public int getid() {
        return id;
    }
    public void setid(int id) {
        this.id = id;
    }
    public double getsalary() {
        return salary;
    }
    public void setsalary(double salary) {
        this.salary = salary;
    }
}
（4）util.java 演示了如何根据指定的类名，类字段名和所对应的数据，得到一个类的实例
import java.lang.reflect.method;
public class util {
    //此方法的最大好处是没有类名son1,son2 可以通过参数来指定，程序里面根本不用出现
    public static base convertstr2servicebean(string beanname,string fieldsetter,string paravalue){
        base base = null ; 
        try {
            class cls = class.forname(beanname) ;
            base = (base)cls.newinstance() ;
            class[] paratypes = new class[]{string.class };
            method method = cls.getmethod(fieldsetter, paratypes) ;
            string[] paravalues = new string[]{paravalue} ;
            method.invoke(base, paravalues) ;
        } catch (throwable e) {
            system.err.println(e);
        }
        return base ;
    }
    
    
    public static void main(string[] args){
        son1 son1 =(son1) util.convertstr2servicebean("trying.reflect.son1","setname","wang da sha");
        system.out.println("son1.getname() :"+son1.getname())  ;
    }
}
//调用结果：
//son1.getname() :wang da sha

谢谢！希望能给大家一点启发！
－－－－－－－－－－－－－－－－－－－－
附：
//下面这篇文档来源于internet，作者不详
reflection 是 java 程序开发语言的特征之一，它允许运行中的 java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。例如，使用它能获得 java 类中各成员的名称并显示出来。
java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，pascal、c 或者 c++ 中就没有办法在程序中获得函数定义相关的信息。
javabean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 java 组件(类) 的属性。
1. 一个简单的例子
考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。
import java.lang.reflect.*;
public class dumpmethods {
   public static void main(string args[]) {
       try {
           class c = class.forname(args[0]);
           method m[] = c.getdeclaredmethods();
           for (int i = 0; i < m.length; i++)
               system.out.println(m[i].tostring());
       } catch (throwable e) {
           system.err.println(e);
       }
   }
}
按如下语句执行：
java dumpmethods java.util.stack
它的结果输出为：
public java.lang.object java.util.stack.push(java.lang.object)
public synchronized java.lang.object java.util.stack.pop()
public synchronized java.lang.object java.util.stack.peek()
public boolean java.util.stack.empty()
public synchronized int java.util.stack.search(java.lang.object)
这样就列出了java.util.stack 类的各方法名以及它们的限制符和返回类型。
这个程序使用 class.forn