[Java] 解析class的工具类 →→→→→进入此内容的聊天室

来自 , 2020-09-25, 写在 Java, 查看 103 次.
URL http://www.code666.cn/view/4a5a0622
  1. package com.google.reflect;
  2.  
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Modifier;
  6. import java.lang.reflect.Proxy;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9.  
  10. public class AnalyticClassInfo
  11. {
  12.  
  13.         private static String getModifier(int modifier)
  14.         {
  15.                 String result = "";
  16.                 switch (modifier)
  17.                 {
  18.                 case Modifier.PRIVATE:
  19.                         result = "private";
  20.                         break;
  21.                 case Modifier.PUBLIC:
  22.                         result = "public";
  23.                         break;
  24.                 case Modifier.PROTECTED:
  25.                         result = "protected";
  26.                         break;
  27.                 case Modifier.ABSTRACT:
  28.                         result = "abstract";
  29.                         break;
  30.                 case Modifier.FINAL:
  31.                         result = "final";
  32.                         break;
  33.                 case Modifier.NATIVE:
  34.                         result = "native";
  35.                         break;
  36.                 case Modifier.STATIC:
  37.                         result = "static";
  38.                         break;
  39.                 case Modifier.SYNCHRONIZED:
  40.                         result = "synchronized";
  41.                         break;
  42.                 case Modifier.STRICT:
  43.                         result = "strict";
  44.                         break;
  45.                 case Modifier.TRANSIENT:
  46.                         result = "transient";
  47.                         break;
  48.                 case Modifier.VOLATILE:
  49.                         result = "volatile";
  50.                         break;
  51.                 case Modifier.INTERFACE:
  52.                         result = "interface";
  53.                         break;
  54.                 default:
  55.                         break;
  56.                 }
  57.                 return result;
  58.         }
  59.  
  60.         private static void printClassDefinition(Class clz)
  61.         {
  62.                 String clzModifier = getModifier(clz.getModifiers());
  63.                 if (clzModifier != null && !clzModifier.equals(""))
  64.                 {
  65.                         clzModifier += "  ";
  66.                 }
  67.  
  68.                 String superClz = "";
  69.                 if(clz.getSuperclass()!=null)
  70.                 {
  71.                         superClz = clz.getSuperclass().getName();
  72.                         if (superClz != null && !superClz.equals(""))
  73.                         {
  74.                                 superClz = " extends " + superClz;
  75.                         }
  76.                 }
  77.                
  78.  
  79.                 Class[] interfaces = clz.getInterfaces();
  80.                 String inters = "";
  81.                 for (int i = 0; i < interfaces.length; i++)
  82.                 {
  83.                         if (i == 0)
  84.                         {
  85.                                 inters += " implements ";
  86.                         }
  87.                         inters += interfaces[i].getName();
  88.                 }
  89.  
  90.                 System.out.println(clzModifier + clz.getName() + " " + superClz + " "
  91.                                 + inters);
  92.  
  93.                 System.out.println("{");
  94.  
  95.                 System.out.println("fields:");
  96.                 Field[] fields = clz.getDeclaredFields();
  97.                 for (int i = 0; i < fields.length; i++)
  98.                 {
  99.                         String modifier = getModifier(fields[i].getModifiers());
  100.                         if (modifier != null && !modifier.equals(""))
  101.                         {
  102.                                 modifier = modifier + " ";
  103.                         }
  104.                         String fieldName = fields[i].getName();
  105.                         String fieldType = fields[i].getType().getName();
  106.                         System.out.println("    " + modifier + fieldType + " " + fieldName
  107.                                         + ";");
  108.                 }
  109.  
  110.                 System.out.println("methods:");
  111.  
  112.                 Method[] methods = clz.getDeclaredMethods();
  113.                 for (int i = 0; i < methods.length; i++)
  114.                 {
  115.                         Method method = methods[i];
  116.  
  117.                         String modifier = getModifier(method.getModifiers());
  118.                         if (modifier != null && !modifier.equals(""))
  119.                         {
  120.                                 modifier = modifier + " ";
  121.                         }
  122.  
  123.                         String methodName = method.getName();
  124.  
  125.                         Class returnClz = method.getReturnType();
  126.                         String retrunType = returnClz.getName();
  127.  
  128.                         Class[] clzs = method.getParameterTypes();
  129.                         String paraList = "(";
  130.                         for (int j = 0; j < clzs.length; j++)
  131.                         {
  132.                                 paraList += clzs[j].getName();
  133.                                 if (j != clzs.length - 1)
  134.                                 {
  135.                                         paraList += ", ";
  136.                                 }
  137.                         }
  138.                         paraList += ")";
  139.  
  140.                         clzs = method.getExceptionTypes();
  141.                         String exceptions = "";
  142.                         for (int j = 0; j < clzs.length; j++)
  143.                         {
  144.                                 if (j == 0)
  145.                                 {
  146.                                         exceptions += "throws ";
  147.                                 }
  148.  
  149.                                 exceptions += clzs[j].getName();
  150.  
  151.                                 if (j != clzs.length - 1)
  152.                                 {
  153.                                         exceptions += ", ";
  154.                                 }
  155.                         }
  156.  
  157.                         exceptions += ";";
  158.  
  159.                         String methodPrototype = modifier + retrunType + " " + methodName
  160.                                         + paraList + exceptions;
  161.  
  162.                         System.out.println("    " + methodPrototype);
  163.  
  164.                 }
  165.                 System.out.println("}");
  166.         }
  167.  
  168.        
  169.         /**
  170.          * @param args
  171.          */
  172.         public static void main(String[] args)
  173.         {
  174.                 // TODO Auto-generated method stub
  175.  
  176. //              printClassDefinition(List.class);
  177. //              printClassDefinition(Proxy.class);
  178.                 printClassDefinition(ArrayList.class);
  179.         }
  180.  
  181.        
  182. }
  183.  
  184. //java/1338

回复 "解析class的工具类"

这儿你可以回复上面这条便签

captcha