java反射

本篇文章依旧采用小例子来说明，因为我始终觉的，案例驱动是最好的，要不然只看理论的话，看了也不懂，不过建议大家在看完文章之后，在回过头去看看理论，会有更好的理解。

下面开始正文。

方法关键字	含义
getDeclaredMethods()	获取所有的方法
getReturnType()	获得方法的返回类型
getParameterTypes()	获得方法的传入参数类型
getDeclaredMethod("方法名",参数类型.class,……)	获得特定的方法
构造方法关键字	含义
getDeclaredConstructors()	获取所有的构造方法
getDeclaredConstructor(参数类型.class,……)	获取特定的构造方法
父类和父接口	含义
getSuperclass()	获取某类的父类
getInterfaces()	获取某类实现的接口

  

【案例1】通过一个对象获得完整的包名和类名

package Reflect;

/**
 * 通过一个对象获得完整的包名和类名
 * */
class Demo{
    //other codes...
}

class hello{
    public static void main(String[] args) {
        Demo demo=new Demo();
        System.out.println(demo.getClass().getName());
    }
}

【运行结果】：Reflect.Demo

【案例2】实例化类对象

package Reflect;
class Demo{
    //other codes...
}

class hello{
    public static void main(String[] args) {
        Class<?> demo1=null;
        Class<?> demo2=null;
        Class<?> demo3=null;
        try{
            //一般尽量采用这种形式
            demo1=Class.forName("Reflect.Demo");
        }catch(Exception e){
            e.printStackTrace();
        }
        demo2=new Demo().getClass();
        demo3=Demo.class;

        System.out.println("类名称   "+demo1.getName());
        System.out.println("类名称   "+demo2.getName());
        System.out.println("类名称   "+demo3.getName());

    }
}

【运行结果】：

类名称   Reflect.Demo

类名称   Reflect.Demo

类名称   Reflect.Demo

【案例3】实例化类对象

通过无参构造实例化对象
 

class Person {

    public Person() {
        this("", 0);
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "[" + this.name + "  " + this.age + "]";
    }

    private String name;
    private int age;
}

public class Demo1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
         Class<?> demo=null;
     try{
                demo=Class.forName("com.elements.Reflect.Person");
     }catch (Exception e) {
                e.printStackTrace();
     }
            Person per=null;
     try {
                per=(Person)demo.newInstance();
     } catch (InstantiationException e) {
     // TODO Auto-generated catch block
                e.printStackTrace();
     } catch (IllegalAccessException e) {
     // TODO Auto-generated catch block
                e.printStackTrace();
     }
            per.setName("Rollen");
            per.setAge(20);
     System.out.println(per);

    }

}

【运行结果】：

 [Rollen  20]

通过带参构造实例化对象

    demo=Class.forName("com.elements.Reflect.Person");
     //取得全部的构造函数
     Constructor<?> cons[]=demo.getConstructors();
                Person per=null;
     //调用哪个构造函数实例化对象
                per=(Person)cons[1].newInstance("Rollen",20);
     System.out.println(per);

 Constructor类的主要属性

    private Class<T> clazz;//对象类
    private int slot;
    private Class<?>[] parameterTypes;//这里保存了构造函数的参数类型，比较重要
    private Class<?>[] exceptionTypes;
    private int modifiers;
    // Generics and annotations support
    private transient String signature;
    // generic info repository; lazily initialized
    private transient ConstructorRepository genericInfo;
    private byte[] annotations;
    private byte[] parameterAnnotations;

【案例4】返回一个类实现的接口

//保存所有的接口
        Class<?> intes[]=demo.getInterfaces();
        for (int i = 0; i < intes.length; i++) {
            System.out.println("实现的接口   "+intes[i].getName());
        }

输出
实现的接口   com.elements.Reflect.China

