class InstanceKlass: public Klass {

 ...

 protected:

  // Annotations for this class

  Annotations*       _annotations;

  // Array classes holding elements of this class.

  Klass*             _array_klasses;

  // Constant pool for this class.

  ConstantPool*     _constants;

  // The InnerClasses attribute and EnclosingMethod attribute. The

  // _inner_classes is an array of shorts. If the class has InnerClasses

  // attribute, then the _inner_classes array begins with 4-tuples of shorts

  // [inner_class_info_index, outer_class_info_index,

  // inner_name_index, inner_class_access_flags] for the InnerClasses

  // attribute. If the EnclosingMethod attribute exists, it occupies the

  // last two shorts [class_index, method_index] of the array. If only

  // the InnerClasses attribute exists, the _inner_classes array length is

  // number_of_inner_classes * 4. If the class has both InnerClasses

  // and EnclosingMethod attributes the _inner_classes array length is

  // number_of_inner_classes * 4 + enclosing_method_attribute_size.

  Array<jushort>*   _inner_classes;

  // Array name derived from this class which needs unreferencing

  // if this class is unloaded.

  Symbol*           _array_name;

  // Number of heapOopSize words used by non-static fields in this klass

  // (including inherited fields but after header_size()).

  int               _nonstatic_field_size;

  int               _static_field_size;    // number words used by static fields (oop and non-oop) in this klass

  // Constant pool index to the utf8 entry of the Generic signature,

  // or 0 if none.

  u2                _generic_signature_index;

  // Constant pool index to the utf8 entry for the name of source file

  // containing this klass, 0 if not specified.

  u2                _source_file_name_index;

  u2                _static_oop_field_count;// number of static oop fields in this klass

  u2                _java_fields_count;    // The number of declared Java fields

  int               _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks

  u2                _minor_version;  // minor version number of class file

  u2                _major_version;  // major version number of class file

  Thread*           _init_thread;    // Pointer to current thread doing initialization (to handle recusive initialization)

  int               _vtable_len;     // length of Java vtable (in words)

  int               _itable_len;     // length of Java itable (in words)

  OopMapCache*      volatile _oop_map_cache;   // OopMapCache for all methods in the klass (allocated lazily)

  JNIid*            _jni_ids;              // First JNI identifier for static fields in this class

  jmethodID*        _methods_jmethod_ids;  // jmethodIDs corresponding to method_idnum, or NULL if none

  nmethodBucket*    _dependencies;         // list of dependent nmethods

  nmethod*          _osr_nmethods_head;    // Head of list of on-stack replacement nmethods for this class

  // Class states are defined as ClassState (see above).

  // Place the _init_state here to utilize the unused 2-byte after

  // _idnum_allocated_count.

  u1                _init_state;                    // state of class

  u1                _reference_type;                // reference type

  // Method array.

  Array<Method*>*   _methods;

  // Default Method Array, concrete methods inherited from interfaces

  Array<Method*>*   _default_methods;

  // Interface (Klass*s) this class declares locally to implement.

  Array<Klass*>*    _local_interfaces;

  // Interface (Klass*s) this class implements transitively.

  Array<Klass*>*    _transitive_interfaces;

  // Int array containing the vtable_indices for default_methods

  // offset matches _default_methods offset

  Array<int>*       _default_vtable_indices;

  // Instance and static variable information, starts with 6-tuples of shorts

  // [access, name index, sig index, initval index, low_offset, high_offset]

  // for all fields, followed by the generic signature data at the end of

  // the array. Only fields with generic signature attributes have the generic

  // signature data set in the array. The fields array looks like following:

  //

  // f1: [access, name index, sig index, initial value index, low_offset, high_offset]

  // f2: [access, name index, sig index, initial value index, low_offset, high_offset]

  //      ...

  // fn: [access, name index, sig index, initial value index, low_offset, high_offset]

  //     [generic signature index]

  //     [generic signature index]

  //     ...

  Array<u2>*        _fields;

  // embedded Java vtable follows here

  // embedded Java itables follows here

  // embedded static fields follows here

  // embedded nonstatic oop-map blocks follows here

  // embedded implementor of this interface follows here

  //   The embedded implementor only exists if the current klass is an

  //   iterface. The possible values of the implementor fall into following

  //   three cases:

  //     NULL: no implementor.

  //     A Klass* that's not itself: one implementor.

  //     Itsef: more than one implementors.

  // embedded host klass follows here

