在说 Reflection 之前，我感觉还是先对静态语言和动态语言有一个了解比较好，下面来看一下一些资料：

1 、 http://cavingdeep.cnblogs.com/archive/2005/08/03/206374.html 说明了什么是静态的，什么是动态的，总结一下就是：

动态语言，准确地说，是指程序在运行时可以改变其结构：新的函数可以被引进，已有的函数可以被删除等在结构上的变化。比如众所周知的 ECMAScript(JavaScript) 便是一个动态语言。除此之外如 Ruby 、 Python 等也都属于动态语言，而 C 、 C++ 等语言则不属于动态语言。（通俗的说法就是：静态的是事先进行规划，考虑到后面需要做的一些事情；而动态的是管他后面会是怎么样呢，先开始再说，要的就是速度，呵呵，这有点和我们生活中做人做事的方式有些相似 ~ ）

2 、 http://www.javaeye.com/topic/35763 对动态语言和静态语言的一个比较新颖的认识，主要从内存的分配和利用情况来说的，也就是说：动态语言不事先分配内存，到用的时候再说，而静态语言会先分配内存，并进行检查，大了放不下啊，呵呵

3 、 http://robbin.javaeye.com/blog/33971 讨论了静态语言和动态语言在开发方面的优势和使用情况等，还在讨论中，不好定论。

注：一般来说，静态语言比较容易调试，而动态语言不太容易调试，因为变数太多，呵呵。

由于静态语言不够灵活，再加上现在随着系统的扩大，以及框架建立的需要，所以说静态语言也需要越来越多的动态的特性，而作为现在首当其冲的 Java 语言，也要通过反射，在执行期间做一些动态的调整以适应多变的需求。

在 Reflection 机制中，最重要的一个类就是 Class 类，这里面记录了我们所定义的 class 中的一些信息，我们可以通过其获得我们定义的 变量、方法、构造函数以及父类等等，并且可以动态的对其进行调用，这样就可以在某些时候将我们没有事先设计的代码在运行期间执行，而不对原有的程序进行改变。

具体的使用样例可以参考： Core Java 2 第六、七版，或者侯捷的 java Reflection 教程（下载地址：http://www.blogjava.net/Files/wqhtomcat/Java反射机制-javatwo-2004-reflection.rar）。

2、  由于 Java 范型的实现采用的是 Erasure 方式，仅仅是在编译期进行检查，所以在运行过程中我们就不能进行范型的实例化，因为我们不知道到底要实例化什么类型的对象，与原来我们手动进行强制类型转换的一样，我们如果知道我们能够转换成什么对象，那么我们就可以将我们知道的类型的信息传递过去，也就是吧 XX.class 传递过去，这样 jvm 就知道我们要实例化什么样的对象了。
 

3、  原来 Class<T> 表示的是一个范型的 Class 类啊，为什么搞的像 List<T> 样式的范型声明呢？搞得我迷糊了好长时间，一致以为是一个类似容器的东西呢，这个语法感觉到有些奇怪，见笑了：），这个类一般用来接受 XX.class 返回的对象。

4、  要想在 java 中范型用得爽，还得配合使用反射才行啊。由于 Java 采用了擦拭法进行范型的支持，所以我们依旧不能在运行期获取到具体的类型的信息，而至能够在我们进行设计的时候对其类型信息进行指定，那么我们指定的类型的信息就可以存放在编译后生成的 class 文件中了，我们可以通过反射来获取到具体的存放的信息，要获取到动态的传入的信息就不行了。

如下所示：

定义一个超类：
 

1 public   class  SuperClass < T  extends  Number >   { 
2 }  
3

再定义一个子类：

import  java.lang.reflect.ParameterizedType; 

  

public   class  MyTest < T >   extends  SuperClass < Integer >   { 

     private  Class clazz  =   null  ; 

     public   void  printClassInf() { 

       System. out .println(  this  .getClass().getName()); 

       System. out .println(  this  .getClass().getTypeParameters()[ 0 ].getName()); 

       System. out .println(  this  .getClass().getSuperclass().getTypeParameters()[ 0 ].getName()); 

       clazz  = (Class) ((ParameterizedType)  this  .getClass().getGenericSuperclass()).getActualTypeArguments()[ 0 ]; 

       String out  =  clazz .getName(); 

       System. out .println(out); 

    }  

