java笔记01-反射

--2013年7月26日17:56:35

写文章之前，参考了这篇：http://www.cnblogs.com/Quincy/archive/2011/06/19/2084557.html

评价：这个作者写的像个字典，我照着看了，里面的代码觉得乱，还是自己整理一篇。

--先看一段代码，这段代码，基本可以演示反射我想总结的东西.

 package com.dev;

 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;

 class Tst {    //提供反射用的类
     private int x;
     public int y;
     public String str1 = "abc";
     public String str2 = "123";
     public Tst(){};
     public Tst(int x, int y) {
         super();
         this.x = x;
         this.y = y;
     }
     @Override
     public String toString() {
         return "Tst [x=" + x + ", y=" + y + ", str1=" + str1 + ", str2=" + str2
                 + "]";
     }

 }
 public class ReflectClass {

     public static void main(String[] args) throws Throwable {
         Tst tst = new Tst(1,2);
         changeField(tst);
         printClass(tst);
         getFields(tst);
         printConstructors(tst);
         printMethods(tst);
     }

     private static void printClass(Object obj) throws Throwable{

         Class<?> clazz = obj.getClass();

         String modifers = Modifier.toString(clazz.getModifiers());
         if(modifers.length() > 0);
             log("--class basic info--");
             log("modifers=" +modifers);
             log("className()=" + clazz.getName());
         Class<?>  superClasses = clazz.getSuperclass();
         if(superClasses != null && !Object.class.equals(superClasses)){
             log("extends:" + superClasses.getName() + " ");
         }

         Class<?>[] interfaces =  clazz.getInterfaces();
         if(interfaces.length > 0){
             log("implents--");
             for(Class<?> interfacez : interfaces){
                 log("impls="+interfacez.getName());
             }
         }
     }

     private static void getFields(Object obj) throws Exception{
         Class<?> clazz = obj.getClass();
         Field[] fields = clazz.getDeclaredFields();
         log("--class fields info--");
         for(Field field : fields){
             String modifers = Modifier.toString(field.getModifiers());
             String fName = field.getName();
 //            fieldX.setAccessible(true);
             field.setAccessible(true);
             Object val = (Object)field.get(obj);
             log( fName+"="+val+",modifers="+modifers+",type="+field.getType().getName() );
 //          log("modifers="+modifers+",type="+field.getType().getName() + ",name=" + fName+",val="+clazz.getField(fName));
         }
     }

     private static void printConstructors(Object obj){
         Class<?> clazz = obj.getClass();
         log("--class constructor info--");
         Constructor<?>[] constructors = clazz.getConstructors();
         log("constructors total count ="+ constructors.length);
         for(Constructor<?> constructor : constructors){

             String modifers = Modifier.toString(constructor.getModifiers());
             if(modifers.length() > 0);
             Class<?>[] parameterTypes = constructor.getParameterTypes();
              log("modifers="+modifers+",CONSName="+constructor.getName() + "--parameterCount="+parameterTypes.length);
             for(Class<?> parameterType : parameterTypes){
                 log("paramter="+parameterType.getName());
             }
         }
     }

     private static void printMethods(Object obj){
         Class<?> clazz = obj.getClass();
         log("--class Methods info--");
         Method[] methods = clazz.getMethods();
         int i = 1;
         for(Method method : methods){
             String modifers = Modifier.toString(method.getModifiers());
             Class<?> returnType = method.getReturnType();
             Class<?>[] parameterTypes = method.getParameterTypes();
             String mName = method.getName();
             log(methods.length+"-"+i+":"+mName+"()-modifers="+modifers+",returnType="+returnType.getName());
             i++;
             for(Class<?> parameterType : parameterTypes){
                 log("  "+parameterTypes.length+"lparameterType="+parameterType.getName());
             }
         }
     }
     private static void changeField(Object obj) throws Exception{
         log("--before="+obj);
         Field field = obj.getClass().getField("str1");
         field.set(obj, "after22");
         log("--after="+obj);
     }
     private static void log(String log){
         System.out.println(log);
     }
 }

知识点1：获得某个类的字节码类对象（Class）的方法有3种：

1、ReflectPoint.class (类名.class)
2、reflectPoint.getClass() (对象名.getClass())
3、Class.forName("com.juziku.ReflectPoint") (Class.forName(类名的路径))

知识点2：获得Field类对象，得到这个对象就可以进行操作了

JAVA 的Class<T>类提供了几个方法获取类的属性。

public Field getField(String name) 返回一个 Field 对象，返回值是一个属性对象，用这个返回对象可以操作这个属性。

public Field[] getFields() 返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段

public Field getDeclaredField(String name) 返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段

public Field[] getDeclaredFields() 返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段

知识点3：获取类的Method

public Method getMethod(String name, Class<?>... parameterTypes)返回一个 Method 对象
public Method[] getMethods()返回一个包含某些 Method 对象的数组
public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
返回一个 Method 对象
public Method[] getDeclaredMethods()返回 Method 对象的一个数组，
这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法

知识点：----

这里其实大概的思想要有，就是用反射包里面的类，获取对象，然后就和普通对象一样进行反射操作。

剩下的参考文档吧，或者仔细看上面的代码。