Java反射：是类字段和方法的顺序规范？Java反射：是类字段和方法的顺序规范？(Java refl

对Java类使用反射来访问所有领域，方法等：
有这些元件 （其在一些标准中规定） 的标准化的订单 ？

当然，我可以凭经验检查它，但我需要知道，如果它总是相同的。

编辑：
我等待着这样一个问题：我需要什么样的顺序;）
长话短说：我有JAXB注解类，并希望视觉上没有不表示这些类。 虽然XML的订单属性是XML标准既不是相关的，也不是为JAXB，我想有一定顺序的可视化表示的XML属性。
例如：开始来结束之后。 这伤害一个人的直觉。

Answer 1:

根据文档 ：

getFields()

返回包含反映此Class对象所表示的类或接口的所有可访问的公共字段Field对象的数组。 返回的数组中的元素不是排序并且不以任何特定的顺序。 如果类或接口没有可访问的公共字段，或者如果它表示一个数组类，基本类型，或者空隙此方法返回长度为0的数组。

getMethods()

返回包含反射的类或接口的该Class对象表示所有的公共成员方法，包括那些由类或接口和那些从超类和超接口继承的声明的方法的对象的阵列。 数组类返回所有的（公共）成员从Object类继承的方法。 返回的数组中的元素不是排序并且不以任何特定的顺序。 如果该类对象表示一个类或接口没有公共成员方法，或者如果该类对象表示一个基本类型或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（）的返回结果中没有特定的顺序，可以添加在返回数组的集合中的元素，并提供自己的比较对它们进行排序不过你想要的。

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

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()));
    }

}

文章来源: Java reflection: Is the order of class fields and methods standardized?