/*
Type是Java编程语言中所有类型的通用超接口。这些类型包括原始类型、参数化类型、数组类型、类型变量和基元类型。
*/

//返回描述此类型的字符串，包括有关任何类型参数的信息。@implSpec默认实现调用{@codetostring}。
default String getTypeName() {
        return toString();
    }

/*
一个容器对象，它可能包含也可能不包含非{@code null}值。如果存在值，{@code isPresent（）}返回{@code true}。如果不存在值，则该对象被视为<i>空</i>，并且{@code isPresent（）}返回{@code false}。

还提供了依赖于包含值的存在与否的其他方法，例如{@link#orElse（Object）orElse（）}（如果没有值存在，则返回默认值）和{@link#ifPresent（Consumer）ifPresent（）}（如果存在值，则执行操作）。

这是一个<a href=“../lang/doc-files/ValueBased.html“>基于值的</a>类；在{@code Optional}的实例上使用标识敏感操作（包括引用相等（{@code==}）、标识哈希代码或同步）可能会产生不可预知的结果，应避免。

{@code Optional}主要用于表示“无结果”的方法返回类型，使用{@code null}可能会导致错误。类型为{@code Optional}的变量本身不应该是{@code null}；它应该始终指向{@code Optional}实例。



*/
//通常每个虚拟机只应存在一个空实例{@link Optional#empty}。
//所以构造方法是私有的
   private Optional() {
        this.value = null;
    }
    private static final Optional<?> EMPTY = new Optional<>();

   //如果非空，则为值；如果为空，则表示不存在值
    private final T value;

//返回空的{@code Optional}实例。此{@code Optional}没有值。
//尽管这样做可能很诱人，但是要避免测试对象是否为空，方法是根据返回的实例与Optional.empty()进行{@code==}比较. 不能保证它是单例的。相反，请使用{@link#isPresent（）}。
 public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }


private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
  public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

//返回一个Optional描述给定的值，如果非null ，否则返回一个空Optional 
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }


//如果一个值存在，返回值，否则抛出NoSuchElementException 。
 public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

//如果值存在，返回true ，否则false 
 public boolean isPresent() {
        return value != null;
    }

public boolean isEmpty() {
        return value == null;
    }


//如果值存在，执行与价值给定的动作，否则什么也不做
 public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }
//如果值存在时，执行与值给定的动作，否则执行给定的基于空动作
  public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }


//如果一个值存在，并且该值给定的谓词相匹配时，返回一个Optional描述的值，否则返回一个空的Optional 
public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) {
            return this;
        } else {
            return predicate.test(value) ? this : empty();
        }
    }

//如果值存在时，返回一个Optional描述（仿佛由ofNullable ）将所述给定的映射函数的值的结果，否则返回一个空的Optional 。如果映射函数返回一个null的结果，那么这个方法返回一个空Optional 
   public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

//如果一个值存在，则返回施加给定的结果Optional荷瘤映射函数的值，否则返回一个空Optional 。此方法类似于map(Function) ，但是映射函数是一个，其结果已经是一个Optional ，并且如果被调用， flatMap不额外内包装它Optional 
public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            @SuppressWarnings("unchecked")
            Optional<U> r = (Optional<U>) mapper.apply(value);
            return Objects.requireNonNull(r);
        }
    }

  public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
        Objects.requireNonNull(supplier);
        if (isPresent()) {
            return this;
        } else {
            @SuppressWarnings("unchecked")
            Optional<T> r = (Optional<T>) supplier.get();
            return Objects.requireNonNull(r);
        }
    }

    public Stream<T> stream() {
        if (!isPresent()) {
            return Stream.empty();
        } else {
            return Stream.of(value);
        }
    }

interface OfField<F extends TypeDescriptor.OfField<F>> extends TypeDescriptor 
    
    说明继承 TypeDescriptor， 泛型是自己的子类
TypeDescriptor：    
/*
具有字段或方法类型描述符的实体

 String descriptorString();返回此实例的类型描述符字符串，该字符串必须是字段类型描述符（JVMS 4.3.2）或方法类型描述符（JVMS 4.3.3）。

*/    
    
 OfField：
/*
具有字段类型描述符的实体
*/    
//这个字段描述符描述数组类型吗？ 返回此字段描述符是否描述数组类型 
boolean isArray();

//这个字段描述符是否描述了一个基元类型（包括void），返回此字段描述符是否描述基元类型
 boolean isPrimitive();

 //如果此字段描述符描述数组类型，则返回其组件类型的描述符，否则返回{@code null}。@返回组件类型，如果此字段描述符不描述数组类型，则返回{@code null}
   F componentType();

//返回数组类型的描述符，该数组类型的组件类型由该描述符描述，@返回数组类型的描述符
F arrayType();

/*
表示<em>constable</em>的类型。constable类型的值是常量，可以在jvms4.4中描述的Java类文件的常量池中表示，并且其实例可以名义上描述为{@link ConstantDesc}。


某些常量类型在常量池中具有本机表示形式：{@link String}、{@link Integer}、{@link Long}、{@link Float}、{@link Double}、{@link Class}、{@link MethodType}和{@link MethodHandle}。类型{@link String}、{@link Integer}、{@link Long}、{@link Float}和{@link Double}作为它们自己的名义描述符；{@link Class}、{@link MethodType}和{@link MethodHandle}具有相应的命名描述符{@link ClassDesc}、{@link MethodTypeDesc}和{@link MethodHandleDesc}。

如果其他引用类型的实例可以用{@link ConstantDesc}名义形式描述自己，那么其他引用类型可以是constable。JavaSE平台API中的示例包括支持Java语言特性的类型，如{@link Enum}，以及运行时支持类，如{@link VarHandle}。它们通常用{@link DynamicConstantDesc}来描述，它描述动态生成的常量（JVM 4.4.10）。

constable类型实例的标称形式是通过{@link\#describeConstable（）}获得的。{@linkplain Constable}不需要（也可以选择不）以{@link ConstantDesc}的形式描述它的所有实例；此方法返回一个{@link Optional}可以为空，以指示无法为实例创建名义描述符。（例如，{@link methodhandle}将为直接方法句柄生成名义描述符，但不一定是由方法句柄组合器生成的那些描述符。）
*/

//如果可以构造，则返回一个{@link Optional}，其中包含此实例的名义描述符；如果无法构造，则返回空的{@link Optional}。
//@return 一个{@link Optional}包含结果的名义描述符，或者一个空的{@link Optional}（如果无法构造）。
Optional<? extends ConstantDesc> describeConstable();

