反射之获取字段

public class Demo12{
    
    /*
    对任意一个Object实例，只要我们获取了它的Class,就可以获取它的一切信息
    Class类提供了以下几个方法来获取字段
    
    Field getField(name):根据字段名获取某个public的field（包括父类）
    Field getDeclaredField(name):根据字段名获取当前类的某个field（不包括父类）
    Field getFields():获取全部public的field(包括父类)
    Field getDeclaredField():获取当前类的全部field（不包括父类）    
    */
    
    //reflection反射
    public static void main(String[] args) throws Exception{  //记住要抛出异常
        Class stuClass = Student.class;
        //获取public字段"score"
        System.out.println(stuClass.getField("score"));//public int Student.score
        //获取继承的public字段"name"
        System.out.println(stuClass.getField("name"));//public java.lang.String Person.name
        //获取private字段"grade"
        System.out.println(stuClass.getDeclaredField("grade"));
    }
}

class Student extends Person{
    public int score;
    //班级字段私有
    private int grade;
}

class Person{
    public String name;
}

一个Field对象包含了一个字段的所有信息
getName():返回字段名称，例如"name"
getType():返回字段类型,也是一个Class实例，例如，String.class
getModifiers():返回字段的修饰符，它是一个int，不同的bit表示不同的含义

public static void main(String[] args) throws Exception{  //记住要抛出异常
        Class stuClass = Student.class;
        //获取public字段"score"
        Field f = stuClass.getField("score");
        //获取字段名称
        System.out.println(f.getName());//score
        //获取字段类型
        System.out.println(f.getType());
        //获取字段的修饰符所代表的bit数字
        int m = f.getModifiers();
        System.out.println(m);
        //判断字段是哪种修饰符
        System.out.println(Modifier.isFinal(m)); 
        System.out.println(Modifier.isPublic(m));
        System.out.println(Modifier.isProtected(m));
        System.out.println(Modifier.isPrivate(m));
        System.out.println(Modifier.isStatic(m));
    }

获取字段值

利用反射拿到字段的一个Field实例只是第一步，我们还可以拿到一个实例对应的该字段的值。

例如，对于一个Person实例，我们可以先拿到name字段对应的Field，再获取这个实例的name字段的值：

import java.lang.reflect.*;
public class Demo12{
    //reflection反射
    public static void main(String[] args) throws Exception{  //记住要抛出异常
        Object p = new Person("先把SE学完！");
        Class cls = p.getClass();
        Field f = cls.getDeclaredField("name");
        //因为name被定义为一个private字段，正常情况下，Main类无法访问Person类的private字段,会得到一个IllegalAccessException    
        //调用Field.setAccessible(true)的意思是，别管这个字段是不是public，一律允许访问
        f.setAccessible(true);
        
        //用Field.get(Object)获取指定实例的指定字段的值
        Object value = f.get(p);
        System.out.println(value);//先把SE学完！
    }
}

class Person {
    private String name;

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

有童鞋会问：如果使用反射可以获取private字段的值，那么类的封装还有什么意义？

答案是正常情况下，我们总是通过p.name来访问Person的name字段，编译器会根据public、protected和private决定是否允许访问字段，这样就达到了数据封装的目的。

而反射是一种非常规的用法，使用反射，首先代码非常繁琐，其次，它更多地是给工具或者底层框架来使用，目的是在不知道目标实例任何信息的情况下，获取特定字段的值。

此外，setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager，那么它会根据规则进行检查，有可能阻止setAccessible(true)。例如，某个SecurityManager可能不允许对java和javax开头的package的类调用setAccessible(true)，这样可以保证JVM核心库的安全。

设置字段值

通过Field实例既然可以获取到指定实例的字段值，自然也可以设置字段的值。

设置字段值是通过Field.set(Object, Object)实现的，其中第一个Object参数是指定的实例，第二个Object参数是待修改的值。示例代码如下：

import java.lang.reflect.*;
public class Demo12{
    //reflection反射
    public static void main(String[] args) throws Exception{  //记住要抛出异常
        //创建Person对象
        Object p = new Person("正在学反射");
        //获取Person对象的Class对象
        Class cls = p.getClass();
        //获取Class对象的字段对象
        Field f = cls.getDeclaredField("name");
        //因为字段是private，所以必须设置访问权限为true，才可以进行访问
        f.setAccessible(true);
        //访问字段值
        Object value = f.get(p); 
        System.out.println(value);
        //修改字段值
        f.set(p,"坚持学下去！");
        //再次访问字段值
        value = f.get(p);
        System.out.println(value);
    }
}

class Person {
    private String name;

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

小结

Java的反射API提供的Field类封装了字段的所有信息：

通过Class实例的方法可以获取Field实例：getField()，getFields()，getDeclaredField()，getDeclaredFields()；

通过Field实例可以获取字段信息：getName()，getType()，getModifiers()；

通过Field实例可以读取或设置某个对象的字段，如果存在访问限制，要首先调用setAccessible(true)来访问非public字段。

通过反射读写字段是一种非常规方法，它会破坏对象的封装。