  //   The embedded host klass only exists in an anonymous class for

  //   dynamic language support (JSR 292 enabled). The host class grants

  //   its access privileges to this class also. The host class is either

  //   named, or a previously loaded anonymous class. A non-anonymous class

  //   or an anonymous class loaded through normal classloading does not

  //   have this embedded field.

  ...

}

  int size = InstanceKlass::size(vtable_len,

								 itable_len,

								 nonstatic_oop_map_size,

		                         isinterf,

								 is_anonymous);

static int size(int vtable_length,

		          int itable_length,

                  int nonstatic_oop_map_size,

                  bool is_interface,

				  bool is_anonymous

  ){

    return align_object_size(header_size()    +  // header_size()为55

           align_object_offset(vtable_length) +

           align_object_offset(itable_length) +

           (

                  (is_interface || is_anonymous) ?

                  align_object_offset(nonstatic_oop_map_size) :

                  nonstatic_oop_map_size

		   ) +

           (

        		   is_interface ? (int)sizeof(Klass*)/HeapWordSize : 0

           ) +

           (

        		   is_anonymous ? (int)sizeof(Klass*)/HeapWordSize : 0)

		   );

  }

// Sizing (in words)

static int header_size(){

  return align_object_offset(sizeof(InstanceKlass)/HeapWordSize); // 以HeapWordSize为单位，64位一个字为8字节，所以值为8

}

InstanceKlass* InstanceKlass::allocate_instance_klass(

                                              ClassLoaderData* loader_data,

                                              int vtable_len,

                                              int itable_len,

                                              int static_field_size,

                                              int nonstatic_oop_map_size,

                                              ReferenceType rt,

                                              AccessFlags access_flags,

                                              Symbol* name,

                                              Klass* super_klass,

                                              bool is_anonymous,

                                              TRAPS) {

  bool isinterf = access_flags.is_interface();

  int size = InstanceKlass::size(vtable_len,

								 itable_len,

								 nonstatic_oop_map_size,

		                         isinterf,

								 is_anonymous);

  // Allocation

  InstanceKlass* ik;

  ///////////////////////////////////////////////////////////////////////

  if (rt == REF_NONE) {

    if (name == vmSymbols::java_lang_Class()) {

      ik = new (loader_data, size, THREAD) InstanceMirrorKlass(

                       vtable_len,

					   itable_len,

					   static_field_size,

					   nonstatic_oop_map_size,

					   rt,

                       access_flags, is_anonymous);

    } else if (

    	  name == vmSymbols::java_lang_ClassLoader() ||

          (

             SystemDictionary::ClassLoader_klass_loaded() &&

             super_klass != NULL &&

             super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass()) // ClassLoader_klass为java_lang_ClassLoader

		  )

    ){

      ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(

                       vtable_len,

					   itable_len,

					   static_field_size,

					   nonstatic_oop_map_size,

					   rt,

                       access_flags, is_anonymous);

    } else {

      // normal class

      ik = new (loader_data, size, THREAD) InstanceKlass(

				vtable_len, itable_len,

				static_field_size,

				nonstatic_oop_map_size,

				rt,

				access_flags, is_anonymous);

    }

  }

  ///////////////////////////////////////////////////////////////////////

  else {

    // reference klass

    ik = new (loader_data, size, THREAD) InstanceRefKlass(

				vtable_len, itable_len,

				static_field_size,

				nonstatic_oop_map_size,

				rt,

				access_flags, is_anonymous);

  }

  ///////////////////////////////////////////////////////////////////////

  // 添加所有类型到我们内部类加载器列表中，包括在根加载器中的类

  // Add all classes to our internal class loader list here,

  // including classes in the bootstrap (NULL) class loader.

  // loader_data的类型为ClassLoaderData*,通过ClassLoaderData中的_klasses保持通过InstanceKlass._next_link属性保持的列表

  loader_data->add_class(ik);

  return ik;

}

// ReferenceType is used to distinguish between java/lang/ref/Reference subclasses

enum ReferenceType {

  REF_NONE,      // Regular class

  REF_OTHER,     // Subclass of java/lang/ref/Reference, but not subclass of one of the classes below

  REF_SOFT,      // Subclass of java/lang/ref/SoftReference

  REF_WEAK,      // Subclass of java/lang/ref/WeakReference

  REF_FINAL,     // Subclass of java/lang/ref/FinalReference

  REF_PHANTOM    // Subclass of java/lang/ref/PhantomReference

};