/*
表示当前在此VM中运行的程序的带批注元素。此接口允许以反射方式读取注释。此接口中的方法返回的所有注释都是不可变的和可序列化的。调用方可以修改此接口方法返回的数组，而不影响返回给其他调用方的数组。

{@link#getAnnotationsByType（Class）}和{@link#getDeclaredAnnotationsByType（Class）}方法支持元素上相同类型的多个批注。如果任一方法的参数是可重复的注释类型（JLS9.6），则该方法将“浏览”容器注释（JLS9.7）（如果存在），并返回容器内的任何注释。可以在编译时生成容器注释来包装参数类型的多个注释。

术语<em>directly present</em>、<em>indirectly present</em>、<em>present</em>和<em>associated</em>在整个接口中被用来精确地描述由方法返回的注释：

如果<i>E</i>具有{@code RuntimeVisibleAnnotations}或{@code RuntimeVisibleParameterAnnotations}或{@code RuntimeVisibleTypeAnnotations}属性，并且该属性包含<i>A</i>，则注释<i>A</i>直接出现在元素<i>E</i>上。

如果<i>E</i>具有{@code RuntimeVisibleAnnotations}或{@code RuntimeVisibleParameterAnnotations}或{@code RuntimeVisibleTypeAnnotations}属性，并且<i>A</i>的类型是可重复的，则注释<i>A</i>在元素<i>E</i>上间接存在，并且该属性正好包含一个注释，其value元素包含<i>A</i>，其类型是包含<i>A</i>类型的注释类型。

注释<i>A</i>存在于元素<i>E</i>上，如果：
	<i> A</i>直接存在于<i>E</i>上；或者<i>A</i>的类型的注释不直接存在于<i>E</i>上，<i>E</i>是一个类，<i>A</i>的类型是可继承的，<i>A</i>存在于<i>E</i>的超类上。
	
注释<i>A</i>与元素<i>E</i>关联，如果：
	<i> A</i>直接或间接存在于<i>E</i>上；或<i>A</i>的类型注释不直接或间接存在于<i>E</i>上，并且<i>E</i>是一个类，<i>A</i>的类型是可继承的，<i>A</i>与<i>E</i>的超类相关联。
	
	
下表总结了此接口中不同方法检查的注释类型。

用不同的AnnotatedElement方法检测的存在类型概述,见下表


对于{@code get[Declared]AnnotationsByType（Class<T>）}的调用，计算直接或间接出现在元素<i>E</i>上的注释的顺序，就好像间接出现在<i>E</i>上的注释直接出现在<i>E</i>上，而不是它们的容器注释中，按照它们在value元素中的出现顺序容器的批注。

如果注释类型<i>T</i>最初是<em>不</em>可重复的，然后修改为可重复的，则需要记住几个兼容性问题。
<i>T</i>的包含注释类型是<i>TC</i>。：将<i>T</i>修改为可重复的是源代码和二进制代码，与现有的<i>T</i>用途以及现有的<i>TC</i>兼容。也就是说，为了源代码的兼容性，带有<i>T</i>类型或<i>TC</i>类型注释的源代码仍然可以编译。为了实现二进制兼容性，带有类型<i>T</i>或类型<i>TC</i>的注释（或具有类型<i>T</i>或类型<i>TC</i>的其他类型的使用）的类文件，如果它们链接到早期版本，则它们将链接到<i>T</i>的修改版本。

（注释类型<i>TC</i>可以非正式地充当包含注释类型的动作，然后将<i>T</i>修改为可正式重复。或者，当<i>T</i>可重复时，<i>TC</i>可以作为一种新类型引入。）

如果元素上存在注释类型<i>TC</i>，并且将<i>T</i>修改为可重复，并将<i>TC</i>作为其包含注释类型，则：
	对<i>T</i>的更改与{@code get[Declared]Annotation（Class<T>）}（用参数<i>T</i>或<i>TC</i>调用）和{@code get[Declared]Annotations（）}方法方法的结果不会因<i>TC</i>成为<i>T</i>的包含注释类型而改变。
	对<i>T</i>的更改会更改使用参数<i>T</i>调用的{@code get[Declared]AnnotationsByType（Class<T>）}方法的结果，因为这些方法现在将把<i>TC</i>类型的注释识别为<i>T</i>的容器注释，并将“查看”它以公开<i>T</i>类型的注释。
	
	
如果元素上存在<i>T</i>类型的注释，并且<i>T</i>是可重复的，并且向元素添加更多类型为<i>T</i>的注释：
	添加<i>T</i>类型的注释既与源代码兼容，又与二进制兼容。
	添加<i>T</i>类型的注释会更改{@code get[Declared]Annotation（Class<T>）}方法和{@code get[Declared]annotations（）}方法的结果，因为这些方法现在只会看到元素上的容器注释，而看不到<i>T</i>类型的注释。
	添加<i>T</i>类型的注释会更改{@code get[Declared]AnnotationsByType（Class<T>）}方法的结果，因为它们的结果将公开类型为<i>T</i>的附加注释，而以前它们只公开<i>T</i>类型的单个注释。
	
	
	
如果此接口中的方法返回的批注包含（直接或间接）引用在此VM中不可访问的类的{@link Class}值成员，则尝试通过对返回的批注调用相关的类返回方法来读取该类将导致{@link TypeNotPresentException}。

类似地，如果注释中的枚举常量不再存在于枚举类型中，则尝试读取枚举值成员将导致{@link EnumConstantNotPresentException}。

如果注释类型<i>T</i>是用{@code@Repeatable}注释（meta-）注释，其value元素表示类型<i>TC</i>，但是<i>TC</i>没有声明返回类型为<i>T</i>{@code[]}的{@code value（）}方法，那么{@link类型的异常java.lang.annotation.AnnotationFormatError}被抛出。

最后，尝试读取其定义演变不兼容的成员将导致{@link java.lang.annotation.AnnotationTypeMitchException}或{@linkjava.lang.annotation.IncompleteAnnotationException}。
*/

 default boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
        return getAnnotation(annotationClass) != null;
    }
//如果指定类型的annotation，<em>存在</em>，则返回此元素的批注，否则返回null。
//<T> 要查询并返回（如果存在）的批注的类型
//annotationClass与注释类型对应的类对象
 <T extends Annotation> T getAnnotation(Class<T> annotationClass);

//返回此元素上<em>存在的注释</em>。
//如果此元素上没有注释<em>present</em>，则返回值为长度为0的数组。
//此方法的调用方可以自由修改返回的数组；它不会影响返回给其他调用方的数组。
 Annotation[] getAnnotations();



 default <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
         /*
          * Definition of associated: directly or indirectly present OR
          * neither directly nor indirectly present AND the element is
          * a Class, the annotation type is inheritable, and the
          * annotation type is associated with the superclass of the
          * element.
          */
         T[] result = getDeclaredAnnotationsByType(annotationClass);

         if (result.length == 0 && // Neither directly nor indirectly present
             this instanceof Class && // the element is a class
             AnnotationType.getInstance(annotationClass).isInherited()) { // Inheritable
             Class<?> superClass = ((Class<?>) this).getSuperclass();
             if (superClass != null) {
                 // Determine if the annotation is associated with the
                 // superclass
                 result = superClass.getAnnotationsByType(annotationClass);
             }
         }

         return result;
     }



default <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
         Objects.requireNonNull(annotationClass);
         // Loop over all directly-present annotations looking for a matching one
         for (Annotation annotation : getDeclaredAnnotations()) {
             if (annotationClass.equals(annotation.annotationType())) {
                 // More robust to do a dynamic cast at runtime instead
                 // of compile-time only.
                 return annotationClass.cast(annotation);
             }
         }
         return null;
     }


 default <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
        Objects.requireNonNull(annotationClass);
        return AnnotationSupport.
            getDirectlyAndIndirectlyPresent(Arrays.stream(getDeclaredAnnotations()).
                                            collect(Collectors.toMap(Annotation::annotationType,
                                                                     Function.identity(),
                                                                     ((first,second) -> first),
                                                                     LinkedHashMap::new)),
                                            annotationClass);
    }

//返回直接存在于该元素上的注释。此方法忽略继承的批注。
//如果此元素上没有直接显示的注释，则返回值为长度为0的数组。此方法的调用方可以自由修改返回的数组；它不会影响返回给其他调用方的数组。
 Annotation[] getDeclaredAnnotations();

继承 AnnotatedElement
/*
所有声明类型变量的实体的公共接口。


*/
   // 按声明顺序返回{@code TypeVariable}对象的数组，这些对象表示由此{@code GenericDeclaration}对象表示的泛型声明所声明的类型变量。如果基础泛型声明未声明类型变量，则返回长度为0的数组。
    //返回{@code TypeVariable}对象的数组，表示由泛型声明声明声明的类型变量
  //@如果此泛型声明的泛型签名不符合Java&trade；虚拟机规范中指定的格式，则引发GenericSignatureFormatError
   public TypeVariable<?>[] getTypeParameters();

实现 Serializable GenericDeclaration Type AnnotatedElement   TypeDescriptor.OfField<Class<?>> Constable这些接口
    
