Fatal编程技术网
  • java/
  • Java反射：类字段和方法的顺序是否标准化？

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

java reflection

Java反射：类字段和方法的顺序是否标准化？,java,reflection,standards-compliance,Java,Reflection,Standards Compliance,使用Java类上的反射来访问所有字段、方法等： 这些元素是否有标准化的顺序（在某些标准中有规定） 当然，我可以经验性地检查它，但我需要知道它是否总是正确的 同样的 编辑： 我等待着这个问题：我需要订单做什么；） 长话短说：我有带JAXB注释的类，但不想要 直观地表示这些类。而XML属性的顺序 两者都与XML无关 标准，也不是JAXB，我希望对 视觉表现。 例如：开始在结束之后。这伤害了一个人的直觉。根据： getFields（） 返回一个数组，该数组包含反映该类对象所表示的类或接口的所有可访问公

使用Java类上的反射来访问所有字段、方法等：
这些元素是否有标准化的顺序（在某些标准中有规定）

当然，我可以经验性地检查它，但我需要知道它是否总是正确的 同样的

编辑：
我等待着这个问题：我需要订单做什么；）
长话短说：我有带JAXB注释的类，但不想要 直观地表示这些类。而XML属性的顺序 两者都与XML无关 标准，也不是JAXB，我希望对 视觉表现。
例如：开始在结束之后。这伤害了一个人的直觉。

根据：

getFields（）

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

getMethods（）

返回一个数组，该数组包含反映该类对象表示的类或接口的所有公共成员方法的方法对象，包括由类或接口声明的方法以及从超类和超接口继承的方法。数组类返回从对象类继承的所有（公共）成员方法返回的数组中的元素没有排序，也没有任何特定顺序。如果此类对象表示没有公共成员方法的类或接口，或者此类对象表示基元类型或void，则此方法返回长度为0的数组

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

}

public void打印类数据（c类）{
Field[]fieldArray=c.getFields（）；
方法[]methodArray=c.getMethods（）；
SortedSet fields=新树集（新的FieldComparator（））；
addAll（Arrays.asList（fieldArray））；
SortedSet methods=new TreeSet（new MethodComparator（））；
addAll（Arrays.asList（methodArray））；
StringBuffer b=新的StringBuffer（“全部”）；
b、 追加（c.getName（））；
b、 追加（“\n字段：\n”）；
用于（字段f：字段）{
b、 附加（“\t”）；
b、 追加（Modifier.toString（f.getModifiers（））；
b、 附加（“”）；
b、 追加（f.getType（））；
b、 附加（“”）；
b、 追加（f.getName（））；
b、 附加（“\n”）；
}
b、 追加（“\n方法：\n”）；
用于（方法m：方法）{
b、 附加（“\t”）；
b、 append（Modifier.toString（m.getModifiers（））；
b、 附加（“”）；
b、 追加（m.getReturnType（））；
b、 附加（“”）；
b、 追加（m.getName（））；
b、 附加（“”）；
对于（类参数：m.getParameterTypes（））{
b、 追加（param.getName（））；
b、 附加（“，”）；
}
b、 deleteCharAt（b.lastIndexOf（“，”）；
b、 附加（“）\n”）；
}
System.out.println（b.toString（））；
}
私有静态类FieldComparator实现Comparator{
公共整数比较（字段f1，字段f2）{
返回（f1.getName（）.compareTo（f2.getName（））；
}   
}
私有静态类MethodComparator实现Comparator{
公共整数比较（方法m1，方法m2）{
返回（m1.getName（）.compareTo（m2.getName（））；
}
}
这是我基于注释的想法的示例

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

}

公共类文件管理器{
@保留（RetentionPolicy.RUNTIME）
公共@接口顺序{
int值（）；
}
公共类{
@顺序（值=2）
公共国际领域1；
@顺序（值=1）
公共国际领域2；
//无注释
公共国际领域3；
@顺序（值=1）
public void start（）{}
@顺序（值=2）
公共void end（）{}
}
/**
*@param args
*/
公共静态void main（字符串[]args）{
Field[]fields=SomeClass.class.getFields（）；
排序（字段，新的比较器（）{
@凌驾
公共整数比较（字段o1，字段o2）{
Order or1=o1.getAnnotation（Order.class）；
Order or2=o2.getAnnotation（Order.class）；
//最后为空
if（or1！=null&&or2！=null）{
返回or1.value（）-or2.value（）；
}否则
如果（or1！=null&&or2==null）{
返回-1；
}否则
if（or1==null&&or2！=null）{
返回1；
}
返回o1.getName（）.compareTo（o2.getName（））；
}
});
用于（字段f：字段）{
System.out.println（f.getName（））；
}
方法[]方法=SomeClass.class.getMethods（）；
sort（方法，新的比较器（）{
@凌驾
公共整数比较（方法o1，方法o2）{
Order or1=o1.getAnnotation（Order.class）；
Order or2=o2.getAnnotation（Order.class）；
//最后为空
if（or1！=null&&or2！=null）{
返回or1.value（）-or2.value（）；
}否则
如果（or1！=null&&or2==null）{
返回-1；
}否则
if（or1==null&&or2！=null）{