protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException
    {// First, check if the class has already been loaded
            Class c = findLoadedClass(name);if (c == null) {long t0 = System.nanoTime();try {if (parent != null) {c = parent.loadClass(name, false);} else {c = findBootstrapClassOrNull(name);}} catch (ClassNotFoundException e) {// ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }if (c == null) {// If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();c = findClass(name);// this is the defining class loader; record the stats
                }}return c;}

Class<?> loadClass(String name, boolean resolve);
Class<?> findClass(String name);
Class<?> defineClass(String name, byte[] b, int off, int len, ProtectionDomain protectionDomain);
void resolveClass(Class<?> c); ​

    static private class SystemClassLoader {public static ClassLoader loader = ClassLoader.createSystemClassLoader();}/**
     * Encapsulates the set of parallel capable loader types.
     */
    private static ClassLoader createSystemClassLoader() {String classPath = System.getProperty("java.class.path", ".");String librarySearchPath = System.getProperty("java.library.path", "");return new PathClassLoader(classPath, librarySearchPath, BootClassLoader.getInstance());}public static ClassLoader getSystemClassLoader() {return SystemClassLoader.loader;}

class BootClassLoader extends ClassLoader {private static BootClassLoader instance;@FindBugsSuppressWarnings("DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED")public static synchronized BootClassLoader getInstance() {if (instance == null) {instance = new BootClassLoader();}return instance;}public BootClassLoader() {super(null);}// ...
}

    public BaseDexClassLoader(String dexPath, File optimizedDirectory,String librarySearchPath, ClassLoader parent) {super(parent);this.pathList = new DexPathList(this, dexPath, librarySearchPath, null);}

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {List<Throwable> suppressedExceptions = new ArrayList<Throwable>();Class c = pathList.findClass(name, suppressedExceptions);if (c == null) {ClassNotFoundException cnfe = new ClassNotFoundException("Didn't find class \"" + name + "\" on path: " + pathList);for (Throwable t : suppressedExceptions) {cnfe.addSuppressed(t);}throw cnfe;}return c;}

private Element[] dexElements;

for (File file : files) {// ...
    if (name.endsWith(DEX_SUFFIX)) {// .dex
        DexFile dex = loadDexFile(file, optimizedDirectory, loader, elements);if (dex != null) {elements[elementsPos++] = new Element(dex, null);}} else { // .zip .jar
        // ...
        DexFile dex = loadDexFile(file, optimizedDirectory, loader, elements);// ...
    }// ...
}​

for (Element element : dexElements) {Class<?> clazz = element.findClass(name, definingContext, suppressed);if (clazz != null) {return clazz;}
}​

/** List of native library path elements. */
private final NativeLibraryElement[] nativeLibraryPathElements;

public Class loadClass(String name, ClassLoader loader) {String slashName = name.replace('.', '/');return loadClassBinaryName(slashName, loader, null);
}
private static native Class defineClassNative(String name, ClassLoader loader, Object cookie,DexFile dexFile)throws ClassNotFoundException, NoClassDefFoundError;

static void Dalvik_dalvik_system_DexFile_openDexFile(const u4* args,JValue* pResult)
{// ...
  DexOrJar* pDexOrJar = NULL;// ...
  if (hasDexExtension(sourceName)&& dvmRawDexFileOpen(sourceName, outputName, &pRawDexFile, false) == 0) {ALOGV("Opening DEX file '%s' (DEX)", sourceName);
​        pDexOrJar = (DexOrJar*) malloc(sizeof(DexOrJar));pDexOrJar->isDex = true;pDexOrJar->pRawDexFile = pRawDexFile;pDexOrJar->pDexMemory = NULL;}// ...
  RETURN_PTR(pDexOrJar);
}

static void Dalvik_dalvik_system_DexFile_defineClass(const u4* args,JValue* pResult)
{// ...
    if (pDexOrJar->isDex)pDvmDex = dvmGetRawDexFileDex(pDexOrJar->pRawDexFile);else
        pDvmDex = dvmGetJarFileDex(pDexOrJar->pJarFile);// ...
    clazz = dvmDefineClass(pDvmDex, descriptor, loader);// ...
}

static ClassObject* findClassNoInit(const char* descriptor, Object* loader,DvmDex* pDvmDex)
{// 在已经加载过的类中去寻找，如果已经加载过，则不用再进行加载了
    clazz = dvmLookupClass(descriptor, loader, true);if (clazz == null) {// 在Dex文件中寻找Class定义
        pClassDef = dexFindClass(pDvmDex->pDexFile, descriptor);// 找到了Class的定义后，将其加载成ClassObject对象
        ClassObject* clazz = loadClassFromDex(pDvmDex, pClassDef, loader);// ...
        // 记录该类到已加载过类的hash table中，便于下次检查
        dvmAddClassToHash(clazz);// ...
        // 链接这个Class
        dvmLinkClass(clazz);}
}