/*
类{@code class}的实例表示正在运行的Java应用程序中的类和接口。枚举类型是一种类，注释类型是一种接口。每个数组也属于一个类，该类反映为一个{@code class}对象，该对象由具有相同元素类型和维数的所有数组共享。原语Java类型（{@code boolean}、{@code byte}、{@code char}、{@code short}、{@code int}、{@code long}、{@code float}和{@code double}）以及关键字{@code void}也表示为{@code Class}对象。

{@code Class}没有公共构造函数。相反，当类装入器调用{@link ClassLoader}defineClass（String，byte[]，int，int）defineClass}方法之一并传递{@code Class}文件的字节时，{@code Class}对象由Java虚拟机自动构造。

类{@code class}的方法公开了类或接口的许多特性。大多数特征都来自类加载器传递给Java虚拟机的{@code class}文件。一些特性由运行时的类加载环境决定，例如{@link#getModule（）getModule（）}返回的模块。

类{@codeclass}的一些方法公开了Java源代码中类或接口的声明是否包含在另一个声明中。其他方法描述类或接口如何位于嵌套中。一个nest是在同一个运行时包中的一组类和接口，它们允许相互访问它们的{@code private}成员。类和接口称为<em>nestmates</em>。一个nestmate充当<em>嵌套主机</em>，并枚举属于该嵌套的其他nestmate；它们中的每一个都将其记录为嵌套主机。属于一个嵌套的类和接口，包括它的宿主，是在生成{@code class}文件时确定的，例如，Java编译器通常将一个顶级类记录为一个嵌套的宿主，其中其他成员是其声明包含在顶级类声明中的类和接口。


以下示例使用{@code Class}对象打印对象的类名：
 *     void printClassName(Object obj) {
 *         System.out.println("The class of " + obj +
 *                            " is " + obj.getClass().getName());
 *     }


还可以使用类文本获取命名类型（或void）的{@code Class}对象。请参阅Java&trade；语言规范的第15.8.2节。例如：
{@code System.out.println("The name of class Foo is: "+Foo.class.getName());}

<T> 由{@code class}对象建模的类的类型。例如，{@code的类型字符串.class}是{@code Class<String>}。使用{@code Class<？>}如果建模的类未知。

*/    
 private static final int ANNOTATION= 0x00002000;
    private static final int ENUM      = 0x00004000;
    private static final int SYNTHETIC = 0x00001000;  

private static native void registerNatives();
    static {
        //就是把 当前Class注册到Native
        registerNatives();
    }

/*
     * 私有构造函数。只有Java虚拟机创建类对象。并阻止构造函数被生成，并且不使用默认构造函数。
     */
    private Class(ClassLoader loader, Class<?> arrayComponentType) {
        // 初始化类加载器的最终字段。非null的初始化值可防止将来的JIT优化假定最后一个字段为null。
        classLoader = loader;
        componentType = arrayComponentType;
    }

   public String toString() {
        return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
            + getName();
    }
   static String typeVarBounds(TypeVariable<?> typeVar) {
        Type[] bounds = typeVar.getBounds();
        if (bounds.length == 1 && bounds[0].equals(Object.class)) {
            return typeVar.getName();
        } else {
            return typeVar.getName() + " extends " +
                Stream.of(bounds).map(Type::getTypeName).
                collect(Collectors.joining(" & "));
        }
    }

 public String toGenericString() {
        if (isPrimitive()) {
            return toString();
        } else {
            StringBuilder sb = new StringBuilder();
            Class<?> component = this;
            int arrayDepth = 0;

            if (isArray()) {
                do {
                    arrayDepth++;
                    component = component.getComponentType();
                } while (component.isArray());
                sb.append(component.getName());
            } else {
                // Class modifiers are a superset of interface modifiers
                int modifiers = getModifiers() & Modifier.classModifiers();
                if (modifiers != 0) {
                    sb.append(Modifier.toString(modifiers));
                    sb.append(' ');
                }

                if (isAnnotation()) {
                    sb.append('@');
                }
                if (isInterface()) { // Note: all annotation types are interfaces
                    sb.append("interface");
                } else {
                    if (isEnum())
                        sb.append("enum");
                    else
                        sb.append("class");
                }
                sb.append(' ');
                sb.append(getName());
            }

            TypeVariable<?>[] typeparms = component.getTypeParameters();
            if (typeparms.length > 0) {
                sb.append(Stream.of(typeparms).map(Class::typeVarBounds).
                          collect(Collectors.joining(",", "<", ">")));
            }

            for (int i = 0; i < arrayDepth; i++)
                sb.append("[]");

            return sb.toString();
        }
    }



//返回与具有给定字符串名称的类或接口关联的{@code Class}对象。调用此方法相当于：
// {@code Class.forName(className, true, currentLoader)}
//其中{@code currentLoader}表示当前类的定义类装入器
//例如，下面的代码片段返回名为{@code的类的运行时{@code Class}描述符java.lang.Thread}:
// {@code Class t = Class.forName("java.lang.Thread")}
 @CallerSensitive
    public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }
//使用给定的类装入器，返回与具有给定字符串名称的类或接口关联的{@code Class}对象。给定一个类或接口的完全限定名（使用{@codegetname}返回的相同格式），该方法尝试定位、加载和链接该类或接口。指定的类装入器用于加载类或接口。如果参数{@code loader}为空，则通过引导类装入器加载类。只有当{@code initialize}参数为{@code true}并且之前没有初始化它时，才初始化该类。
//如果{@code name}表示基元类型或void，则将尝试在未命名包中查找名称为{@code name}的用户定义类。因此，此方法不能用于获取表示基元类型或void的{@code Class}对象
//如果{@code name}表示数组类，则数组类的组件类型已加载但未初始化。
//例如，在实例方法中，表达式：{@code Class.forName("Foo")}相当于{@code Class.forName("Foo", true, this.getClass().getClassLoader())}
//注意，这个方法抛出与加载、链接或初始化相关的错误，如Java语言规范<em>第12.2、12.3和12.4节所述。请注意，此方法不检查请求的类是否可由其调用者访问。
 @CallerSensitive
    public static Class<?> forName(String name, boolean initialize,
                                   ClassLoader loader)
        throws ClassNotFoundException
    {
        Class<?> caller = null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            // Reflective call to get caller class is only needed if a security manager
            // is present.  Avoid the overhead of making this call otherwise.
            caller = Reflection.getCallerClass();
            if (loader == null) {
                ClassLoader ccl = ClassLoader.getClassLoader(caller);
                if (ccl != null) {
                    sm.checkPermission(
                        SecurityConstants.GET_CLASSLOADER_PERMISSION);
                }
            }
        }
        return forName0(name, initialize, loader, caller);
    }

    /** Called after security check for system loader access checks have been made. */
    private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)
        throws ClassNotFoundException;



//返回给定模块中具有给定二进制名称的{@code Class}。
// 此方法尝试定位、加载和链接类或接口。它不运行类初始值设定项。如果找不到该类，则此方法返回{@code null}。
//如果给定模块的类装入器定义了其他模块，并且给定的名称是另一个模块中定义的类，则该方法在类加载后返回{@code null}。
//此方法不检查其调用者是否可以访问所请求的类。
//此方法在失败时返回{@code null}，而不是抛出一个{@link ClassNotFoundException}，就像{@link#forName（String，boolean，ClassLoader）}方法所做的那样。如果调用者在另一个模块中加载一个类，则安全检查是基于堆栈的权限检查。
 public static Class<?> forName(Module module, String name) {
        Objects.requireNonNull(module);
        Objects.requireNonNull(name);

        ClassLoader cl;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            Class<?> caller = Reflection.getCallerClass();
            if (caller != null && caller.getModule() != module) {
                // if caller is null, Class.forName is the last java frame on the stack.
                // java.base has all permissions
                sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
            }
            PrivilegedAction<ClassLoader> pa = module::getClassLoader;
            cl = AccessController.doPrivileged(pa);
        } else {
            cl = module.getClassLoader();
        }

        if (cl != null) {
            return cl.loadClass(module, name);
        } else {
            return BootLoader.loadClass(module, name);
        }
    }







