java 反射 - Field

public class A
{
    public String id;
    protected String name;
    int age;
    private String sex;
    int[][] ints;
}

public class C {
    private int a;
    private double d;
    private boolean flag;

    private String str;


    public C(int a, double d, boolean flag, String str) {
        this.a = a;
        this.d = d;
        this.flag = flag;
        this.str = str;
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public double getD() {
        return d;
    }

    public void setD(double d) {
        this.d = d;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

//    public String getStr() {
//        return str;
//    }
//
//    public void setStr(String str) {
//        this.str = str;
//    }
}

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test {
    /**
     * 返回该类所在包的包名字字符串
     *
     * @param thisClass 一个类的Class对象
     * @return 该类的包名字字符串
     */
    public static String getThisPackageName(Class<?> thisClass) {
        String thisClassName = thisClass.getName();
        String thispackage = thisClassName.substring(0, thisClassName.lastIndexOf("."));
        return thispackage;
    }

    public static void main(String[] args) throws SecurityException, IllegalAccessException {
        //获取字段的名字  类型 修饰符编码
        // nameType();
        fieldSetGet();

    }

    /***
     * 获取字段的名字  类型 修饰符编码
     */
    private static void nameType() {
        Field[] sField = A.class.getDeclaredFields();
        for (Field field : sField) {

            // 获取字段的名字
            System.out.printf("字段：%-4s|", field.getName());
            // 获取字段的类型的Class类，然后获取规范化的名字
            System.out.printf("类型：%-18s|", field.getGenericType().getTypeName());
            //获取字段的类型的Class类，然后获取规范化的名字
            System.out.printf("Type：%-18s|", field.getType().getCanonicalName());

            //使用Field.getModifiers()，可获取字段的修饰符编码，
            //然后再使用Modifier.toString(int code)，来解码成字字符串
            System.out.printf("修饰符：%s", Modifier.toString(field.getModifiers()));

 // 当前 field 所属于的类
            Class<?> declaringClass = field.getDeclaringClass();

            System.out.println();

        }
    }


    // todo  基本类型的获取方法：
    // byte getByte(Object obj)
    //          获取一个静态或实例 byte 字段的值。
    //int getInt(Object obj)
    //          获取 int 类型或另一个通过扩展转换可以转换为 int 类型的基本类型的静态或实例字段的值。
    // short getShort(Object obj)
    //          获取 short 类型或另一个通过扩展转换可以转换为 short 类型的基本类型的静态或实例字段的值。
    // long getLong(Object obj)
    //          获取 long 类型或另一个通过扩展转换可以转换为 long 类型的基本类型的静态或实例字段的值。
    // float getFloat(Object obj)
    //          获取 float 类型或另一个通过扩展转换可以转换为 float 类型的基本类型的静态或实例字段的值。
    // double getDouble(Object obj)
    //          获取 double 类型或另一个通过扩展转换可以转换为 double 类型的基本类型的静态或实例字段的值。
    // boolean getBoolean(Object obj)
    //          获取一个静态或实例 boolean 字段的值。
    // char getChar(Object obj)
    //          获取 char 类型或另一个通过扩展转换可以转换为 char 类型的基本类型的静态或实例字段的值。

    // todo  基本类型的setter方法：
    // void setByte(Object obj, byte b)
    //          将字段的值设置为指定对象上的一个 byte 值。
    // void setShort(Object obj, short s)
    //  将字段的值设置为指定对象上的一个 short 值。
    // void setInt(Object obj, int i)
    //          将字段的值设置为指定对象上的一个 int 值。
    // void setLong(Object obj, long l)
    //          将字段的值设置为指定对象上的一个 long 值。
    // void setFloat(Object obj, float f)
    //          将字段的值设置为指定对象上的一个 float 值。
    // void setDouble(Object obj, double d)
    //          将字段的值设置为指定对象上的一个 double 值。
    // void setBoolean(Object obj, boolean z)
    //          将字段的值设置为指定对象上的一个 boolean 值。
    // void setChar(Object obj, char c)
    //          将字段的值设置为指定对象上的一个 char 值。


    //  todo  引用类型的getters方法：
    //
    //    Object get(Object obj)
    //    返回指定对象上此 Field 表示的字段的值。

    //  todo    4.引用类型的setters方法：
    //
    //    void set(Object obj, Object value)
    //    将指定对象变量上此 Field 对象表示的字段设置为指定的新值。


    public static void fieldSetGet() throws IllegalArgumentException, IllegalAccessException {

        C c = new C(10, 123.456, true,"s1");
        System.out.println("c对象的值：");
        System.out.println(c);
        System.out.println("-------------------------------");
        Class cClass = c.getClass();
        // 获取所有的字段
        Field[] cFields = cClass.getDeclaredFields();
        for (Field field : cFields) {
            field.setAccessible(true);
            System.out.println("获取到字段：" + field.getType().getCanonicalName()
                    + ",值：" + field.get(c));
        }
        for (Field field : cFields) {
            if (field.getType().getCanonicalName() == "int") {
                field.setInt(c, 30);
            } else if (field.getType().getCanonicalName() == "double") {
                field.setDouble(c, 6789.9901);
            } else if (field.getType().getCanonicalName() == "boolean") {
                field.setBoolean(c, false);
            }else if (field.getType().getCanonicalName() == "java.lang.String") {
                field.set(c, "s2");
            }
            // System.out.println(field.getType().getCanonicalName());
        }
        System.out.println("-------------------------------");
        System.out.println("现在的c对象的值：");
        for (Field field : cFields) {
            field.setAccessible(true);
            System.out.println("获取到字段：" + field.getType().getCanonicalName()
                    + ",值：" + field.get(c));
        }
    }


}