【案例5】获取类的属性

     demo=Class.forName("com.elements.Reflect.Person");
     //取得全部的构造函数
     Class<?> intes[]=demo.getInterfaces();

     System.out.println("===============本类属性========================");
     // 取得本类的全部属性
     Field[] field = demo.getDeclaredFields();
     for (int i = 0; i < field.length; i++) {
     // 权限修饰符
     int mo = field[i].getModifiers();
     String priv = Modifier.toString(mo);
     // 属性类型
     Class<?> type = field[i].getType();
     System.out.println(priv + " " + type.getName() + " "
     + field[i].getName() + ";");
     }
     System.out.println("===============实现的接口或者父类的属性========================");
     // 取得实现的接口或者父类的属性
     Field[] filed1 = demo.getFields();
     for (int j = 0; j < filed1.length; j++) {
     // 权限修饰符
     int mo = filed1[j].getModifiers();
     String priv = Modifier.toString(mo);
     // 属性类型
     Class<?> type = filed1[j].getType();
     System.out.println(priv + " " + type.getName() + " "
     + filed1[j].getName() + ";");
     }

输出
===============本类属性========================
private java.lang.String name;
private int age;
===============实现的接口或者父类的属性========================
public static final java.lang.String name;
public static final int age;

【案例5】获取类的方法

    demo=Class.forName("com.elements.Reflect.Person");
     //取得全部的接口
     Class<?> intes[]=demo.getInterfaces();

     System.out.println("===============本类方法========================");
     // 取得本类的本类方法

     Method[] method = demo.getDeclaredMethods();
     for (int i = 0; i < method.length; i++) {
     // 权限修饰符
     int mo = method[i].getModifiers();
     String priv = Modifier.toString(mo);
     // 返回的类型
     Class<?> type = method[i].getReturnType();

     //获取参数
     Parameter[] parms= method[i].getParameters();

     String stringprams="";
     for (int p = 0; p < parms.length; p++) {
                        stringprams=stringprams+ parms[p].getParameterizedType()+",";
     }
     if (stringprams.length()>1)
                    stringprams=stringprams.substring(0, stringprams.length()-1);

     System.out.println(priv + " " + type.getName() + " "
                            +method[i].getName()+"("+stringprams+")" );
     }

输出

===============本类方法========================
public java.lang.String toString()
public java.lang.String getName()
public void setName(class java.lang.String)
public void sayChina()
public int getAge()
public void setAge(int)
public void sayHello(class java.lang.String,int)

【案例6】调用类的方法

     demo=Class.forName("com.elements.Reflect.Person");
     Object o=demo.newInstance();

     //调用Person类中的sayChina方法
     Method method=demo.getMethod("sayChina");
     method.invoke(demo.newInstance());

     //调用setName 带参数
     Method method2=demo.getMethod("setName",String.class);
                method2.invoke(o,"aaaa");
     System.out.print(o);
     //以下代码实现一样
//	            Person p=(Person) demo.newInstance();
//	            p.setName("aaaa");        
//	            System.out.print(p);

【案例7】调用类的get和set方法

public static void getter(Object obj, String att) {
     try {
     Method method = obj.getClass().getMethod("get" + att);
     System.out.println(method.invoke(obj));
     } catch (Exception e) {
                e.printStackTrace();
     }
     }


     public static void setter(Object obj, String att, Object value,
     Class<?> type) {
     try {
     Method method = obj.getClass().getMethod("set" + att, type);
     method.invoke(obj, value);
     } catch (Exception e) {
                e.printStackTrace();
     }
     }


    /**
     * @param args
     */
    public static void main(String[] args) {
        Class<?> demo = null;
        Object obj=null;
        try {
            demo = Class.forName("com.elements.Reflect.Person");
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
         obj=demo.newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        setter(obj,"Sex","男",String.class);
        getter(obj,"Sex");


    }

【案例8】通过反射修改属性值

        Class<?> demo = null;
        Object obj = null;

        demo = Class.forName("Reflect.Person");
        obj = demo.newInstance();

        Field field = demo.getDeclaredField("sex");
        field.setAccessible(true);
        field.set(obj, "男");
        System.out.println(field.get(obj));