//创建由{@code class}对象表示的类的新实例。类被实例化，就像是由带有空参数列表的{@code new}表达式实例化的。如果类尚未初始化，则初始化该类。
//此方法传播由空构造函数引发的任何异常，包括已检查的异常。使用此方法可以有效地绕过编译器执行的编译时异常检查。这个 构造函数.newInstance方法通过将构造函数引发的任何异常包装到（选中的）InvocationTargetException中，可以避免此问题。
//clazz.newInstance()将被替换成clazz.getDeclaredConstructor().newInstance()
//后一个调用序列被推断为能够抛出其他异常类型{@link InvocationTargetException}和{@link NoSuchMethodException}。这两个异常类型都是{@link ReflectiveOperationException}的子类。
 public T newInstance()
        throws InstantiationException, IllegalAccessException


     //确定指定的{@code Object}是否与此{@code Class}表示的对象赋值兼容。这个方法是Java语言{@code instanceof}操作符的动态等价物。如果指定的{@code Object}参数非空，并且可以转换为此{@code Class}对象表示的引用类型，则该方法返回{@code true}，而不引发{@code ClassCastException。}否则返回{@code false}。
     //具体地说，如果这个{@code Class}对象表示一个已声明的类，则如果指定的{@code object}参数是所表示类（或其任何子类）的实例，则此方法返回{@code true}；否则返回{@code false}。如果这个{@code Class}对象表示数组类，如果指定的{@code object}参数可以通过标识转换或扩展引用转换转换转换为数组类的对象，则此方法返回{@code true}；否则返回{@code false}。如果这个{@code Class}对象表示一个接口，则如果指定的{@code object}参数的类或任何超类实现了此接口，则此方法返回{@code true}；否则返回{@code false}。如果这个{@code Class}对象表示一个基元类型，这个方法返回{@code false}。
@HotSpotIntrinsicCandidate
    public native boolean isInstance(Object obj);

//确定此{@code class}对象表示的类或接口是否与指定的{@code class}参数所表示的类或接口相同，还是其超类或超接口。如果是，则返回{@code true}；否则返回{@code false}。如果这个{@code Class}对象表示一个基元类型，如果指定的{@code Class}参数正是这个{@code Class}对象，则此方法返回{@code true}；否则返回{@code false}。
// 具体地说，此方法测试指定的{@code Class}参数表示的类型是否可以通过标识转换或扩展引用转换转换转换为此{@code Class}对象表示的类型。有关详细信息，请参见Java语言规范第5.1.1和5.1.4节。
    public native boolean isAssignableFrom(Class<?> cls);

//确定指定的{@code Class}对象是否表示接口类型。
public native boolean isInterface();
//确定指定的{@code Class}对象是否表示数组类型。
public native boolean isArray();
//确定指定的{@code Class}对象是否表示基元类型。
 public native boolean isPrimitive();
////确定指定的{@code Class}对象是否表示注解类型。
 public boolean isAnnotation() {
        return (getModifiers() & ANNOTATION) != 0;
    }
/*
public Class OutClass{
    private static class InnerClass {
        synthetic OutClass this$0;
        public InnerClass(OutClass args) {

            this.this$0 =args;
        }

        private int x;

        synthetic static void access$1(int x) { this.x=x; }
        synthetic static int access$2(int x) { return x }

        private void y() {
        };
        synthetic static int access$3() { y() }
    }
}    
所有说，等于是为了获取我们的x写了getter/setter方法。为了调用 y（）写了一个嵌套的调用方法….
真是用心良苦啊…..
看完了上文，我们知道了，原来内部类在编译的时候为了给外部类调用，提供了几个静态方法给外部类使用。
补充点：（很重要啊）
1. 如果将y方法的修饰词改为public，就不会出现access$3()合成方法，对x也是同理。；

2.当你对x只赋值，不调用时，或者只调用，不赋值。只会产生相应的getter或setter方法；

3.将构造函数变为private 也会生成一个非静态的合成方法，如下：

synthetic  void  OutClass$InnerClass(OuClass this$0) {  }
归根结底，作为一个Android的coder。那么多的static方法不适合移动的不算充裕的内存。因此Google不提倡使用私有内部类，最好将其拆开独立成一个Class。还有内部类尽量改为静态内部类，可以避免内存泄漏。有空看看google 的性能建议文档还是挺不错的！
*/
  public boolean isSynthetic() {
        return (getModifiers() & SYNTHETIC) != 0;
    }


//以{@code String}形式返回由{@code class}对象表示的实体（类、接口、数组类、基元类型或void）的名称。
//如果该类对象表示不是数组类型的引用类型，则返回该类的二进制名称，如Java&trade；语言规范指定的那样
//如果这个类对象表示一个基元类型或void，那么返回的名称是{@code String}，相当于对应于基元类型或void的Java语言关键字。
//如果这个class对象表示一个数组类，那么名称的内部形式是由元素类型的名称前面加上一个或多个'{@code[}'字符组成，表示数组嵌套的深度。元素类型名称的编码如下：
/*
Element Type	Encoding
boolean	            Z
byte	            B
char	            C
class or interface	Lclassname;
double	            D
float	            F
int	                I
long	            J
short	            S
类或接口名<i>classname</i>是上面指定的类的二进制名称。

     * String.class.getName()
     *     returns "java.lang.String"
     * byte.class.getName()
     *     returns "byte"
     * (new Object[3]).getClass().getName()
     *     returns "[Ljava.lang.Object;"
     * (new int[3][4][5][6][7][8][9]).getClass().getName()
     *     returns "[[[[[[[I"
*/
   public String getName() {
        String name = this.name;
        return name != null ? name : initClassName();
    }
    // Cache the name to reduce the number of calls into the VM. This field would be set by VM itself during initClassName call.
    private transient String name;
    private native String initClassName();



//返回类的类装入器。有些实现可能使用null来表示引导类装入器。如果这个类是由引导类装入器加载的，则此方法将在此类实现中返回null。
//如果此对象表示基元类型或void，则返回null。
 public ClassLoader getClassLoader() {
        ClassLoader cl = getClassLoader0();
        if (cl == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());
        }
        return cl;
    }
    // Initialized in JVM not by private constructor This field is filtered from reflection access, i.e. getDeclaredField will throw NoSuchFieldException
    private final ClassLoader classLoader;
    // Package-private to allow ClassLoader access
    ClassLoader getClassLoader0() { return classLoader; }



//返回该类或接口所属的模块。
//如果该类表示数组类型，则此方法返回元素类型的{@code Module}。如果该类表示基元类型或void，则java.base版返回模块。
//如果这个类在一个未命名的模块中，则返回该类的类加载器的{@linkplain ClassLoader#getUnnamedModule（）unnamed}{@code module}。
   public Module getModule() {
        return module;
    }
    // set by VM
    private transient Module module;


//返回{@code Class}，表示由{@code Class}表示的实体（类、接口、基元类型或void）的直接超类。如果这个{@code Class}表示{@code Object}类;  接口、基元类型或void，则返回null。
//如果此对象表示数组类，则返回表示{@code object}类的{@code class}对象。
    public native Class<? super T> getSuperclass();


//返回{@code Type}，表示由{@code class}表示的实体（类、接口、基元类型或void）的直接超类。
//如果超类是参数化类型，则返回的{@code type}对象必须准确地反映源代码中使用的实际类型参数。如果之前没有创建过表示超类的参数化类型，则会创建该类型。有关参数化类型的创建过程的语义，请参阅parameteredType的声明。如果这个{@code Class}表示{@code Object}类、接口、基元类型或void，则返回null。如果此对象表示数组类，则返回表示{@code object}类的{@code class}对象。
public Type getGenericSuperclass() {
        ClassRepository info = getGenericInfo();
        if (info == null) {
            return getSuperclass();
        }

        // Historical irregularity:
        // Generic signature marks interfaces with superclass = Object
        // but this API returns null for interfaces
        if (isInterface()) {
            return null;
        }

        return info.getSuperclass();
    }

//an array type, a primitive type or void, 返回null
 public Package getPackage() {
        if (isPrimitive() || isArray()) {
            return null;
        }
        ClassLoader cl = getClassLoader0();
        return cl != null ? cl.definePackage(this)
                          : BootLoader.definePackage(this);
    }

// 如果该类是顶级类，则此方法返回该类所属包的完全限定名，如果该类位于未命名的包中，则返回空字符串。如果该类是成员类，则此方法等效于对{@linkplain getEnclosingClass enclosing class}调用{@code getPackageName（）}。
//如果这个类是{@linkplain isLocalClass本地类}或{@linkplain isAnonymousClass（）匿名类}，则此方法等效于对{@linkplain getenclosuringmethod enclosuring method}或{@linkplain getenclosuringconstructor including constructor}的{@linkplain}getDeclaringClass声明类}。
// 如果此类表示数组类型，则此方法返回元素类型的包名称。如果这个类表示基元类型或void，则包名“{@codejava.lang }“返回。
 public String getPackageName() {
        String pn = this.packageName;
        if (pn == null) {
            Class<?> c = this;
            while (c.isArray()) {
                c = c.getComponentType();
            }
            if (c.isPrimitive()) {
                pn = "java.lang";
            } else {
                String cn = c.getName();
                int dot = cn.lastIndexOf('.');
                pn = (dot != -1) ? cn.substring(0, dot).intern() : "";
            }
            this.packageName = pn;
        }
        return pn;
    }

    // cached package name
    private transient String packageName;