     public   static   void  main(String[] args) { 

       MyTest test  =   new  MyTest < Shit > (); 

       test.printClassInf(); 

    }  

}  

那么我们只能够获得我们实现定义好的要传入到 SuperClass 类中的 Integer 类型的范型信息，而不能得到我们在程序中传入的 Shit 类的类型信息，因为 java 范型的信息不记录的实例中，仅仅在类中进行了记录（这点感觉 java 的范型还不够成熟，可能因为要向后兼容等原因吧）。

参考资料：

http://www.duduwolf.com/wiki/2006/51.html

http://calvin.javaeye.com/blog/33139    白衣的 SpringSide 中对范型使用的说明

http://www-128.ibm.com/developerworks/cn/java/j-jtp01255.html   Java 理论和实践关于范型的讲解

http://www.nirvanastudio.org/java/dont-repeat-the-dao.html   范型实现可重用 DAO 的文章

http://gceclub.sun.com.cn/Java_Docs/html/zh_CN/api/java/lang/reflect/ParameterizedType.html#getActualTypeArguments()

http://buaawhl.javaeye.com/blog/22020   范型的实现原理，讲的比较清楚

在进行 Log4J 的使用过程中，我对下面的两个问题比较敏感：

1、  Log4J 是如何进行工作的？

这是在 Log4J 项目中对 Log4J 的介绍中的一段话

With log4j it is possible to enable logging at runtime without modifying the application binary. The log4j package is designed so that these statements can remain in shipped code without incurring a heavy performance cost. Logging behavior can be controlled by editing a configuration file, without touching the application binary.

对于 Log4J 的具体如何进行工作的原理，在 javaeye 上 buaawhl 给出了一个解释：

http://buaawhl.javaeye.com/blog/6450

总结一下就是利用 JDK 提供的 new Throwable().getStackTrace() 方法返回当前运行栈的结构层次，然后对返回的调用栈的信息进行分析，找到调用该类的类的名称。（也就是Log4J自己说的Runtime期间实现Log）

由于在 Log4J 中只存在一个根 Logger ，并且 Logger 之间存在继承的关系，并且我们可以在配置文件（ log4J.proerties 或者 XML ）中进行配置，可以初始化指定的 Logger ，并且对指定的 Logger 进行一些相关的配置，如设置如何进行输出，以及如何将输出进行布局。并且由于 Logger 之间会存在继承的关系（会找一个最近的 Logger 进行继承，如果没有就以根 Logger 作为父类，共享父类的配置信息），以及父子类之间初始化没有先后的顺序，所以我们可以在配置文件中，对各个程序以及不同的包中使用到 Log4j 的 Log 纪录方式进行配置。

如果在同一个 APPLICATION 对相同名称的 Logger 进行调用，那么只会返回一个 Logger 实例。

2、  Log4J 会不会对系统的性能造成大的影响？

这是对 Log4J 性能的一些描述，看来还是不错的，呵呵，在调整一下 Log 的等级就可以了。

On an AMD Duron clocked at 800Mhz running JDK 1.3.1, it costs about 5 nanoseconds to determine if a logging statement should be logged or not. Actual logging is also quite fast, ranging from 21 microseconds using the SimpleLayout, 37 microseconds using the TTCCLayout. The performance of the PatternLayout is almost as good as the dedicated layouts, except that it is much more flexible.

注：对于 Common Logging 和 Log4J 的关系可以参见 （其实 JCL 是一个规范，对一些 Log 工具进行了包装，我们常会使用到的具体实现还是 Log4j ，当然也可以使用其他的实现）

http://hedong.3322.org/archives/000316.html

参考资料：

http://www-128.ibm.com/developerworks/cn/java/l-log4j/index.html 使用 Log4J 进行日志操作

http://zooo.51.net/heavyz_cs/notebook/log4j.html Log4J 学习笔记（推荐）

http://www.dingl.com/view.shtml?xh=485 log4j 配置

http://hedong.3322.org/archives/000193.html 竹笋炒肉的 Log4J 学习笔记

http://forum.springside.org.cn/redirect.php?fid=3&tid=382&goto=nextoldset SpringSide 对 Log4j 的使用要点