Java基础之反射

反射

作为jdk1.5后的新特性，反射这个知识还是要掌握的，以前自己也知道个大概，但是从来没有系统的学习过，所以这次准备记录下。

先看看反射需要用到的包：java.lang.reflect

看看这个包的说明:
提供类和接口，以获得关于类和对象的反射信息。在安全限制内，反射允许编程访问关于加载类的字段、方法和构造方法的信息，并允许使用反射字段、方法和构造方法对其底层对等项进行操作。

在利用反射操作中，我们无非使用Constructor< T>、Field、Method三个类比较多。在我们学习这三个类之前，我们要知道java中通过字节码获取Class的三种方法：

• 类名.class，例如，System.class

• 对象.getClass()，例如，new Date().getClass()

• Class.forName(“类名”)，例如，Class.forName(“java.util.Date”)

下面我们通过实例测试：

（1）创建Person类

package com.dsw.reflect;

public class Person {
    private String name;
    private String age;
    public Person(){

    }

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

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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

    public void printMsg(){
        System.out.println(this.name + "--" + this.age);
    }
}

 

（2）、编写测试类

 

public class ReflectDemo {

/**
 * @param args
 */
public static void main(String[] args) {
    //通过类名.class获取字节码
    Class clazz1 = Person.class;

    //通过对象.getClass()获取字节码
    Person person = new Person();
    Class clazz2 = person.getClass();

    //通过Class.forName("类名");获取字节码
    try {
        Class clazz3 = Class.forName("com.dsw.reflect.Person");
        System.out.println("clazz1 == clazz2:" + (clazz1 == clazz2));
        System.out.println("clazz2 == clazz3:" + (clazz2 == clazz3));
        System.out.println("clazz1.equals(clazz2):" + clazz1.equals(clazz2));
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}
}

运行结果：

clazz1 == clazz2:true
clazz2 == clazz3:true
clazz1.equals(clazz2):true

只有获取到字节码，我们才能获取到类的Field、Method等相关方法。

 

Constructor

 

1、继承关系

2、方法集合 

测试实例代码：

public static void main(String[] args) {
    //通过类名.class获取字节码
    Class<Person> clazz = Person.class;

    //通过字节码获取构造函数
    try {
        //获取具体的构造方法
        Constructor<Person> constructor = clazz.getConstructor(String.class,String.class);
        System.out.println(constructor.getName());
        Person person = constructor.newInstance("张三","20岁");
        person.printMsg();

        //获取无参构造函数，无参构造函数只能创建无参的实例
        Constructor<Person> constructor1 = clazz.getConstructor();
        System.out.println(constructor1.getName());
        Person person1 = constructor1.newInstance();
        person1.printMsg();
        //获取所有的构造方法
        Constructor<?> [] constructors = clazz.getConstructors();
        for(int i=0;i<constructors.length;i++){
            Constructor<?> construct = constructors[i];
            System.out.println(construct.getName());
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

运行结果：

com.dsw.reflect.Person
张三--20岁
2-java.lang.String
com.dsw.reflect.Person
null--null
com.dsw.reflect.Person
com.dsw.reflect.Person

通过获取构造函数，我们可以创建对应的实例，然后使用类对象的方法。

 

Method
1、继承关系

 

2、方法集合

测试用例：
注意：
Method中invoke（Object obj,Object…args）第一个参数为类的实例，第二个参数为相应函数中的参数，我想问，我调用的函数本来是一个多参数（参数个数不确定）的函数，应该怎么办？

可以这样调用：method.invoke(object, new Object[][]{new Object[]{obj1, obj2}}); 
这样相当于object.method(obj1, obj2);

测试用例：

public static void main(String[] args) {
    //通过类名.class获取字节码
    Class<Person> clazz = Person.class;
    try {
        Object obj = clazz.newInstance();
        Method method = clazz.getMethod("printMethod", new Class[]{String.class});
        method.invoke(obj, new Object[]{method.getName()});
        //获取所有的公共声明的方法
        Method[] methods = clazz.getMethods();
        if(methods != null && methods.length >0){
            for(int i=0;i<methods.length;i++){
                Method methodSub = methods[i];
                System.out.println(methodSub.getName());
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

运行结果：

Method:printMethod
getName
setName
printMethod
getAge
setAge
printMsg
wait
wait
wait
equals
toString
hashCode
getClass
notify
notifyAll

 

Field
1、继承关系

 

2、方法集合


测试用例：

public static void main(String[] args) {
    //通过类名.class获取字节码
    Class<Person> clazz = Person.class;
    try {
        //获取指定的字段名称
        Field field = clazz.getDeclaredField("name");
        System.out.println(field.getName());
        /*获取所有的字段
         * getFields获取的是公共的字段，
         * getDeclaredFields获取所有声明的字段
         */
        Field[] fields = clazz.getDeclaredFields();
        if(fields != null && fields.length >0){
            for(int i=0;i<fields.length;i++){
                System.out.println(fields[i].getName());
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

运行结果：

name
name
age