module modulename {}

public interface AnnotatedConstruct {
    // 返回当前结构直接持有的注解
    List<? extends AnnotationMirror> getAnnotationMirrors();
    /**
     * 根据注解类型返回注解，注意获取的结果 Annotation 中包含了 Class 对象
     * 但是该 Class 对象无法用于定位和加载相关类。尝试做这些操作时，会抛出
     * MirroredTypesException 异常
     * 
     * 注意该方法是对运行时的注解信息进行操作
     */
    <A extends Annotation> A getAnnotation(Class<A> annotationType);
    /**
     * 功能同上，该方法可以额外检测可重复的注解(java8 新特性)
     */
    <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType);
}

import java.lang.annotation.*;
import static java.lang.annotation.RetentionPolicy.*;
import javax.lang.model.element.*;
import static javax.lang.model.element.NestingKind.*;

@Retention(RUNTIME)
@interface Nesting {
    NestingKind value();
}

interface Shape {
   String name();
}

// NestingExamples 是 TOP_LEVEL 顶层类
@Nesting(TOP_LEVEL)
public class NestingExamples {
    // 静态类 MemberClass1 是 MEMBER 成员类
    @Nesting(MEMBER)
    static class MemberClass1{}

    @Nesting(MEMBER)
    class MemberClass2{}

    public static void main(String... argv) {
        // LocalClass 是局部类
        @Nesting(LOCAL)
        class LocalClass{};
        // new 接口是匿名类
        @Nesting(ANONYMOUS)
        Shape circle = new Shape() {
            @Override
            public String name() {
                return null;
            }
        }
        // 其他代码省略
    }
}

public interface Element extends AnnotatedConstruct {
    // 返回此元素相关的 Type
    TypeMirror asType();
    // 返回此元素的种类
    ElementKind getKind();
    // 返回此元素的修饰符(不包括注解)
    Set<Modifier> getModifiers();
    // 返回此元素的名称(作用同 Class 类中的一致)
    Name getSimpleName();
    // 返回包含此元素的最里面的元素
    Element getEnclosingElement();
    // 返回此元素包含的元素
    List<? extends Element> getEnclosedElements();
    // Object 中定义的方法
    boolean equals(Object var1);
    // Object 中定义的方法
    int hashCode();
    // 父类 AnnotatedConstruct 定义的方法
    List<? extends AnnotationMirror> getAnnotationMirrors();
    // 父类 AnnotatedConstruct 定义的方法
    <A extends Annotation> A getAnnotation(Class<A> var1);
    // 父类 AnnotatedConstruct 定义的方法
    <R, P> R accept(ElementVisitor<R, P> var1, P var2);
}

public interface Parameterizable extends Element {
    // 获取泛型参数列表
    List<? extends TypeParameterElement> getTypeParameters();
}

public interface QualifiedNameable extends Element {
    // 元素的全限定名称
    Name getQualifiedName();
}

public interface VariableElement extends Element {
    // 获取被视为编译时常量的 final 字段的值
    // 如果不是编译时常量，则返回 null。
    Object getConstantValue();
    // 返回当前变量元素的简单名称
    @Override
    Name getSimpleName();
    // 获取包含当前元素的元素
    // 方法或构造函数参数的外层元素是声明参数的 ExecutableElement
    @Override
    Element getEnclosingElement();
}

public interface TypeParameterElement extends Element {
    // 返回由包含此类型参数(泛型参数)的泛型类、接口、方法或构造函数。
    Element getGenericElement();
    // 返回此类型参数的边界。由泛型的 extends 子句指定。
    // 如果没有使用 extends 子句，那么结果是 java.lang.Object。
    List<? extends TypeMirror> getBounds();
    // 返回包含此元素的元素，作用同 getGenericElement 方法
    @Override
    Element getEnclosingElement();
}