//返回由该对象表示的类或接口直接实现的接口。
//如果此对象表示一个类，则返回值是一个数组，该数组包含表示该类直接实现的所有接口的对象。数组中接口对象的顺序与此对象表示的类的声明的{@code implements}子句中接口名称的顺序相对应。例如，给定声明：
/*
{@code class Shimmer implements FloorWax, DessertTopping { ... }}
假设{@code s}的值是{@code Shimmer}的一个实例；表达式的值：
{@code s.getClass().getInterfaces()[0]}是表示接口{@code FloorWax}的{@code Class}对象
以及以下值：@code s.getClass().getInterfaces()[1]}是{@code DessertTopping}的{@code Class}对象

如果此对象表示接口，则数组包含表示接口直接扩展的所有接口的对象。数组中接口对象的顺序与此对象表示的接口声明的{@code extends}子句中接口名称的顺序相对应。

如果此对象表示不实现接口的类或接口，则该方法返回长度为0的数组。

如果此对象表示基元类型或void，则该方法返回长度为0的数组。

如果这个{@code Class}对象表示数组类型，则{@code Cloneable}和{@codejava.io.Serializable可序列化}按顺序返回。
*/
    public Class<?>[] getInterfaces() {
        // defensively copy before handing over to user code
        return getInterfaces(true);
    }
    private Class<?>[] getInterfaces(boolean cloneArray) {
        ReflectionData<T> rd = reflectionData();
        if (rd == null) {
            // no cloning required
            return getInterfaces0();
        } else {
            Class<?>[] interfaces = rd.interfaces;
            if (interfaces == null) {
                interfaces = getInterfaces0();
                rd.interfaces = interfaces;
            }
            // defensively copy if requested
            return cloneArray ? interfaces.clone() : interfaces;
        }
    }
    private native Class<?>[] getInterfaces0();


//返回{@code Type}，表示由该对象表示的类或接口直接实现的接口。
//如果超级接口是参数化类型，则为其返回的{@code type}对象必须准确地反映源代码中使用的实际类型参数。如果以前没有创建过表示每个超级接口的参数化类型，则会创建该类型。有关参数化类型的创建过程的语义，请参阅parameteredType的声明。
//如果此对象表示一个类，则返回值是一个数组，该数组包含表示该类直接实现的所有接口的对象。数组中接口对象的顺序与此对象表示的类的声明的{@code implements}子句中接口名称的顺序相对应。
//如果此对象表示接口，则数组包含表示接口直接扩展的所有接口的对象。数组中接口对象的顺序与此对象表示的接口声明的{@code extends}子句中接口名称的顺序相对应。

    public Type[] getGenericInterfaces() {
        ClassRepository info = getGenericInfo();
        return (info == null) ?  getInterfaces() : info.getSuperInterfaces();
    }



  public Class<?> getComponentType() {
        // 只返回数组类型。对于实例类型的类，存储可以重用。
        if (isArray()) {
            return componentType;
        } else {
            return null;
        }
    }
    private final Class<?> componentType;


//返回此类或接口的Java语言修饰符，以整数编码。修饰符由{@code public}、{@code protected}、{@code private}、{@code final}、{@code static}、{@code abstract}和{@code interface}的Java虚拟机常量组成；它们应该使用{@code Modifier}类的方法进行解码。
//如果基础类是数组类，那么它的{@code public}、{@code private}和{@code protected}修饰符与其组件类型的修饰符相同。如果这个{@code Class}表示基元类型或void，那么它的{@code public}修饰符总是{@code true}，而它的{@code protected}和{@code private}修饰符总是{@code false}。如果此对象表示数组类、基元类型或void，则其{@code final}修饰符始终为{@code true}，其接口修饰符始终为{@code false}。其其他修饰符的值不由本规范确定。修饰符编码在Java虚拟机规范中定义，表4.1。
 public native int getModifiers();

//获取此类的签名者。此类的签名者，如果没有签名者，则为null。特别是，如果此对象表示基元类型或void，则此方法返回null。
public native Object[] getSigners();


native void setSigners(Object[] signers);


//如果这个{@code Class}对象表示构造函数中的本地类或匿名类，则返回一个构造函数对象，该对象表示基础类的直接封闭构造函数。否则返回{@code null}。特别是，如果基础类是直接由类型声明、实例初始值设定项或静态初始值设定项包围的本地或匿名类，则此方法返回{@code null}。
 public Constructor<?> getEnclosingConstructor() throws SecurityException {
        EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();

        if (enclosingInfo == null)
            return null;
        else {
            if (!enclosingInfo.isConstructor())
                return null;

            ConstructorRepository typeInfo = ConstructorRepository.make(enclosingInfo.getDescriptor(),
                                                                        getFactory());
            Type []    parameterTypes   = typeInfo.getParameterTypes();
            Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];

            // Convert Types to Classes; returned types *should*
            // be class objects since the methodDescriptor's used
            // don't have generics information
            for(int i = 0; i < parameterClasses.length; i++)
                parameterClasses[i] = toClass(parameterTypes[i]);

            // Perform access check
            final Class<?> enclosingCandidate = enclosingInfo.getEnclosingClass();
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                enclosingCandidate.checkMemberAccess(sm, Member.DECLARED,
                                                     Reflection.getCallerClass(), true);
            }

            Constructor<?>[] candidates = enclosingCandidate
                    .privateGetDeclaredConstructors(false);
            /*
             * Loop over all declared constructors; match number
             * of and type of parameters.
             */
            ReflectionFactory fact = getReflectionFactory();
            for (Constructor<?> c : candidates) {
                if (arrayContentsEq(parameterClasses,
                                    fact.getExecutableSharedParameterTypes(c))) {
                    return fact.copyConstructor(c);
                }
            }

            throw new InternalError("Enclosing constructor not found");
        }
    }


//如果这个{@code class}对象表示的类或接口是另一个类的成员，则返回表示声明它的类的{@code class}对象。如果该类或接口不是任何其他类的成员，则此方法返回null。如果这个{@code Class}对象表示数组类、基元类型或void，则此方法返回null。
 @CallerSensitive
    public Class<?> getDeclaringClass() throws SecurityException {
        final Class<?> candidate = getDeclaringClass0();

        if (candidate != null) {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                candidate.checkPackageAccess(sm,
                    ClassLoader.getClassLoader(Reflection.getCallerClass()), true);
            }
        }
        return candidate;
    }

    private native Class<?> getDeclaringClass0();



// 返回基础类的立即封闭类。如果基础类是顶级类，则此方法返回{@code null}。
public Class<?> getEnclosingClass() throws SecurityException {
        // There are five kinds of classes (or interfaces):
        // a) Top level classes
        // b) Nested classes (static member classes)
        // c) Inner classes (non-static member classes)
        // d) Local classes (named classes declared within a method)
        // e) Anonymous classes


        // JVM Spec 4.7.7: A class must have an EnclosingMethod
        // attribute if and only if it is a local class or an
        // anonymous class.
        EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
        Class<?> enclosingCandidate;

        if (enclosingInfo == null) {
            // This is a top level or a nested class or an inner class (a, b, or c)
            enclosingCandidate = getDeclaringClass0();
        } else {
            Class<?> enclosingClass = enclosingInfo.getEnclosingClass();
            // This is a local class or an anonymous class (d or e)
            if (enclosingClass == this || enclosingClass == null)
                throw new InternalError("Malformed enclosing method information");
            else
                enclosingCandidate = enclosingClass;
        }

        if (enclosingCandidate != null) {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                enclosingCandidate.checkPackageAccess(sm,
                    ClassLoader.getClassLoader(Reflection.getCallerClass()), true);
            }
        }
        return enclosingCandidate;
    }



