java 反射机制的理解

这段时间工作中用到的反射机制较多，以前理解总是表面上的（嘿嘿，当然不是现在有多深），最开始接触的就是连接数据库时的Class.formName("com.microsoft....")；当时只对用，并不理解。

现在看来，反射其实是在程序运行时，我们动态获取类的信息，并可以改变其内部信息, 包括方法、属性等，并不是写代码时就把要用到的类写死（用到哪个类写哪个类），而是用一个通用符代替，等调用时再动态传入类的名称，再获取传入类的信息。

就我拙见，使用反射机制，其一可以提高代码重用性，二是提高代码质量。

 

 

1.       class 生成对应的 Class object 的几种方法

l  getClass()

l  Class.forName()

l  .class

l  运用 Classes 的 TYPE 语法

 

2.       运行时生成 instances

l  针对不带参数的构造方法 ，调用 Class 的 newInstances() 方法

l  带参数的构造方法：

例：

Class c=Class.forName(“类全名”);

// 生成 Class 类型数组（构造方法接收两个参数）

Class[] types=new Class[]{double.class,int.class};

// 返回对应接收两个参数的构造方法

Constructor ctor=c.getConstructor(types);

                   // 生成对象的实例

                   Object[] arg=new Object[]{3.121,125};

                   Object obj=ctor.newInstance(arg);

                  

3.       返回运行时的 methods

 

           //一测试方法

public String func(String s,Hashtable ht){

         System.out.println(“func invoked”);

         Return s;

}

 

Public static void main(String args[]){

      Class c=Class.forName(“类全名”);

// 生成 Class 类型数组（构造方法接收两个参数）

Class[] types=new Class[2];

Types[0]=Class.forName(“java.lang.String”);

Types[1]=Class.forName(“java.util.Hashtable”);

// 获取 func 方法

Method m=c.getMethod(func,types);

 

Test obj=new Test();

 

Object[] args=new Object[]{new String(“Hello world”),null};

 //执行方法

Object r=m.invoke(obj,args);

        

}

 

 

在实际开发中，可能很多人用过，动态获取集合类中对象的值。集合类中不同集合类中包含不同的对象，那么我们不是为每个集合类都写个迭代方法，而是使用反射机制，写一通用方法，无论传来是哪个集合类都能获取其中对象的值，下面是一个简单例子

 

    /**
     *动态处理集合中实体类的值
     *
     * @param it
     *            数据集合
     * @param pattern
     *            日期样式
     * @return 拼接后的实体类属性值
     */
    @SuppressWarnings("unchecked")
    private StringBuffer dynamic(Iterator<T> it, String pattern) {
        StringBuffer sb = new StringBuffer();
        while (it.hasNext()) {
            try {
                T t = (T) it.next();
                Class cls = t.getClass();

                //得到实体类中所有的属性字段
                Field[] fields = cls.getDeclaredFields();
                for (int i = 0; i < fields.length; i++) {
                    // 得到属性名
                    String fieldName = fields[i].getName();

                    //属性对应的get方法名
                    String methodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                    //获得属性对应方法
                    Method method = cls.getMethod(methodName, new Class[] {});

                    //得到属性值
                    Object value = method.invoke(t, new Object[] {});

                    //格式化日期
                    if (value instanceof Date) {
                        Date date = (Date) value;
                        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
                        value = sdf.format(date);
                        log.info(value);
                    }
                    // 追加字符串
                    sb.append(value.toString() + " ");
                    log.info(sb.toString());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            sb.append("/r/n");
        }
        return sb;
    }

 

 

这样处理，看起来比普通写法要复杂，但只需一个类就可以解决，其实是简化了代码。

一点小总结，希望和大家一起学习！