réflexion Java: Est-ce l'ordre des champs de classe et des méthodes normalisées?

Question

En utilisant la réflexion sur les classes Java pour accéder à tous les champs, méthodes, etc.:
Y at-il un ordre normalisé de ces éléments (qui est spécifié dans une norme)?

Bien sûr, I pourrait vérifier de façon empirique, mais je dois savoir s'il est toujours même.

EDIT: J'attendirent la question: Qu'est-ce que je dois l'ordre pour;)
Longue histoire courte: J'ai des classes JAXB annotées, et ne veux pas représenter visuellement ces classes. Bien que l'ordre des attributs XML est ni pertinent pour le XML standard, ni pour JAXB, je veux avoir un certain ordre des attributs XML pour la représentation visuelle.
Par exemple: démarrage vient après la fin. Cela nuit à son intuition.

Answer 1

Selon la documentation :

getFields()

  

Retourne un tableau contenant des objets champ reflétant tous les champs publics accessibles de la classe ou de l'interface représentée par cet objet de classe. Les éléments du tableau retourné ne sont pas triés et ne sont pas dans un ordre particulier. Cette méthode retourne un tableau de longueur 0 si la classe ou de l'interface n'a pas de champ public accessible, ou si elle représente une classe de tableau , un type primitif, ou nulle.

getMethods()

  

renvoie un tableau contenant des objets réfléchissants Méthode toutes les méthodes membres publics de la classe ou de l'interface représenté par cet objet de classe, y compris celles qui sont déclarées par la classe ou l'interface et ceux hérités de superclasses et superinterfaces. les classes Array retournent toutes les méthodes membres (publiques) héritées de la classe Object. Les éléments dans le tableau de retour ne sont pas triés et ne sont pas dans un ordre particulier. Cette méthode retourne un tableau de longueur 0 si cet objet de classe représentant une classe ou d'une interface qui n'a pas de méthodes de membre du public, ou si cet objet de classe représente un type primitif ou nulle.

Answer 2

Un échantillon pour mon idée à base d'annotation.

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

Même si getFields () et getMethods () résultats de retour sans ordre particulier, vous pouvez ajouter les éléments dans les tableaux retournés aux collections et fournir votre propre Comparator pour les trier comme vous le voulez.

Dans cet exemple, je suis juste trier les champs et méthodes selon l'ordre alphabétique de leurs noms - mais vous pouvez les trier en fonction de la classe, les modificateurs déclarant, types de retour, etc. en fournissant la logique requise dans le respectif 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()));
    }

}