//返回源代码中给定的基础类的简单名称。如果基础类是匿名的，则返回空字符串。
//数组的简单名称是附加“[]”的组件类型的简单名称。尤其是组件类型为匿名的数组的简单名称为“[]
public String getSimpleName() {
        ReflectionData<T> rd = reflectionData();
        String simpleName = rd.simpleName;
        if (simpleName == null) {
            rd.simpleName = simpleName = getSimpleName0();
        }
        return simpleName;
    }

    private String getSimpleName0() {
        if (isArray()) {
            return getComponentType().getSimpleName() + "[]";
        }
        String simpleName = getSimpleBinaryName();
        if (simpleName == null) { // top level class
            simpleName = getName();
            simpleName = simpleName.substring(simpleName.lastIndexOf('.') + 1); // strip the package name
        }
        return simpleName;
    }


//返回由Java语言规范定义的基础类的规范名称。如果基础类没有规范名称（即，如果它是本地或匿名类或其组件类型没有规范名称的数组），则返回null。
public String getCanonicalName() {
        ReflectionData<T> rd = reflectionData();
        String canonicalName = rd.canonicalName;
        if (canonicalName == null) {
            rd.canonicalName = canonicalName = getCanonicalName0();
        }
        return canonicalName == ReflectionData.NULL_SENTINEL? null : canonicalName;
    }

    private String getCanonicalName0() {
        if (isArray()) {
            String canonicalName = getComponentType().getCanonicalName();
            if (canonicalName != null)
                return canonicalName + "[]";
            else
                return ReflectionData.NULL_SENTINEL;
        }
        if (isLocalOrAnonymousClass())
            return ReflectionData.NULL_SENTINEL;
        Class<?> enclosingClass = getEnclosingClass();
        if (enclosingClass == null) { // top level class
            return getName();
        } else {
            String enclosingName = enclosingClass.getCanonicalName();
            if (enclosingName == null)
                return ReflectionData.NULL_SENTINEL;
            return enclosingName + "." + getSimpleName();
        }
    }


//Returns {@code true} if and only if the underlying class is an anonymous class.
 public boolean isAnonymousClass() {
     //满足下面三个条件就是匿名类
        return !isArray() && isLocalOrAnonymousClass() &&
                getSimpleBinaryName0() == null;
    }


public boolean isLocalClass() {
        return isLocalOrAnonymousClass() &&
                (isArray() || getSimpleBinaryName0() != null);
    }


 public boolean isMemberClass() {
        return !isLocalOrAnonymousClass() && getDeclaringClass0() != null;
    }


  private String getSimpleBinaryName() {
        if (isTopLevelClass())
            return null;
        String name = getSimpleBinaryName0();
        if (name == null) // anonymous class
            return "";
        return name;
    }

    private native String getSimpleBinaryName0();
 private boolean isTopLevelClass() {
        return !isLocalOrAnonymousClass() && getDeclaringClass0() == null;
    }
 private boolean isLocalOrAnonymousClass() {
        // JVM Spec 4.7.7: A class must have an EnclosingMethod
        // attribute if and only if it is a local class or an
        // anonymous class.
        return hasEnclosingMethodInfo();
    }
    private boolean hasEnclosingMethodInfo() {
        Object[] enclosingInfo = getEnclosingMethod0();
        if (enclosingInfo != null) {
            EnclosingMethodInfo.validate(enclosingInfo);
            return true;
        }
        return false;
    }


//返回一个数组，该数组包含{@code Class}对象，这些对象表示属于该{@code Class}对象的类的所有公共类和接口。这包括从超类继承的公共类和接口成员，以及由类声明的公共类和接口成员。如果{@code Class}对象没有公共成员类或接口，则此方法返回长度为0的数组。如果{@code Class}对象表示基元类型、数组类或void，则此方法还返回长度为0的数组。
 public Class<?>[] getClasses() {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.PUBLIC, Reflection.getCallerClass(), false);
        }

        // Privileged so this implementation can look at DECLARED classes,
        // something the caller might not have privilege to do.  The code here
        // is allowed to look at DECLARED classes because (1) it does not hand
        // out anything other than public members and (2) public member access
        // has already been ok'd by the SecurityManager.

        return java.security.AccessController.doPrivileged(
            new java.security.PrivilegedAction<>() {
                public Class<?>[] run() {
                    List<Class<?>> list = new ArrayList<>();
                    Class<?> currentClass = Class.this;
                    while (currentClass != null) {
                        for (Class<?> m : currentClass.getDeclaredClasses()) {
                            if (Modifier.isPublic(m.getModifiers())) {
                                list.add(m);
                            }
                        }
                        currentClass = currentClass.getSuperclass();
                    }
                    return list.toArray(new Class<?>[0]);
                }
            });
    }

//返回一个数组，该数组包含{@code Field}对象，这些对象反映了由这个{@code class}对象表示的类或接口的所有可访问公共字段。
//如果这个{@code Class}对象表示没有可访问公共字段的类或接口，则此方法返回长度为0的数组。如果这个{@code Class}对象表示一个类，那么这个方法返回该类及其所有超类和超接口的公共字段。
//如果当前这个类是接口，则返回这个接口的所有字段。
//如果是数组，基元 ，void 类型 ，返回空数组
//返回数组中的元素没有排序，并且没有任何特定的顺序。
  public Field[] getFields() throws SecurityException {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.PUBLIC, Reflection.getCallerClass(), true);
        }
        return copyFields(privateGetPublicFields());
    }
 public Field getField(String name)
        throws NoSuchFieldException, SecurityException {
        Objects.requireNonNull(name);
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.PUBLIC, Reflection.getCallerClass(), true);
        }
        Field field = getField0(name);
        if (field == null) {
            throw new NoSuchFieldException(name);
        }
        return getReflectionFactory().copyField(field);
    }




//返回一个数组容器 包含了 这个类或者接口包括继承父类或者父接口反射出来公有方法
//如果这个{@code Class}对象表示数组类型，那么返回的数组对于数组类型从{@code object}继承的每个公共方法都有一个{@code Method}对象。它不包含{@code clone（）}的{@code Method}对象。
//如果这个{@code Class}对象表示接口，则返回的数组不包含{@code object}隐式声明的任何方法。因此，如果此接口或其任何一个超接口中没有显式声明方法，则返回的数组的长度为0。（请注意，表示类的{@code Class}对象始终具有从{@code object}继承的公共方法。）
//返回的数组从不包含名为“{@code<init>}”或“{@code<clinit>}”的方法。返回数组中的元素没有排序，并且没有任何特定的顺序。
//一般情况下，计算结果如下4步算法。让C是这个{@code class}对象表示的类或接口：
/*
	//方法组合包括：
		由{@link#getDeclaredMethods（）}返回的C声明的公共实例和静态方法，并经过筛选仅包含公共方法。  
		如果C是{@code Object}以外的类，那么在C的超类中包含递归调用该算法的结果。
		包括在C的所有直接上接口上递归调用此算法的结果，但只包括实例方法。
	//步骤1中的联合被划分为具有相同签名（名称、参数类型）和返回类型的方法子集。
	// 在每个这样的子集中，只选择最具体的方法。让方法M是一组具有相同签名和返回类型的方法。如果没有这样的方法N，M是最具体的！=来自同一集合的M，使得N比M更具体。如果：
		N由类声明，M由接口声明；或
		N和M都是由类声明的，或者都是由接口声明的，N的声明类型与M的声明类型相同或是其子类型（显然，如果M和N的声明类型是相同的类型，那么M和N是相同的方法）。
	//该算法的结果是从步骤3中选择的所有方法的并集。
*/
//注意：一个类中可能有多个具有特定名称和参数类型的方法，因为尽管Java语言禁止一个类声明具有相同签名但返回类型不同的多个方法，而Java虚拟机则不允许。这增加了虚拟机的灵活性，可用于实现各种语言功能。例如，协变返回可以用{@linkplain java.lang.reflect.Method#isBridge bridge methods}实现；桥方法和重写方法将具有相同的签名，但返回类型不同。
 public Method[] getMethods() throws SecurityException {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.PUBLIC, Reflection.getCallerClass(), true);
        }
        return copyMethods(privateGetPublicMethods());
    }
 public Method getMethod(String name, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
        Objects.requireNonNull(name);
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.PUBLIC, Reflection.getCallerClass(), true);
        }
        Method method = getMethod0(name, parameterTypes);
        if (method == null) {
            throw new NoSuchMethodException(methodToString(name, parameterTypes));
        }
        return getReflectionFactory().copyMethod(method);
    }



