Java反射:类字段和方法的顺序是否标准化？

Question

使用Java类上的反射来访问所有字段,方法等:
这些元素是否有标准化顺序(在某些标准中指定)？

当然,我可以凭经验检查,但我需要知道它是否总是一样的.

编辑:
我等待的问题:我需要的订单;)
长话短说:我有JAXB注释类,并且不希望在视觉上代表这些类.虽然XML属性的顺序既不与XML标准相关,也不与JAXB相关,但我希望对可视表示具有特定顺序的XML属性.
例如:开始结束.这伤害了一个人的直觉.

Answer 1

根据文件:

getFields()

返回一个包含Field对象的数组,该对象反映此Class对象所表示的类或接口的所有可访问公共字段.返回的数组中的元素没有排序,也没有任何特定的顺序.如果类或接口没有可访问的公共字段,或者它表示数组类,基本类型或void,则此方法返回长度为0的数组.

getMethods()

返回一个包含Method对象的数组,这些对象反映此Class对象所表示的类或接口的所有公共成员方法,包括由类或接口声明的那些以及从超类和超接口继承的那些.数组类返回从Object类继承的所有(公共)成员方法.返回的数组中的元素没有排序,也没有任何特定的顺序.如果此Class对象表示没有公共成员方法的类或接口,或者此Class对象表示基本类型或void,则此方法返回长度为0的数组.

Answer 2

基于注释的想法的示例.

public class FiledOrder {
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Order {
        int value();
    }
    public class SomeClass {
        @Order(value=2)
        public int field1;
        @Order(value=1)
        public int field2;
        // no annotation
        public int field3;
        @Order(value=1)
        public void start() { }
        @Order(value=2)
        public void end() { }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        Field[] fields = SomeClass.class.getFields();
        Arrays.sort(fields, new Comparator<Field>() {
            @Override
            public int compare(Field o1, Field o2) {
                Order or1 = o1.getAnnotation(Order.class);
                Order or2 = o2.getAnnotation(Order.class);
                // nulls last
                if (or1 != null && or2 != null) {
                    return or1.value() - or2.value();
                } else
                if (or1 != null && or2 == null) {
                    return -1;
                } else
                if (or1 == null && or2 != null) {
                    return 1;
                }
                return o1.getName().compareTo(o2.getName());
            }
        });
        for (Field f : fields) {
            System.out.println(f.getName());
        }
        Method[] methods = SomeClass.class.getMethods();
        Arrays.sort(methods, new Comparator<Method>() {
            @Override
            public int compare(Method o1, Method o2) {
                Order or1 = o1.getAnnotation(Order.class);
                Order or2 = o2.getAnnotation(Order.class);
                // nulls last
                if (or1 != null && or2 != null) {
                    return or1.value() - or2.value();
                } else
                if (or1 != null && or2 == null) {
                    return -1;
                } else
                if (or1 == null && or2 != null) {
                    return 1;
                }
                return o1.getName().compareTo(o2.getName());
            }
        });
        for (Method m : methods) {
            System.out.println(m.getName());
        }
    }

}

Answer 3

即使getFields()和getMethods()没有按特定顺序返回结果,您也可以将返回数组中的元素添加到集合中,并提供您自己的Comparator来根据需要对它们进行排序.

在这个例子中,我只是排序的字段并根据他们的名字的字母顺序方法 - 但你可以根据在各自的比较器提供所需的逻辑声明类,改性剂,返回类型等,对它们进行排序.

public void PrintClassData(Class c) {
    Field[] fieldArray = c.getFields();
    Method[] methodArray = c.getMethods();
    SortedSet<Field> fields = new TreeSet<Field>(new FieldComparator());
    fields.addAll(Arrays.asList(fieldArray));
    SortedSet<Method> methods = new TreeSet<Method>(new MethodComparator());
    methods.addAll(Arrays.asList(methodArray));

    StringBuffer b = new StringBuffer("All About ");
    b.append(c.getName());
    b.append("\nFields:\n");
    for(Field f : fields) {
        b.append("\t");
        b.append(Modifier.toString(f.getModifiers()));
        b.append(" ");
        b.append(f.getType());
        b.append(" ");
        b.append(f.getName());
        b.append("\n");
    }
    b.append("\nMethods:\n");
    for (Method m : methods) {
        b.append("\t");
        b.append(Modifier.toString(m.getModifiers()));
        b.append(" ");
        b.append(m.getReturnType());
        b.append(" ");
        b.append(m.getName());
        b.append("( ");
        for (Class param : m.getParameterTypes()) {
            b.append(param.getName());
            b.append(", ");
        }
        b.deleteCharAt(b.lastIndexOf(","));
        b.append(")\n");
    }
    System.out.println(b.toString());
}

private static class FieldComparator implements Comparator<Field> {

    public int compare(Field f1, Field f2) {
        return (f1.getName().compareTo(f2.getName()));
    }   
}

private static class MethodComparator implements Comparator<Method> {

    public int compare(Method m1, Method m2) {
        return (m1.getName().compareTo(m2.getName()));
    }

}