variables miembro reflexión de la reflexión de Java

Anterior describe la estructura del método de reflexión reflexión de Java . Esta vez hablamos de cómo las variables miembro de la clase de reflexión y usados como un caso simple.

[A] Clase Field,

clase Archivado representa el campo que contiene todos los campos tienen propiedades, tales como modificadores, tipo de variable, valor, etc., clase Archivado tiene un método para obtener estas propiedades.
Y las clases heredan como un constructor java.lang.reflect.AccessibleObject clase, hay formas de determinar si el acceso y establecer la propiedad privada.
Para los siguientes muestra cómo modificar, para obtener una variable de clase:
la clase Point:

public class Point {
    public int x;
    private int y;
    public static int z = 10;
    
    public Point(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
}

Método de prueba:

public static void main(String[] args) throws Exception {
        Point p = new Point(3,4);
        Class cls = p.getClass();
        //1、获得Point类中所有的成员变量
        Field[] fields = cls.getFields();
        //打印
        for(Field field : fields){
            //get(p);获得对象p的所有成员变量
            System.out.println(field.get(p));
        }
        
        //2、获得Point类中的指定x,y,z变量
        Field fieldX = cls.getField("x");
        Field fieldY = cls.getField("y");
        Field fieldZ = cls.getField("z");
        //分别对应对象p
        System.out.println("x:"+fieldX.get(p)+" y:"+fieldY.get(p)+" z:"+fieldZ.get(null));
        
    }

resultados:

3
10
Exception in thread "main" java.lang.NoSuchFieldException: y
    at java.lang.Class.getField(Class.java:1584)
    at club.leyvan.muzile.ConstructDemo.main(ConstructDemo.java:20)

clase Clase GetFields (): Obtener todos los campos tales como el objeto de la clase Field.
getFields clase Clase (nombre de cadena): para obtener el campo de clase y los parámetros del mismo nombre.
get colectiva presentada (p): Este campo es que se unen un cuerpo de destino. Ejemplos del pase p, el campo miembro de unión a campo de destino correspondiente al objeto específico y es un p valor p nombre de objeto del campo en el objeto que representa el método.
Las variables estáticas pertenecen a la clase así que no necesitan de obligar a un objeto específico, se puede obtener un valor nulo pase campo estático.
La primera parte del código, además de las variables privadas se imprimen, y la segunda parte del informe estaba mal, no la variable privada y, podemos ver que ser una variable privada no se puede leer. Ahora ponemos los siguientes cambios en el código, se puede obtener el valor de una variable privada.
Código se modifica de la siguiente manera:

public static void main(String[] args) throws Exception {
        Point p = new Point(3,4);
        Class cls = p.getClass();
        //1、获得Point类中所有的成员变量
        Field[] fields = cls.getFields();
        //打印
        for(Field field : fields){
            //get(p);获得对象p的所有成员变量
            System.out.println(field.get(p));
        }
        
        //2、获得Point类中的指定x,y,z变量
        Field fieldX = cls.getField("x");
        //修改部分↓↓
        Field fieldY = cls.getDeclaredField("y");
        fieldY.setAccessible(true);
        //修改部分↑↑
        Field fieldZ = cls.getField("z");
        //分别对应对象p
        System.out.println("x:"+fieldX.get(p)+" y:"+fieldY.get(p)+" z:"+fieldZ.get(null));
        
    }

resultados:

3
10
x:3 y:4 z:10

clase getDeclaredField clase (String name): obtener variables privadas
campo hereda de la clase clase java.lang.reflect.AccessibleObject tiene setAccessible (b booleano): Establecer si el acceso a los miembros privados.
El método anterior llamada violencia de reflexión, la violencia puede conseguir que los miembros privados.

[Di] caso: modo de reflexión usando una variable de clase de tipo String todos "b" modificar "a"

categorías de frijol:

package club.leyvan.muzile;

public class Bean {
    public int i1 = 10;
    public String str1 = "basketball";
    private String str2 = "breakfast";
    private static String str3 = "bbc";
    @Override
    public String toString() {
        return "Bean [i1=" + i1 + ", str1=" + str1 + ", str2=" + str2 + "]";
    }
    
    public static String getStr3(){
        return "str3: "+str3;
    }
}

Método de prueba:

public static void main(String[] args) throws Exception {
        //获得class
        Class cls = Class.forName("club.leyvan.muzile.Bean");
        //创建一个对象 默认调用无参构造方法
        Bean obj = (Bean)cls.newInstance();
        //获得所有字段
        Field[] fields = cls.getDeclaredFields();
        //扫描所有字段
        for(Field field : fields){
            //class对象只有一份，所以使用==更好
            if(field.getType() == String.class){
                //判断是否是
                if(!field.isAccessible()){
                    field.setAccessible(true);
                }
                //判断是否是静态字段
                //getModifiers()获得所有的修饰符
                //boolean isStatic = Modifier.isStatic(field.getModifiers());
                String oldValue = (String)field.get(obj);
                String newValue = oldValue.replace('b', 'a');
                field.set(obj, newValue);
            }
        }
        System.out.println(obj+Bean.getStr3());
    }

resultados:

Bean [i1=10, str1=aasketaall, str2=areakfast]str3: aac

En donde field.getModifiers (): Obtener todos los modificadores
Modifier.isStatic (): determinar si modificador se obtiene por la estática
field.set (obj, valor): modificar el valor de la objeto dependiente

Siguiente decimos reflejo de los miembros del método de reflexión de Java