public interface ModuleElement extends Element, QualifiedNameable {
    // 返回模块的全限定名
    @Override
    Name getQualifiedName();
    // 返回模块的名称
    @Override
    Name getSimpleName();
    // 返回当前元素包含的元素
    @Override
    List<? extends Element> getEnclosedElements();
    // 判断 module 是否是 open 的
    boolean isOpen();
    // 判断是否是未命名的模块
    boolean isUnnamed();
    // 返回包含当前元素的元素
    @Override
    Element getEnclosingElement();
    // 返回模块声明中包含的指令
    List<? extends Directive> getDirectives();
    // 模块指令类型枚举
    enum DirectiveKind {
        REQUIRES,
        EXPORTS,
        OPENS,
        USES,
        PROVIDES
    };
    // 代表模块指令
    interface Directive {
        // 指令类型
        DirectiveKind getKind();
        // 将指令访问器应用到当前指令上
        <R, P> R accept(DirectiveVisitor<R, P> v, P p);
    }
    // 指令访问器
    interface DirectiveVisitor<R, P> {
        default R visit(Directive d) {
            return d.accept(this, null);
        }
        default R visit(Directive d, P p) {
            return d.accept(this, p);
        }
        R visitRequires(RequiresDirective d, P p);
        R visitExports(ExportsDirective d, P p);
        R visitOpens(OpensDirective d, P p);
        R visitUses(UsesDirective d, P p);
        R visitProvides(ProvidesDirective d, P p);
        default R visitUnknown(Directive d, P p) {
            throw new UnknownDirectiveException(d, p);
        }
    }
    // Requires 指令
    interface RequiresDirective extends Directive {
        boolean isStatic();
        boolean isTransitive();
        ModuleElement getDependency();
    }
    // Exports 指令
    interface ExportsDirective extends Directive {
        PackageElement getPackage();
        List<? extends ModuleElement> getTargetModules();
    }
    // Opens 指令
    interface OpensDirective extends Directive {
        PackageElement getPackage();
        List<? extends ModuleElement> getTargetModules();
    }
    // Provides 指令
    interface ProvidesDirective extends Directive {
        TypeElement getService();
        List<? extends TypeElement> getImplementations();
    }
    // Uses 指令
    interface UsesDirective extends Directive {
        TypeElement getService();
    }
}

public interface PackageElement extends Element, QualifiedNameable {
    // 返回包的全限定名
    Name getQualifiedName();
    // 返回包名
    @Override
    Name getSimpleName();
    // 返回当前元素包含的元素
    @Override
    List<? extends Element> getEnclosedElements();
    // 判断是否是未命名的包
    boolean isUnnamed();
    // 返回包含当前元素的元素
    @Override
    Element getEnclosingElement();
}

public interface TypeElement extends Element, Parameterizable, QualifiedNameable {
    // 返回当前元素包含的元素
    // 注意包含强制元素(比如构造函数和枚举的枚举值和 valueOf 方法)
    @Override
    List<? extends Element> getEnclosedElements();
    // 返回当前元素的 NestingKind(类的类型)
    NestingKind getNestingKind();
    // 返回当前元素的全限定名，但不包含泛型信息
    // 比如 java.util.Set<E> 返回的是 "java.util.Set"
    Name getQualifiedName();
    // 返回元素的名称
    @Override
    Name getSimpleName();
    // 返回当前元素的直接父类。如果当前元素表示接口或java.lang.Object 类，
    // 则返回分类为 TypeKind.NONE 的 NoType
    TypeMirror getSuperclass();
    // 返回类或接口直接实现的接口类型    
    List<? extends TypeMirror> getInterfaces();
    // 按声明顺序返回类型参数。
    List<? extends TypeParameterElement> getTypeParameters();
    // 返回包含当前元素的元素
    @Override
    Element getEnclosingElement();
}

public interface ExecutableElement extends Element, Parameterizable {
    // 按声明顺序返回当前元素的实际类型参数(泛型参数)列表
    List<? extends TypeParameterElement> getTypeParameters();
    // 返回当前元素的返回类型。如果元素不是方法，或者是不返回值的方法，
    // 则返回类型为 TypeKind.VOID 的 NoType。
    TypeMirror getReturnType();
    // 按声明顺序返回当前元素的参数列表
    List<? extends VariableElement> getParameters();
    // 返回当前元素的接收者类型，java 8 新特性
    TypeMirror getReceiverType();
    // 返回方法或构造函数是否接受可变长度的参数
    boolean isVarArgs();
    // 判断方法是否是默认方法，java 8 新特性
    // 详见 https://www.cnblogs.com/huahuayu/p/12390338.html
    boolean isDefault();
    // 按声明顺序返回方法或构造函数的 throws 子句中列出的异常
    List<? extends TypeMirror> getThrownTypes();
    // 返回注解的默认值。如果不是注解或者注解无默认值，则返回 null。
    AnnotationValue getDefaultValue();
    // 返回方法、构造函数、init 代码块的名称
    @Override
    Name getSimpleName();
}

