Java反射总结

这篇博客对于Java中的反射机制，做一些总结，有不完善的地方再继续补充。

一. 定义
JAVA反射机制(The JAVA reflection mechanism)是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

二. 功能
在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

三. 使用
1.首先我们想通过反射获取类或者接口的属性和方法，就必须获得这个类或者接口的Class对象。有以下三种方法：
1).使用使用Class类的静态方法 Class.forName(String name)
2).类的语法,Stirng.class
3).使用类的实例化的getClass方法 obj.getClass();

2.获取类的构造器

1).public Constructor<?>[] getConstructors()      返回类中所有的public构造器集合，默认构造器的下标为0
2).public Constructor<T> getConstructor(Class<?>... parameterTypes)   返回指定public构造器，参数为构造器参数类型集合
3).public Constructor<?>[] getDeclaredConstructors()  返回类中所有的构造器，包括私有
4).public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回任意指定的构造器

3.获取类的成员变量

1).public Field getDeclaredField(String name)  获取任意指定名字的成员变量
2).public Field[] getDeclaredFields()             获取所有的成员变量
3).public Field getField(String name)           获取任意public成员变量
4).public Field[] getFields()                          获取所有的public成员变量
Field 重要方法set(Object obj, Object value)，将指定对象变量上此 Field 对象表示的字段设置为指定的新值。

4.获取类的方法

1).public Method getDeclaredMethod(String name,Class<?>... parameterTypes) 获取任意指定方法
2).public Method[] getDeclaredMethods()  获取所有的方法
3).public Method[] getMethods()    获取所有的共有方法的集合
4).public Method getMethod(String name,Class<?>... parameterTypes) 获取指定公有方法
Method重要方法invoke(Object obj ,Object…parmasType)，调用由此 Method 对象表示的底层方法。

getMethods()和getDeclaredMethods()区别
getMethods()返回某个类的所有公用（public）方法包括其继承类的公用方法，当然也包括它所实现接口的方法。
getDeclaredMethods()对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。当然也包括它所实现接口的方法。

示例代码：
1. StudentBean类

package com.li.reflection;

public class StudentBean {

    public String id;
    public String name;
    public String sex;
    public String age;
    private String height;

    public StudentBean() {
        // TODO Auto-generated constructor stub
    }

    public StudentBean(String id) {
        super();
        this.id = id;
    }

    public StudentBean(String id, String name, String sex, String age) {
        super();
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAge() {
        return age;
    }

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

    public String getHeight() {
        return height;
    }

    public void setHeight(String height) {
        this.height = height;
    }


    @Override
    public String toString() {
        return "StudentBean [id=" + id + ", name=" + name + ", sex=" + sex
                + ", age=" + age + ", height=" + height + "]";
    }

    private void goToSchool(){
        System.out.println("Go to School");
    }

    public void eat(String food){
        System.out.println("eat "+food);
    }

    public boolean finishHomework(){
        System.out.println("finishHomework?");
        return true;
    }
}

2.使用
package com.li.reflection;

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

public class ReflectionDemo {

    public static void main(String[] args) throws Exception{

        /**
         * 想要通过反射来获取类或者接口的属性和方法，首先获得这个类或者接口的Class对象
         */
        Class<?> cls;

        System.out.println("------------------Get Class------------------");
        //1.Class对象的静态方法    Class.forName(包名+类名)
        cls = Class.forName("com.li.reflection.StudentBean");
        //2.获得接口的静态方法   eg String.class
//      cls = StudentBean.class;
        //3.通过类或者接口的实例化对象 getClass()方法
//      StudentBean student = new StudentBean();
//      cls = student.getClass();
        System.out.println(cls.toString()); 
//输出: class com.li.reflection.StudentBean       

        System.out.println("------------------Get Constructor------------------");
        getConstructor(cls);

        System.out.println("------------------Get Field------------------");
        getField(cls);

        System.out.println("------------------Get Method------------------");
        getMethod(cls);
    }

    /**
     * 获得构造器创建对象
     */
    public static void getConstructor(Class<?> cls) throws Exception{
        //获得构造器
        Constructor<?>[] constructors = cls.getConstructors();
//      Constructor<?>[] constructors = cls.getDeclaredConstructors();
        for(Constructor cts : constructors){
            System.out.println(cts.getName()+"-->"+cts.toString());
        }
//输出：
//      com.li.ref.StudentBean-->public com.li.ref.StudentBean()
//      com.li.ref.StudentBean-->public com.li.ref.StudentBean(java.lang.String,java.lang.String,java.lang.String,java.lang.String)
//      com.li.ref.StudentBean-->public com.li.ref.StudentBean(java.lang.String)

        //获得默认无参构造方法
        Constructor ct = cls.getDeclaredConstructor(null);
        System.out.println(ct.toString());
        //获得只有一个参数的构造方法
        Constructor ct1 = cls.getDeclaredConstructor(new Class[]{String.class});
        System.out.println(ct1.toString()); //public com.li.ref.StudentBean(java.lang.String)
        //获得含有四个参数的构造方法
        Constructor ct4 = cls.getDeclaredConstructor(new Class[]{String.class, String.class, String.class, String.class});
        System.out.println(ct4.toString());

        //需要含有默认无参的构造方法
        StudentBean stu = (StudentBean) cls.newInstance();
        System.out.println(stu.toString());  //StudentBean [id=null, name=null, sex=null, age=null, height=null]
        //创建含一个参数的对象
        StudentBean st = (StudentBean) ct1.newInstance("25");
        System.out.println(st.toString());  //StudentBean [id=25, name=null, sex=null, age=null, height=null]
        //创建含四个参数的对象
        StudentBean st4 = (StudentBean) ct4.newInstance("1001","LiLei","male","16");
        System.out.println(st4.toString());  //StudentBean [id=1001, name=LiLei, sex=male, age=16, height=null]
    }


    /**
     * 获得类的属性
     */
    public static void getField(Class<?> cls) throws Exception{
        Field[] fields = cls.getDeclaredFields();
        for(Field fd : fields){
            fd.setAccessible(true);
            System.out.println(fd.toString());
        }
//输出：       
//      public java.lang.String com.li.ref.StudentBean.id
//      public java.lang.String com.li.ref.StudentBean.name
//      public java.lang.String com.li.ref.StudentBean.sex
//      public java.lang.String com.li.ref.StudentBean.age
//      private java.lang.String com.li.ref.StudentBean.height

        Field field = cls.getDeclaredField("id");
        System.out.println(field.toString());   //public java.lang.String com.li.ref.StudentBean.id
        StudentBean stu = (StudentBean) cls.newInstance();
        field.set(stu, "10010");
        System.out.println(stu.toString()); //StudentBean [id=10010, name=null, sex=null, age=null, height=null]
    }



    /**
     * 获取方法
     */
    public static void getMethod(Class<?> cls) throws Exception{
        Method[] methods = cls.getDeclaredMethods();
        for(Method method : methods){
            System.out.println(method.getName());
        }

        Method md = cls.getDeclaredMethod("goToSchool");
        md.setAccessible(true);
        StudentBean stu = (StudentBean) cls.newInstance();
        md.invoke(stu);

        Method method = cls.getDeclaredMethod("eat", String.class);
        method.invoke(stu, "vegetable");    //输出：eat vegetable
    }
}

坑爹的编辑器，看起来有点乱，聪明如你，肯定能看明白。