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 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法

知识点：----

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

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