interface ParameterizedType extends Type {
     //获取参数类型 <> 里面的那些值, 例如 Map.Entry<K,V> 的 [K,V] 数组
     Type[] getActualTypeArguments(); 
     //获取参数类型 <> 前面的值，例如 Map.Entry<K,V> 的 MMap.Entry
     Type getRawType();
     //获取所属类的类型，如 Map.Entry<K,V> 的 Map
     Type getOwnerType();
}

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.*;

public class Test {
    public TypeTest.Pair<String, Long> entry = new TypeTest.Pair<>();
    public static void main(String[] args) throws NoSuchFieldException {
        Class clz = Test.class;
        // getGenericType 获取变量的声明类型
        Type genericType2 = clz.getField("entry").getGenericType();

        // 输出结果：TypeTest$Pair<java.lang.String, java.lang.Long>
        System.out.println("参数类型2: " + genericType2.getTypeName());

        if (genericType2 instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) genericType2;
            Type[] types = pType.getActualTypeArguments();

            // 输出结果：[class java.lang.String, class java.lang.Long]
            System.out.println("参数类型列表: " + Arrays.asList(types));
            // 输出结果：class TypeTest$Pair
            System.out.println("参数原始类型: " + pType.getRawType());
            // 输出结果：class TypeTest
            System.out.println("参数父类类型: " + pType.getOwnerType());
        }
    }
}

class TypeTest {
    static class Pair<K, V> {
        public Map<K, V> map = new HashMap<>();
    }
}

> Task :Test.main()

参数类型2: TypeTest$Pair<java.lang.String, java.lang.Long>
参数类型列表: [class java.lang.String, class java.lang.Long]
参数原始类型: class TypeTest$Pair
参数父类类型: class TypeTest

public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
    // 返回此类型参数的上界列表，如果没有上界则放回Object
    // 例如  V extends Number & Serializable
    // 有两个上界，Number 和 Serializable
    Type[] getBounds();
    // 类型参数声明时的载体，
    // 例如 class TypeTest<T, V extends Number & Serializable>，
    // 那么 V 的载体就是TypeTest
    D getGenericDeclaration();

    String getName();
    // Java 1.8 加入了 AnnotatedType
    // 如果泛型参数类型的上界(extends)用注解标记了，
    // 我们可以通过它拿到相应的注解
    AnnotatedType[] getAnnotatedBounds();
}

java.lang.reflect.Method,
java.lang.reflect.Constructor，
java.lang.Class

import java.lang.reflect.*;
import java.util.*;

public class Test {
    public static void main(String[] args) throws NoSuchFieldException {
        Class clz = TypeTest.Pair.class;
        // getGenericType 获取变量的声明类型
        Type mapType = clz.getField("map").getGenericType();

        // 输出结果：java.util.Map<K, V>
        System.out.println("声明类型: " + mapType.getTypeName());

        if (mapType instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) mapType;
            Type[] types = pType.getActualTypeArguments();

            List<String> names = new ArrayList<>();
            for (Type type : types) {
                names.add(type.getClass().getSimpleName());
            }

            // 输出结果：[K, V]
            System.out.println("参数类型列表: " + Arrays.asList(types));
            // [TypeVariableImpl, TypeVariableImpl]
            System.out.println("实际类型列表: " + names);
        }

        System.out.println("\n===================================");

        // getGenericType 获取变量的声明类型
        Type valueType = clz.getField("value").getGenericType();
        // 输出结果：java.util.Map<K, V>
        System.out.println("声明类型: " + valueType.getTypeName());
        if (valueType instanceof TypeVariable) {
            TypeVariable pType = (TypeVariable) valueType;
            System.out.println("实际类型: " + pType.getGenericDeclaration());
        }
    }
}

class TypeTest {
    static class Pair<K, V> {
        public Map<K, V> map = new HashMap<>();

        public V value = null;
    }
}

> Task :Test.main()