//返回一个数组，其中包含{@code Constructor}对象，这些对象反映由这个{@code class}对象表示的类的所有公共构造函数。如果类没有公共构造函数，或者类是数组类，或者类反映基元类型或void，则返回长度为0的数组。
//请注意，虽然此方法返回{@code Constructor<T>}对象的数组（即该类中的构造函数数组），但该方法的返回类型是{@code Constructor<？>[]}和<em>不像预期的那样</em>{@code Constructor<T>[]}。这种信息较少的返回类型是必需的，因为从该方法返回后，可以修改数组以保存不同类的{@code Constructor}对象，这将违反{@code Constructor<T>[]}的类型保证。
  public Constructor<?>[] getConstructors() throws SecurityException {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.PUBLIC, Reflection.getCallerClass(), true);
        }
        return copyConstructors(privateGetDeclaredConstructors(true));
    }
public Constructor<T> getConstructor(Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException
    {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.PUBLIC, Reflection.getCallerClass(), true);
        }
        return getReflectionFactory().copyConstructor(
            getConstructor0(parameterTypes, Member.PUBLIC));
    }


//返回{@code Class}对象的数组，该数组反映声明为此{@code Class}对象表示的类的成员的所有类和接口。这包括公共、受保护、默认（包）访问以及类声明的私有类和接口，但不包括继承的类和接口。如果类没有声明任何类或接口作为成员，或者这个{@code class}对象表示基元类型、数组类或void，则此方法返回长度为0的数组。
  public Class<?>[] getDeclaredClasses() throws SecurityException {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.DECLARED, Reflection.getCallerClass(), false);
        }
        return getDeclaredClasses0();
    }



//返回{@code Field}对象的数组，该数组反映由这个{@code class}对象表示的类或接口声明的所有字段。这包括public、protected、default（package）access和private字段，但不包括继承的字段。
//如果这个{@code Class}对象表示没有声明字段的类或接口，则此方法返回长度为0的数组。
//如果这个{@code Class}对象表示数组类型、基元类型或void，则此方法返回长度为0的数组。
//返回数组中的元素没有排序，并且没有任何特定的顺序。
 public Field[] getDeclaredFields() throws SecurityException {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.DECLARED, Reflection.getCallerClass(), true);
        }
        return copyFields(privateGetDeclaredFields(false));
    }
 public Field getDeclaredField(String name)
        throws NoSuchFieldException, SecurityException {
        Objects.requireNonNull(name);
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.DECLARED, Reflection.getCallerClass(), true);
        }
        Field field = searchFields(privateGetDeclaredFields(false), name);
        if (field == null) {
            throw new NoSuchFieldException(name);
        }
        return getReflectionFactory().copyField(field);
    }


//返回一个数组，该数组包含{@code Method}对象，这些对象反映由该{@code class}对象表示的类或接口的所有已声明方法，包括公共、受保护、默认（包）访问和私有方法，但不包括继承的方法。
//如果这个{@code Class}对象表示一个类型，该类型具有多个声明的方法，这些方法具有相同的名称和参数类型，但返回类型不同，则返回的数组对每个此类方法都有一个{@code Method}对象。
//如果这个{@code Class}对象表示一个具有类初始化方法{@code<clinit>}的类型，则返回的数组没有相应的{@code method}对象。
//如果这个{@code Class}对象表示没有声明方法的类或接口，则返回的数组的长度为0。
//如果这个{@code Class}对象表示数组类型、基元类型或void，则此方法返回长度为0的数组。
//返回数组中的元素没有排序，并且没有任何特定的顺序。
 public Method[] getDeclaredMethods() throws SecurityException {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.DECLARED, Reflection.getCallerClass(), true);
        }
        return copyMethods(privateGetDeclaredMethods(false));
    }
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
        Objects.requireNonNull(name);
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.DECLARED, Reflection.getCallerClass(), true);
        }
        Method method = searchMethods(privateGetDeclaredMethods(false), name, parameterTypes);
        if (method == null) {
            throw new NoSuchMethodException(methodToString(name, parameterTypes));
        }
        return getReflectionFactory().copyMethod(method);
    }


//返回{@code Constructor}对象的数组，该数组反映由这个{@code class}对象表示的类声明的所有构造函数。它们是public、protected、default（package）access和private构造函数。返回的数组中的元素没有排序，并且没有任何特定的顺序。如果类具有默认构造函数，则它将包含在返回的数组中。如果{@code Class}对象表示接口、基元类型、数组类或void，则此方法返回长度为0的数组。
 public Constructor<?>[] getDeclaredConstructors() throws SecurityException {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.DECLARED, Reflection.getCallerClass(), true);
        }
        return copyConstructors(privateGetDeclaredConstructors(false));
    }
 public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException
    {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkMemberAccess(sm, Member.DECLARED, Reflection.getCallerClass(), true);
        }

        return getReflectionFactory().copyConstructor(
            getConstructor0(parameterTypes, Member.DECLARED));
    }


 public T cast(Object obj) {
        if (obj != null && !isInstance(obj))
            throw new ClassCastException(cannotCastMsg(obj));
        return (T) obj;
    }

/*
如果这个{@code Class}对象表示方法中的本地类或匿名类，则返回一个Method对象，该对象表示基础类的直接封闭方法。否则返回{@code null}。
特别是，如果基础类是直接由类型声明、实例初始值设定项或静态初始值设定项包围的本地或匿名类，则此方法返回{@code null}。
*/

 @CallerSensitive
    public Method getEnclosingMethod() throws SecurityException {
        EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();

        if (enclosingInfo == null)
            return null;
        else {
            if (!enclosingInfo.isMethod())
                return null;

            MethodRepository typeInfo = MethodRepository.make(enclosingInfo.getDescriptor(),
                                                              getFactory());
            Class<?>   returnType       = toClass(typeInfo.getReturnType());
            Type []    parameterTypes   = typeInfo.getParameterTypes();
            Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];

            // Convert Types to Classes; returned types *should*
            // be class objects since the methodDescriptor's used
            // don't have generics information
            for(int i = 0; i < parameterClasses.length; i++)
                parameterClasses[i] = toClass(parameterTypes[i]);

            // Perform access check
            final Class<?> enclosingCandidate = enclosingInfo.getEnclosingClass();
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                enclosingCandidate.checkMemberAccess(sm, Member.DECLARED,
                                                     Reflection.getCallerClass(), true);
            }
            Method[] candidates = enclosingCandidate.privateGetDeclaredMethods(false);

            /*
             * Loop over all declared methods; match method name,
             * number of and type of parameters, *and* return
             * type.  Matching return type is also necessary
             * because of covariant returns, etc.
             */
            ReflectionFactory fact = getReflectionFactory();
            for (Method m : candidates) {
                if (m.getName().equals(enclosingInfo.getName()) &&
                    arrayContentsEq(parameterClasses,
                                    fact.getExecutableSharedParameterTypes(m))) {
                    // finally, check return type
                    if (m.getReturnType().equals(returnType)) {
                        return fact.copyMethod(m);
                    }
                }
            }

            throw new InternalError("Enclosing method not found");
        }
    }

    private native Object[] getEnclosingMethod0();

    private EnclosingMethodInfo getEnclosingMethodInfo() {
        Object[] enclosingInfo = getEnclosingMethod0();
        if (enclosingInfo == null)
            return null;
        else {
            return new EnclosingMethodInfo(enclosingInfo);
        }
    }





 private static final class EnclosingMethodInfo {
        private final Class<?> enclosingClass;
        private final String name;
        private final String descriptor;

        static void validate(Object[] enclosingInfo) {
            if (enclosingInfo.length != 3)
                throw new InternalError("Malformed enclosing method information");
            try {
                // The array is expected to have three elements:

                // the immediately enclosing class
                Class<?> enclosingClass = (Class<?>)enclosingInfo[0];
                assert(enclosingClass != null);

                // the immediately enclosing method or constructor's
                // name (can be null).
                String name = (String)enclosingInfo[1];

                // the immediately enclosing method or constructor's
                // descriptor (null iff name is).
                String descriptor = (String)enclosingInfo[2];
                assert((name != null && descriptor != null) || name == descriptor);
            } catch (ClassCastException cce) {
                throw new InternalError("Invalid type in enclosing method information", cce);
            }
        }

        EnclosingMethodInfo(Object[] enclosingInfo) {
            validate(enclosingInfo);
            this.enclosingClass = (Class<?>)enclosingInfo[0];
            this.name = (String)enclosingInfo[1];
            this.descriptor = (String)enclosingInfo[2];
        }

        boolean isPartial() {
            return enclosingClass == null || name == null || descriptor == null;
        }

        boolean isConstructor() { return !isPartial() && "<init>".equals(name); }

        boolean isMethod() { return !isPartial() && !isConstructor() && !"<clinit>".equals(name); }

        Class<?> getEnclosingClass() { return enclosingClass; }

        String getName() { return name; }

        String getDescriptor() { return descriptor; }

}

 
private transient volatile SoftReference<ReflectionData<T>> reflectionData;

    // Incremented by the VM on each call to JVM TI RedefineClasses()
    // that redefines this class or a superclass.
    private transient volatile int classRedefinedCount;

    // Lazily create and cache ReflectionData
    private ReflectionData<T> reflectionData() {
        SoftReference<ReflectionData<T>> reflectionData = this.reflectionData;
        int classRedefinedCount = this.classRedefinedCount;
        ReflectionData<T> rd;
        if (reflectionData != null &&
            (rd = reflectionData.get()) != null &&
            rd.redefinedCount == classRedefinedCount) {
            return rd;
        }
        // else no SoftReference or cleared SoftReference or stale ReflectionData
        // -> create and replace new instance
        return newReflectionData(reflectionData, classRedefinedCount);
    }

    private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> oldReflectionData,
                                                int classRedefinedCount) {
        while (true) {
            ReflectionData<T> rd = new ReflectionData<>(classRedefinedCount);
            // try to CAS it...
            if (Atomic.casReflectionData(this, oldReflectionData, new SoftReference<>(rd))) {
                return rd;
            }
            // else retry
            oldReflectionData = this.reflectionData;
            classRedefinedCount = this.classRedefinedCount;
            if (oldReflectionData != null &&
                (rd = oldReflectionData.get()) != null &&
                rd.redefinedCount == classRedefinedCount) {
                return rd;
            }
        }
    }










