जावा प्रतिबिंब: कक्षा क्षेत्रों और विधियों का क्रम मानकीकृत है?

Question

सभी वर्गों, विधियों आदि तक पहुंचने के लिए जावा कक्षाओं पर प्रतिबिंब का उपयोग करना:
क्या इन तत्वों का मानकीकृत क्रम (जो कुछ मानक में निर्दिष्ट है)?

बेशक, मैं इसे अनुभवी जांच सकता हूं, लेकिन मुझे यह जानने की ज़रूरत है कि यह हमेशा है।

संपादित करें:
मैं प्रश्न के लिए इंतजार कर रहे थे: क्या मैं के लिए आदेश की जरूरत है;)
लंबी कहानी कम: मैं JAXB-एनोटेट श्रेणियां होती हैं, और कोई नेत्रहीन इन कक्षाओं का प्रतिनिधित्व करना चाहते हैं। एक्सएमएल गुणों का क्रम एक्सएमएल मानक के लिए न तो प्रासंगिक है, न ही जेएक्सबी के लिए, मैं दृश्य प्रतिनिधित्व के लिए एक्सएमएल विशेषताओं का एक निश्चित आदेश चाहता हूं।
उदाहरण के लिए: अंत के बाद शुरू होता है। यह किसी के अंतर्ज्ञान को दर्द देता है।

Answer 1

the documentation के अनुसार:

getFields()

फील्ड वस्तुओं वर्ग या इस वर्ग वस्तु का प्रतिनिधित्व करती इंटरफेस के सभी सुलभ सार्वजनिक क्षेत्रों को दर्शाती युक्त एक सरणी देता है। लौटाए गए सरणी में तत्व सॉर्ट नहीं किए गए हैं और किसी भी विशेष क्रम में नहीं हैं। यह विधि लंबाई 0 की एक सरणी देता है यदि कक्षा या इंटरफ़ेस में कोई सार्वजनिक सार्वजनिक फ़ील्ड नहीं है, या यदि यह सरणी वर्ग, एक आदिम प्रकार या शून्य का प्रतिनिधित्व करता है।

getMethods()

विधि वस्तुओं सभी सार्वजनिक सदस्य वर्ग या अंतरफलक के इस वर्ग वस्तु का प्रतिनिधित्व करती उन वर्ग या इंटरफ़ेस और सुपर-क्लास से विरासत में मिली उन और द्वारा घोषित सहित तरीकों, को दर्शाती युक्त एक सरणी देता है superinterfaces। ऐरे कक्षाएं ऑब्जेक्ट क्लास से विरासत में प्राप्त सभी (सार्वजनिक) सदस्य विधियों को वापस लाती हैं। लौटाए गए सरणी में तत्व सॉर्ट नहीं किए गए हैं और किसी भी विशेष क्रम में नहीं हैं। यह विधि लंबाई 0 की एक सरणी देता है यदि यह क्लास ऑब्जेक्ट किसी वर्ग या इंटरफ़ेस का प्रतिनिधित्व करता है जिसमें कोई सार्वजनिक सदस्य विधियां नहीं हैं, या यदि यह क्लास ऑब्जेक्ट एक आदिम प्रकार या शून्य का प्रतिनिधित्व करता है।

Answer 2

हालांकि 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())); 
    } 

} 

Answer 3

मेरे एनोटेशन आधारित विचार के लिए एक नमूना।

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

}