声明类型: java.util.Map<K, V>
参数类型列表: [K, V]
实际类型列表: [TypeVariableImpl, TypeVariableImpl]

===================================
声明类型: V
实际类型: class TypeTest$Pair

public interface WildcardType extends Type {
    // 如果有extends 则返回的是extends对象的type 否则是[object]
    Type[] getUpperBounds();
    // 如果有super 则返回的是super 对象的type 否则是[]
    Type[] getLowerBounds();
}

import java.lang.reflect.*;
import java.util.*;

public class Test {
    public static void main(String[] args) throws NoSuchFieldException {
        Class c = TypeTest.class;
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            ParameterizedType type = (ParameterizedType) field.getGenericType();
            for (Type type1 : type.getActualTypeArguments()) {
                System.out.println("getTypeName():  " + type1.getTypeName());
                if (type1 instanceof WildcardType) {
                    System.out.println("getUpperBounds(): " + Arrays.toString(((WildcardType) type1).getUpperBounds()));
                    System.out.println("getLowerBounds(): " + Arrays.toString(((WildcardType) type1).getLowerBounds()));
                    System.out.println("===========================");
                }
            }
        }
    }
}

class TypeTest {
    List<? extends String> sList;//属于WildcardType
    List<?> list;//属于WildcardType
    List<? super Integer> iList;//属于WildcardType
}

> Task :Test.main()

getTypeName():  ? extends java.lang.String
getUpperBounds(): [class java.lang.String]
getLowerBounds(): []
===========================
getTypeName():  ?
getUpperBounds(): [class java.lang.Object]
getLowerBounds(): []
===========================
getTypeName():  ? super java.lang.Integer
getUpperBounds(): [class java.lang.Object]
getLowerBounds(): [class java.lang.Integer]
===========================

public interface GenericArrayType extends Type {
    // 返回改数组类型元素的类型，例如T[] 返回的是T
    Type getGenericComponentType();
}

public class Test {
    public static void main(String[] args) throws NoSuchFieldException {
        Class c = TypeTest.class;
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            Type type = field.getGenericType();
            if (type instanceof GenericArrayType) {
                System.out.println(((GenericArrayType) type).getGenericComponentType());
            }
            System.out.println("==================================");
        }

    }
}

class TypeTest<T> {
    T[] ts;
    List<String>[] lists;
}

> Task :Test.main()

T
==================================
java.util.List<java.lang.String>
==================================

try {
     // 代码省略
} catch (Exception1 | Exception2 ex) {
     // Exception1 | Exception2 中的 | 就是 UNION 类型
}

class ChildC<T extends ClassA & InterfaceB> {
    // T extends ClassA & InterfaceB 中的 & 就是 INTERSECTION 类型
}

public interface TypeMirror extends AnnotatedConstruct {
    // 获取 type 的类型
    TypeKind getKind();
    // 将访问器应用到当前 type 上
    <R, P> R accept(TypeVisitor<R, P> var1, P var2);

    boolean equals(Object var1);
    int hashCode();
    String toString();
}

public interface ArrayType extends ReferenceType {
    // 返回数组内包含的元素的类型
    TypeMirror getComponentType();
}

public interface DeclaredType extends ReferenceType {
    // 返回此 type 对应的元素，详见 TypeElement 的讲解
    Element asElement();
    // 返回包含此 type 的 type，只有内部类才有结果
    // 无对应的结果则返回类型为 TypeKind.NONE 的 NoType。
    TypeMirror getEnclosingType();
    // 返回此类型的实际类型参数。
    // 对于嵌套在参数化类型(parameterized type，即泛型)中的类型，
    // 例如 Outer<String>.Inner<Number>，仅包括 Inner 的类型参数
    List<? extends TypeMirror> getTypeArguments();
}

public interface ExecutableType extends TypeMirror {
    // 返回当前可执行类型的泛型参数声明的泛型变量
    List<? extends TypeVariable> getTypeVariables();
    // 同 ExecutableElement 中的方法
    TypeMirror getReturnType();
    // 返回当前可执行类型的泛型参数的类型
    List<? extends TypeMirror> getParameterTypes();
    // 同 ExecutableElement 中的方法
    TypeMirror getReceiverType();
    // 同 ExecutableElement 中的方法
    List<? extends TypeMirror> getThrownTypes();
}

