java里的反射机制

     作为一个java初学者，想了解java里的反射机制。我觉得首先应该能区分静态编译和动态编译。

 一.静态编译和动态编译

     通俗讲，静态编译：在编译时确定类型，绑定对象,即通过。
     动态编译：运行时(RunningTime)确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了  

     多态的应用，有以降低类之间的藕合性，即Class.forName(“ClassName”)应用。

package ref;
import java.awt.Color;

//定义一个鸟类接口
public interface Bird {
	 String name="猫头鹰";
	 int age=2;
	 Color color=Color.black;
   public void PlayRole();
   public void Fly(int flymile);
   
}
package ref;
import java.awt.Color;

public class MaoBird implements Bird{
      public void PlayRole(){
    	  System.out.println("这只鸟的名字为"+name+",他的年龄为"+age+",它的颜色为"+color);
      }
      public void Fly(int flymile){
    	  System.out.println("它飞了"+flymile+"米");
      }
}
package ref;
import java.lang.reflect.Constructor;
/**
 * 这里类的创建通过java反射机制来实现
 * @author Administrator
 *
 */
public class RunMain1 {
    public static void main(String args[]){
    	try {
	            Class c=Class.forName("ref.MaoBird");
		    Object brid=c.newInstance();
		    MaoBird maobird=(MaoBird)brid;
		    maobird.PlayRole();
                    maobird.Fly(3);			
		} catch (Exception e) {
			e.printStackTrace();
		}
    }
}
/**
 *这里是我们常说的静态创建类对象
 */
public class RunMain2{
      public static void main(String args[]){
                 MaoBird  maobird=new MaBird();
                 maobird.PlayRole();
                 maobird.Fly(3);
      }
}

   上面的RunMain2一开始通过类名NEW一个对象，然后在对象上调用其方法.而第一个RunMain1中，则是先获取类名，通过构造器创建对象。二者的区别，用文字还是很难说的准确。需要自己慢慢体会吧！

二.通过反射动态获得

    如果说我知道一个东西，却不知道它是用来干嘛的。这是不是显得对于东西我们认识的不够透彻？

   1:提取属性详细信息:

   

private static void printFiledInfo( java.lang.reflect.Field[] fields){
System.out.println("共有属性: "+fields.length);
for(java.lang.reflect.Field f : fields){
String fName=f.getName();
System.out.println("属性名字是: "+fName);
Class fType= f.getType();
System.out.println("属性类型是: "+fType);
//得到属性的访问限定符
int mType= f.getModifiers();
//判断是何种限定符
if (java.lang.reflect.Modifier.isPublic(mType))
System.out.println(" public");
if (java.lang.reflect.Modifier.isAbstract(mType))
System.out.println(" abstract");
if (java.lang.reflect.Modifier.isFinal(mType))
System.out.println(" final");
}
}

   2取得超类/接口详细信息

 

private static void printInterface( Class[] interfaces){
for(Class c : interfaces){
System.out.println("接口名: "+c.getName());
Class[] cs=c.getInterfaces();
printInterface(cs);
}
}
//输出所有父类名字
private static void printSuper( Class superClass){
System.out.println("接口名: "+superClass.getName());
Class ss=superClass.getSuperclass();
if(null!=ss){
printSuper(ss);
}
}

 

    3提取方法/构造器详细信息

   

//打印方法信息
private static void printMethodInfo( java.lang.reflect.Method[] methods){
for(java.lang.reflect.Method m : methods){
int t= m.getModifiers();
System.out.println("限定符是: "+t);
String name= m.getName();
System.out.println("方法名是: "+name);
Class returnType = m.getReturnType();
System.out.println("返回值类型是: "+returnType.getName());
//参数类型组....
Class ps[]= m.getParameterTypes();
//异常类型组...
Class es[]= m.getExceptionTypes();
}
}
//打印构造器信息
private static void printConstructorInfo(java.lang.reflect.Constructor[] cons){
for(java.lang.reflect.Constructor con : cons){
//构造器限定符
int m= con.getModifiers();
//得到参数类型表 . . .
Class[] ptype=con.getParameterTypes();
}
}

    以上只是它的一部分作用，想知道可以看javaAPI文档中java.lang.reflect类的方法。

三.关于在对象上调用方法和对象调用方法的区别

    其实我觉得这个问题是很纠结的，因为从字面看二者，是没有什么区别。从代码看，二者的区别就是显示

    出来。前者一开始通过已知的方法名和参数动态获得一个方法对象，然后通过这个对象调用方法。

    后者是通过类名创建对象，在对象调用方法。

    好吧，我觉得大家看完后，肯定还是很难区别。那以后敲代码慢慢体会了。