/*
 * 通过类描述符查找一个类的定义
 *
 * 类描述符"descriptor"应该例如："Landroid/debug/Stuff;".
 */
const DexClassDef* dexFindClass(const DexFile* pDexFile,const char* descriptor)
{const DexClassLookup* pLookup = pDexFile->pClassLookup;u4 hash;int idx, mask;hash = classDescriptorHash(descriptor);mask = pLookup->numEntries - 1;idx = hash & mask;/*
     * 遍历DexClassLookup，直到找到Class的定义
     */
    while (true) {int offset;offset = pLookup->table[idx].classDescriptorOffset;if (offset == 0)return NULL;// 先比对类描述符的hash值
        if (pLookup->table[idx].classDescriptorHash == hash) {const char* str;str = (const char*) (pDexFile->baseAddr + offset);// hash值匹配后，再比对类描述符的字符串
            if (strcmp(str, descriptor) == 0) {// 找到匹配指定描述符的类
                return (const DexClassDef*)(pDexFile->baseAddr + pLookup->table[idx].classDefOffset);}}idx = (idx + 1) & mask;}
}

/*
 * Helper for loadClassFromDex, which takes a DexClassDataHeader and
 * encoded data pointer in addition to the other arguments.
 */
static ClassObject* loadClassFromDex0(DvmDex* pDvmDex,const DexClassDef* pClassDef, const DexClassDataHeader* pHeader,const u1* pEncodedData, Object* classLoader)
{newClass = (ClassObject*) dvmMalloc(size, ALLOC_NON_MOVING);dvmSetClassSerialNumber(newClass);// 类的签名
    newClass->descriptor = descriptor;// 类的状态 -> Loaded
    newClass->status = CLASS_IDX;// 父类
    newClass->super = (ClassObject*) pClassDef->superclassIdx;// 接口列表
    pInterfacesList = dexGetInterfacesList(pDexFile, pClassDef);// 静态变量（并设置为默认值0或null）
    newClass->sfieldCount = count;for (i = 0; i < count; i++) {dexReadClassDataField(&pEncodedData, &field, &lastIndex);loadSFieldFromDex(newClass, &field, &newClass->sfields[i]);}// 成员变量
    for (i = 0; i < count; i++) {dexReadClassDataField(&pEncodedData, &field, &lastIndex);loadIFieldFromDex(newClass, &field, &newClass->ifields[i]);}dvmLinearReadOnly(classLoader, newClass->ifields);// 成员方法
    newClass->directMethodCount = count;newClass->directMethods = (Method*) dvmLinearAlloc(classLoader,count * sizeof(Method));for (i = 0; i < count; i++) {dexReadClassDataMethod(&pEncodedData, &method, &lastIndex);loadMethodFromDex(newClass, &method, &newClass->directMethods[i]);}dvmLinearReadOnly(classLoader, newClass->directMethods);// 虚方法(父类方法)
    newClass->virtualMethodCount = count;newClass->virtualMethods = (Method*) dvmLinearAlloc(classLoader,count * sizeof(Method));for (i = 0; i < count; i++) {dexReadClassDataMethod(&pEncodedData, &method, &lastIndex);loadMethodFromDex(newClass, &method, &newClass->virtualMethods[i]);}dvmLinearReadOnly(classLoader, newClass->virtualMethods);// 字节码
    newClass->sourceFile = dexGetSourceFile(pDexFile, pClassDef);
}

bool dvmLinkClass(ClassObject* clazz) { }

bool dvmInitClass(CLassObject* clazz) { }

struct DexFile {/* directly-mapped "opt" header */
    const DexOptHeader* pOptHeader;
​    // DEX文件头指针，包含所有指针的偏移量和长度
    const DexHeader*    pHeader;// 字符串列表指针，UTF-16编码
    const DexStringId*  pStringIds;// 类型列表指针
    const DexTypeId*    pTypeIds;// 字段列表指针
    const DexFieldId*   pFieldIds;// 方法列表指针
    const DexMethodId*  pMethodIds;// 函数原型数据指针，方法声明的字符串，返回类型和参数列表
    const DexProtoId*   pProtoIds;// 类的定义列表指针，类的信息，包括接口，超类，类信息，静态变量偏移量等
    const DexClassDef*  pClassDefs;// 静态连接数据
    const DexLink*      pLinkData;/*
     * These are mapped out of the "auxillary" section, and may not be
     * included in the file.
     */
    const DexClassLookup* pClassLookup;const void*         pRegisterMapPool;       // RegisterMapClassPool
​    /* points to start of DEX file data */
    const u1*           baseAddr;/* track memory overhead for auxillary structures */
    int                 overhead;
​    /* additional app-specific data structures associated with the DEX */
    //void*               auxData;
};