public interface IntersectionType extends TypeMirror {
    // 获取泛型的边界列表
    List<? extends TypeMirror> getBounds();
}

public interface TypeVariable extends ReferenceType {
    // 返回与泛型变量对应的元素
    Element asElement();
    // 返回此类型变量的上限
    // 如果声明此类型变量时没有明确的上限，则结果为 java.lang.Object
    // 如果用多个上限声明，结果是交集类型
    TypeMirror getUpperBound();
    // 返回此类型变量的下限，无合适结果时下限为 NullType
    TypeMirror getLowerBound();
}

public interface UnionType extends TypeMirror {
    // 返回 | 的结果列表(或表达式的拆分)
    List<? extends TypeMirror> getAlternatives();
}

public interface WildcardType extends TypeMirror {
    // 返回通配符的上限。由 extends 语句定义
    TypeMirror getExtendsBound();
    // 返回通配符的下限。由 super 语句定义
    TypeMirror getSuperBound();
}

public interface Elements {
    // 根据包的全限定名返回包元素
    PackageElement getPackageElement(CharSequence name);
    // 根据包的全限定名从指定模块中返回包元素
    default PackageElement getPackageElement(
        ModuleElement module, 
        CharSequence name
    ) {
        return null;
    }
    // 根据包的全限定名获取所有包元素。不同模块可能存在多个相同名称的包元素
    default Set<? extends PackageElement> getAllPackageElements(
        CharSequence name
    ) {
       // 方法实现省略，见代码后的方法讲解
    }
    // 根据全限定名获取 TypeElement
    TypeElement getTypeElement(CharSequence name);
    // 根据全限定名从指定的模块中获取 TypeElement
    default TypeElement getTypeElement(
        ModuleElement module, 
        CharSequence name
    ) {
        return null;
    }
    // 根据全限定名获取所有类型元素，不同模块可能存在多个相同名称的类型元素
    default Set<? extends TypeElement> getAllTypeElements(CharSequence name) {
        // 代码实现省略，见代码后的方法讲解
    }
    // 根据全限定名返回对应的模块元素。如果找不到指定的模块，则返回 null
    default ModuleElement getModuleElement(CharSequence name) {
        return null;
    }
    // 获取所有模块元素
    default Set<? extends ModuleElement> getAllModuleElements() {
        return Collections.emptySet();
    }
    // 返回注解元素的值，包括默认值
    Map<? extends ExecutableElement, ? extends AnnotationValue> getElementValuesWithDefaults(
        AnnotationMirror anno
    );
    // 返回元素 e 的文档注释。文档注释以 "/**" 开头、以 "*/" 结尾
    String getDocComment(Element e);
    // 判断元素是否被弃用了
    boolean isDeprecated(Element e);
    // 返回给定元素的来源
    default Elements.Origin getOrigin(Element e) {
        return Elements.Origin.EXPLICIT;
    }
    // 根据被注解的结构获取注解元素的来源
    default Elements.Origin getOrigin(
        AnnotatedConstruct c, 
        AnnotationMirror a
    ) {
        return Elements.Origin.EXPLICIT;
    }
    // 返回指定模块指令的来源
    default Elements.Origin getOrigin(
        ModuleElement m, 
        Directive directive
    ) {
        return Elements.Origin.EXPLICIT;
    }
    // 判断方法是否是桥接方法，桥接方法是 JDK 1.5 引入泛型后，
    // 为了使 Java 的泛型方法生成的字节码和 1.5 版本前的字节码相兼容，
    // 由编译器自动生成的方法
    default boolean isBridge(ExecutableElement e) {
        return false;
    }
    // 返回元素的二进制名
    // 二进制名即元素的原名，与 TypeElement.getQualifiedName() 一样
    // 比如 Object 的 binary name 是 java.lang.Object
    // Thread 的 binary name 是 java.lang.Thread
    // 二进制名的定义可见 jls 13.1 The Form of a Binary
    Name getBinaryName(TypeElement type);
    // 返回元素对应的包。一个包元素对应的包就是它自己
    PackageElement getPackageOf(Element type);
    // 返回元素对应的模块。模块元素对应的模块就是它自己
    // 如果该元素没有对应的模块，则返回 null
    default ModuleElement getModuleOf(Element type) {
        return null;
    }
    // 返回类型元素的所有成员，无论是继承的还是直接声明的
    // 对于一个类，结果还包括它的构造函数，但不包括本地类或匿名类
    List<? extends Element> getAllMembers(TypeElement type);
    // 返回元素上存在的所有注解，无论是直接存在还是通过继承而存在
    List<? extends AnnotationMirror> getAllAnnotationMirrors(Element e);
    // 测试 hider 是否隐藏了 hidden
    // hider 和 hidden 可以是一种类型、方法或字段
    boolean hides(Element hider, Element hidden);
    // 判断 overrider 方法是否作为给定 type 的成员覆盖了 overridden 方法
    boolean overrides(
        ExecutableElement overrider, 
        ExecutableElement overridden, 
        TypeElement type
    );
    // 返回代表基本类型或字符串的常量表达式的文本
    // 返回的文本采用合适的形式表示源代码中的值
    // value 的类型是基本类型或者 String
    // 方法返回的结果同 VariableElement.getConstantValue()
    // 相关定义可见 jls 15.28 Constant Expression, 4.12.4 final Variables
    String getConstantExpression(Object value);
    // 打印 elements 的内容到 writer 中，此方法主要用于调试
    void printElements(Writer w, Element... elements);
    // 返回与 cs 内容一致的 Name 对象
    Name getName(CharSequence cs);
    // 判断元素是否是函数式接口
    // 函数式接口定义见 jls 9.8 Functional Interfaces
    boolean isFunctionalInterface(TypeElement type);
    // 元素或其他语言模型内容的来源
    public static enum Origin {
        // 显式声明
        EXPLICIT,
        // 强制构造
        MANDATED,
        // 合成构造
        SYNTHETIC;