private static class ReflectionData<T> {
        volatile Field[] declaredFields;
        volatile Field[] publicFields;
        volatile Method[] declaredMethods;
        volatile Method[] publicMethods;
        volatile Constructor<T>[] declaredConstructors;
        volatile Constructor<T>[] publicConstructors;
        // Intermediate results for getFields and getMethods
        volatile Field[] declaredPublicFields;
        volatile Method[] declaredPublicMethods;
        volatile Class<?>[] interfaces;

        // Cached names
        String simpleName;
        String canonicalName;
        static final String NULL_SENTINEL = new String();

        // Value of classRedefinedCount when we created this ReflectionData instance
        final int redefinedCount;

        ReflectionData(int redefinedCount) {
            this.redefinedCount = redefinedCount;
        }
    }

/**
     * Atomic operations support.
     */
    private static class Atomic {
        // initialize Unsafe machinery here, since we need to call Class.class instance method
        // and have to avoid calling it in the static initializer of the Class class...
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        // offset of Class.reflectionData instance field
        private static final long reflectionDataOffset
                = unsafe.objectFieldOffset(Class.class, "reflectionData");
        // offset of Class.annotationType instance field
        private static final long annotationTypeOffset
                = unsafe.objectFieldOffset(Class.class, "annotationType");
        // offset of Class.annotationData instance field
        private static final long annotationDataOffset
                = unsafe.objectFieldOffset(Class.class, "annotationData");

        static <T> boolean casReflectionData(Class<?> clazz,
                                             SoftReference<ReflectionData<T>> oldData,
                                             SoftReference<ReflectionData<T>> newData) {
            return unsafe.compareAndSetReference(clazz, reflectionDataOffset, oldData, newData);
        }

        static <T> boolean casAnnotationType(Class<?> clazz,
                                             AnnotationType oldType,
                                             AnnotationType newType) {
            return unsafe.compareAndSetReference(clazz, annotationTypeOffset, oldType, newType);
        }

        static <T> boolean casAnnotationData(Class<?> clazz,
                                             AnnotationData oldData,
                                             AnnotationData newData) {
            return unsafe.compareAndSetReference(clazz, annotationDataOffset, oldData, newData);
        }
    }

private static class AnnotationData {
       final Map<Class<? extends Annotation>, Annotation> annotations;
       final Map<Class<? extends Annotation>, Annotation> declaredAnnotations;

       // Value of classRedefinedCount when we created this AnnotationData instance
       final int redefinedCount;

       AnnotationData(Map<Class<? extends Annotation>, Annotation> annotations,
                      Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
                      int redefinedCount) {
           this.annotations = annotations;
           this.declaredAnnotations = declaredAnnotations;
           this.redefinedCount = redefinedCount;
       }
   }

   // Annotations cache
   @SuppressWarnings("UnusedDeclaration")
   private transient volatile AnnotationData annotationData;

   private AnnotationData annotationData() {
       while (true) { // retry loop
           AnnotationData annotationData = this.annotationData;
           int classRedefinedCount = this.classRedefinedCount;
           if (annotationData != null &&
               annotationData.redefinedCount == classRedefinedCount) {
               return annotationData;
           }
           // null or stale annotationData -> optimistically create new instance
           AnnotationData newAnnotationData = createAnnotationData(classRedefinedCount);
           // try to install it
           if (Atomic.casAnnotationData(this, annotationData, newAnnotationData)) {
               // successfully installed new AnnotationData
               return newAnnotationData;
           }
       }
   }

   private AnnotationData createAnnotationData(int classRedefinedCount) {
       Map<Class<? extends Annotation>, Annotation> declaredAnnotations =
           AnnotationParser.parseAnnotations(getRawAnnotations(), getConstantPool(), this);
       Class<?> superClass = getSuperclass();
       Map<Class<? extends Annotation>, Annotation> annotations = null;
       if (superClass != null) {
           Map<Class<? extends Annotation>, Annotation> superAnnotations =
               superClass.annotationData().annotations;
           for (Map.Entry<Class<? extends Annotation>, Annotation> e : superAnnotations.entrySet()) {
               Class<? extends Annotation> annotationClass = e.getKey();
               if (AnnotationType.getInstance(annotationClass).isInherited()) {
                   if (annotations == null) { // lazy construction
                       annotations = new LinkedHashMap<>((Math.max(
                               declaredAnnotations.size(),
                               Math.min(12, declaredAnnotations.size() + superAnnotations.size())
                           ) * 4 + 2) / 3
                       );
                   }
                   annotations.put(annotationClass, e.getValue());
               }
           }
       }
       if (annotations == null) {
           // no inherited annotations -> share the Map with declaredAnnotations
           annotations = declaredAnnotations;
       } else {
           // at least one inherited annotation -> declared may override inherited
           annotations.putAll(declaredAnnotations);
       }
       return new AnnotationData(annotations, declaredAnnotations, classRedefinedCount);
   }

   // Annotation types cache their internal (AnnotationType) form

   @SuppressWarnings("UnusedDeclaration")
   private transient volatile AnnotationType annotationType;

   boolean casAnnotationType(AnnotationType oldType, AnnotationType newType) {
       return Atomic.casAnnotationType(this, oldType, newType);
   }

   AnnotationType getAnnotationType() {
       return annotationType;
   }

   Map<Class<? extends Annotation>, Annotation> getDeclaredAnnotationMap() {
       return annotationData().declaredAnnotations;
   }

   /* Backing store of user-defined values pertaining to this class.
    * Maintained by the ClassValue class.
    */
   transient ClassValue.ClassValueMap classValueMap;