        private Origin() {
        }
        // 判断来源是显示或隐式声明的
        public boolean isDeclared() {
            return this != SYNTHETIC;
        }
    }
}

public class ElementFilter {
    private static final Set<ElementKind> CONSTRUCTOR_KIND;
    private static final Set<ElementKind> FIELD_KINDS;
    private static final Set<ElementKind> METHOD_KIND;
    private static final Set<ElementKind> PACKAGE_KIND;
    private static final Set<ElementKind> MODULE_KIND;
    private static final Set<ElementKind> TYPE_KINDS;

    static {
        CONSTRUCTOR_KIND = Collections.unmodifiableSet(
            EnumSet.of(ElementKind.CONSTRUCTOR)
        );
        FIELD_KINDS = Collections.unmodifiableSet(
            EnumSet.of(ElementKind.FIELD, ElementKind.ENUM_CONSTANT)
        );
        METHOD_KIND = Collections.unmodifiableSet(
            EnumSet.of(ElementKind.METHOD)
        );
        PACKAGE_KIND = Collections.unmodifiableSet(
            EnumSet.of(ElementKind.PACKAGE)
        );
        MODULE_KIND = Collections.unmodifiableSet(
            EnumSet.of(ElementKind.MODULE)
        );
        TYPE_KINDS = Collections.unmodifiableSet(
            EnumSet.of(
                ElementKind.CLASS, 
                ElementKind.ENUM, 
                ElementKind.INTERFACE, 
                ElementKind.ANNOTATION_TYPE
            )
        );
    }

    private ElementFilter() {
    }
    // 返回 elements 中的字段列表
    public static List<VariableElement> fieldsIn(
        Iterable<? extends Element> elements
    ) {
        return listFilter(
            elements, 
            FIELD_KINDS, 
            VariableElement.class
        );
    }
    // 返回 elements 中的字段列表
    public static Set<VariableElement> fieldsIn(
        Set<? extends Element> elements
    ) {
        return setFilter(
            elements, 
            FIELD_KINDS, 
            VariableElement.class
        );
    }
    // 返回 elements 中的构造函数列表
    public static List<ExecutableElement> constructorsIn(
        Iterable<? extends Element> elements
    ) {
        return listFilter(
            elements, 
            CONSTRUCTOR_KIND, 
            ExecutableElement.class
        );
    }
    // 返回 elements 中的构造函数列表
    public static Set<ExecutableElement> constructorsIn(
        Set<? extends Element> elements
    ) {
        return setFilter(
            elements,
            CONSTRUCTOR_KIND,
            ExecutableElement.class
        );
    }
    // 返回 elements 中的方法列表
    public static List<ExecutableElement> methodsIn(
        Iterable<? extends Element> elements
    ) {
        return listFilter(
            elements, 
            METHOD_KIND,
            ExecutableElement.class
        );
    }
    // 返回 elements 中的方法列表
    public static Set<ExecutableElement> methodsIn(
        Set<? extends Element> elements
    ) {
        return setFilter(
            elements, 
            METHOD_KIND, 
            ExecutableElement.class
        );
    }
    // 返回 elements 中的类型列表
    public static List<TypeElement> typesIn(
        Iterable<? extends Element> elements
    ) {
        return listFilter(
            elements, 
            TYPE_KINDS, 
            TypeElement.class
        );
    }
    // 返回 elements 中的类型列表
    public static Set<TypeElement> typesIn(
        Set<? extends Element> elements
    ) {
        return setFilter(
            elements, 
            TYPE_KINDS, 
            TypeElement.class
        );
    }
    // 返回 elements 中的包列表
    public static List<PackageElement> packagesIn(
        Iterable<? extends Element> elements
    ) {
        return listFilter(
            elements, 
            PACKAGE_KIND, 
            PackageElement.class
        );
    }
    // 返回 elements 中的包列表
    public static Set<PackageElement> packagesIn(
        Set<? extends Element> elements
    ) {
        return setFilter(
            elements, 
            PACKAGE_KIND, 
            PackageElement.class
        );
    }
    // 返回 elements 中的模块列表
    public static List<ModuleElement> modulesIn(
        Iterable<? extends Element> elements
    ) {
        return listFilter(
            elements, 
            MODULE_KIND, 
            ModuleElement.class
        );
    }
    // 返回 elements 中的模块列表
    public static Set<ModuleElement> modulesIn(
        Set<? extends Element> elements
    ) {
        return setFilter(
            elements, 
            MODULE_KIND,
            ModuleElement.class
        );
    }
    // 真正的实现方法，用于获取元素中对应的数据
    private static <E extends Element> List<E> listFilter(
        Iterable<? extends Element> elements, 
        Set<ElementKind> targetKinds, 
        Class<E> clazz
    ) {
        List<E> list = new ArrayList();
        Iterator var4 = elements.iterator();

        while(var4.hasNext()) {
            Element e = (Element)var4.next();
            if (targetKinds.contains(e.getKind())) {
                list.add((Element)clazz.cast(e));
            }
        }

        return list;
    }
    // 真正的实现方法，用于获取元素中对应的数据
    private static <E extends Element> Set<E> setFilter(
        Set<? extends Element> elements, 
        Set<ElementKind> targetKinds, 
        Class<E> clazz
    ) {
        Set<E> set = new LinkedHashSet();
        Iterator var4 = elements.iterator();

        while(var4.hasNext()) {
            Element e = (Element)var4.next();
            if (targetKinds.contains(e.getKind())) {
                set.add((Element)clazz.cast(e));
            }
        }

        return set;
    }
    // 返回模块指令列表中的 exports 指令
    public static List<ExportsDirective> exportsIn(
        Iterable<? extends Directive> directives
    ) {
        return listFilter(
            directives, 
            DirectiveKind.EXPORTS, 
            ExportsDirective.class
        );
    }
    // 返回模块指令列表中的 opens 指令
    public static List<OpensDirective> opensIn(
        Iterable<? extends Directive> directives
    ) {
        return listFilter(
            directives, 
            DirectiveKind.OPENS, 
            OpensDirective.class
        );
    }
    // 返回模块指令列表中的 provides 指令
    public static List<ProvidesDirective> providesIn(
        Iterable<? extends Directive> directives
    ) {
        return listFilter(
            directives, 
            DirectiveKind.PROVIDES, 
            ProvidesDirective.class
        );
    }
    // 返回模块指令列表中的 requires 指令
    public static List<RequiresDirective> requiresIn(
        Iterable<? extends Directive> directives
    ) {
        return listFilter(
            directives, 
            DirectiveKind.REQUIRES, 
            RequiresDirective.class
        );
    }
    // 返回模块指令列表中的 uses 指令
    public static List<UsesDirective> usesIn(
        Iterable<? extends Directive> directives
    ) {
        return listFilter(
            directives, 
            DirectiveKind.USES, 
            UsesDirective.class
        );
    }
    // 真正的实现方法，用于获取模块指令中对应的指令
    private static <D extends Directive> List<D> listFilter(
        Iterable<? extends Directive> directives, 
        DirectiveKind directiveKind, 
        Class<D> clazz
    ) {
        List<D> list = new ArrayList();
        Iterator var4 = directives.iterator();

        while(var4.hasNext()) {
            Directive d = (Directive)var4.next();
            if (d.getKind() == directiveKind) {
                list.add((Directive)clazz.cast(d));
            }
        }

        return list;
    }
}

public interface Types {
    // 返回与 TypeMirror 对应的元素
    Element asElement(TypeMirror t);
    // 判断两个 TypeMirror 代表的类型是否相同
    boolean isSameType(TypeMirror t1, TypeMirror t2);
    // 判断 first 是否是 second 的子类
    // 任何类型都被认为是其自身的子类
    // subtype 的定义可以见 jls 4.10 Subtyping
    boolean isSubtype(TypeMirror first, TypeMirror second);
    // 判断 first 是否可分配给 second
    // 类似的使用理解可以见 Class.isAssignableFrom 方法
    // Assignable 的定义可以见 jls 5.2 Assignment Conversion
    boolean isAssignable(TypeMirror first, TypeMirror second);
    // 判断 first 是否包含 second
    // 具体的定义可以见 jls 4.5.1.1 Type Argument Containment and Equivalence
    boolean contains(TypeMirror first, TypeMirror second);
    // 测试 first 的签名是否是 second 的子签名
    // 方法签名由 方法名+形参列表 组成，与返回值无关
    // 方法签名的定义可以见 jls 8.4.2 Method Signature
    boolean isSubsignature(ExecutableType first, ExecutableType second);
    // 返回类型 t 的直接父类
    List<? extends TypeMirror> directSupertypes(TypeMirror t);
    // 返回类型 t 经过泛型擦除后的类型
    // 如果 t 是包或者模块，则将抛出 IllegalArgumentException
    // 类型擦除的定义详见 jls 4.6 Type Erasure
    TypeMirror erasure(TypeMirror t);
    // 返回基本类型装箱后的类型
    TypeElement boxedClass(PrimitiveType t);
    // 返回包装类型拆箱后的基本类型
    PrimitiveType unboxedType(TypeMirror t);
    // 返回对 t 进行泛型捕获转换后的类型
    // 如果 t 是可执行的类型、包或者模块，会抛出 IllegalArgumentException
    // 泛型捕获转换的定义见 jls 5.1.10 Capture Conversion
    TypeMirror capture(TypeMirror t);
    // 返回 t 对应的基本类型
    // 如果 t 不是基本类型，将抛出 IllegalArgumentException
    PrimitiveType getPrimitiveType(TypeKind kind);
    // 返回 NullType
    NullType getNullType();
    // 获取 NoType
    NoType getNoType(TypeKind kind);
    // 返回数组类型，数组中元素的类型是 componentType
    ArrayType getArrayType(TypeMirror componentType);
    // 返回一个新的通配符类型参数
    // 边界可以都不指定，也可以指定其中一个，但不能同时指定两个边界
    // 当边界不需要指定时，对应的参数传入 null 即可
    WildcardType getWildcardType(
        TypeMirror extendsBounds, 
        TypeMirror superBounds
    );
    // 返回对应于类型 typeElem 和参数 typeArgs 的 DeclaredType
    DeclaredType getDeclaredType(
        TypeElement typeElem, 
        TypeMirror... typeArgs
    );
    // 返回对应于类型 typeElem 和参数 typeArgs 的 DeclaredType
    // 该 DeclaredType 是 DeclaredType 的成员类型(member class)
    // 如果 containing 为空或者不是泛型，则该方法等价于同名的双参方法
    DeclaredType getDeclaredType(
        DeclaredType containing, 
        TypeElement typeElem, 
        TypeMirror... typeArgs
    );
    // 从 containing 类型看元素 element 的类型
    TypeMirror asMemberOf(DeclaredType containing, Element element);
}