public Launcher() {
  Launcher.ExtClassLoader var1;
  try {
  	// 獲取擴展類加載器
   var1 = Launcher.ExtClassLoader.getExtClassLoader(); 
  } catch (IOException var10) {
   throw new InternalError("Could not create extension class loader", var10);
  }

  try {
  	// 獲取系統(tǒng)類加載器
   this.loader = Launcher.AppClassLoader.getAppClassLoader(var1); 
  } catch (IOException var9) {
   throw new InternalError("Could not create application class loader", var9);
  }
		// 此處是將系統(tǒng)類加載器設(shè)置為當(dāng)前線程的上下文加載器
  Thread.currentThread().setContextClassLoader(this.loader); 
  String var2 = System.getProperty("java.security.manager");
  if (var2 != null) {
   SecurityManager var3 = null;
   if (!"".equals(var2) && !"default".equals(var2)) {
    try {
     var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
    } catch (IllegalAccessException var5) {
    } catch (InstantiationException var6) {
    } catch (ClassNotFoundException var7) {
    } catch (ClassCastException var8) {
    }
   } else {
    var3 = new SecurityManager();
   }

   if (var3 == null) {
    throw new InternalError("Could not create SecurityManager: " + var2);
   }

   System.setSecurityManager(var3);
  }

 }

// 這是ExtClassLoader類內(nèi)部的定義
private static volatile Launcher.ExtClassLoader instance;// 單例模式實例對象

public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
// 從這里可以看出，ExtClassLoader是一個由double-checking形成的懶漢式單例對象
   if (instance == null) { 
    Class var0 = Launcher.ExtClassLoader.class;
    synchronized(Launcher.ExtClassLoader.class) {
     if (instance == null) {
      instance = createExtClassLoader(); // 創(chuàng)建ExtClassLoader
     }
    }
   }

   return instance;
  }

// createExtClassLoader()方法
private static Launcher.ExtClassLoader createExtClassLoader() throws IOException {
   try {
    return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
     public Launcher.ExtClassLoader run() throws IOException {
      File[] var1 = Launcher.ExtClassLoader.getExtDirs();
      int var2 = var1.length;

      for(int var3 = 0; var3 < var2; ++var3) {
       MetaIndex.registerDirectory(var1[var3]);
      }

      return new Launcher.ExtClassLoader(var1); // 調(diào)用構(gòu)造方法
     }
    });
   } catch (PrivilegedActionException var1) {
    throw (IOException)var1.getException();
   }
  }

// ExtClassLoader的構(gòu)造方法
public ExtClassLoader(File[] var1) throws IOException {
			// 此處第二個參數(shù)需要格外注意??！，我們進入父類的構(gòu)造方法查看該參數(shù)是什么
   super(getExtURLs(var1), (ClassLoader)null, Launcher.factory); 
   SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
  }

// 父類URLClassLoader的構(gòu)造方法
// 此處的第二個參數(shù)是父類構(gòu)造器的引用，也就解釋了為什么在調(diào)用獲得ExtClassLoader的
public URLClassLoader(URL[] urls, ClassLoader parent, getParent()方法獲取父類構(gòu)造器為null
       URLStreamHandlerFactory factory) {
  super(parent);
  // this is to make the stack depth consistent with 1.1
  SecurityManager security = System.getSecurityManager();
  if (security != null) {
   security.checkCreateClassLoader();
  }
  acc = AccessController.getContext();
  ucp = new URLClassPath(urls, factory, acc);
 }

public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
   final String var1 = System.getProperty("java.class.path");
   final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
   return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
    public Launcher.AppClassLoader run() {
     URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
     return new Launcher.AppClassLoader(var1x, var0); // 與擴展類加載器不同的是，系統(tǒng)類加載器并不是單例模式的
    }
   });
  }
// AppClassLoader的構(gòu)造方法
AppClassLoader(URL[] var1, ClassLoader var2) { 
 // 這里的var2 對應(yīng)上述getAppClassLoader()方法中的var0，而var0對應(yīng)的就是Launcher的構(gòu)造方法中獲取到的ExtClassLoader
 // 在ExtClassLoader源碼的分析中，我們知道這個var2代表的就是父類構(gòu)造器，所以此處就是將AppClassLoader的父類設(shè)置為ExtClassLoader
   super(var1, var2, Launcher.factory);
   this.ucp.initLookupCache(this);
  }

public Class<?> loadClass(String name) throws ClassNotFoundException {
		// loadClass調(diào)用重載含有兩個參數(shù)的loadClass，其中第二個參數(shù)表示在加載時是否解析，默認為false
  return loadClass(name, false); 
 }
// 含有兩個參數(shù)的重載loadClass方法
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException{// resolve:true->加載class的同時進行解析操作
  synchronized (getClassLoadingLock(name)) {// 同步操作，保證只能加載一次
   // 首先在緩存中判斷是否已經(jīng)加載同名的類
   Class<?> c = findLoadedClass(name);
   if (c == null) {
    long t0 = System.nanoTime();
    // 此處就是雙親委派機制的具體實現(xiàn)，其實就是讓父類加載器先去加載。
    try {
     // 獲取當(dāng)前類加載器的父類加載器
     if (parent != null) {
      // 如果存在父類加載器，則調(diào)用父類加載器的loadClass進行加載(雙親委派)
      c = parent.loadClass(name, false);
     } else { 
     		 // parent == null:父類加載器是引導(dǎo)類加載器
      c = findBootstrapClassOrNull(name);
     }
    } catch (ClassNotFoundException e) {
     // ClassNotFoundException thrown if class not found
     // from the non-null parent class loader
    }
				// 當(dāng)前類加載器的父類加載器未加載此類 or 當(dāng)前類加載器未加載此類
    if (c == null) { 
     // If still not found, then invoke findClass in order
     // to find the class.
     long t1 = System.nanoTime();
     // 調(diào)用當(dāng)前類加載器的findClass()
     c = findClass(name);

     // this is the defining class loader; record the stats
     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
     sun.misc.PerfCounter.getFindClasses().increment();
    }
   }
   if (resolve) {// 是否進行解析操作
    resolveClass(c);
   }
   return c;
  }
 }

//在ClassLoader中的findClass()方法
rotected Class<?> findClass(String name) throws ClassNotFoundException {
  throw new ClassNotFoundException(name);
 }

protected Class<?> findClass(final String name)
  throws ClassNotFoundException
 {
  final Class<?> result;
  try {
   result = AccessController.doPrivileged(
    new PrivilegedExceptionAction<Class<?>>() {
     public Class<?> run() throws ClassNotFoundException {
      String path = name.replace('.', '/').concat(".class");// 類名路徑字符串格式替換
      Resource res = ucp.getResource(path, false);// 獲得class源文件
      if (res != null) {
       try {
       	// 調(diào)用defineClass()方法獲得要加載的類對應(yīng)的Class對象，
       	// defineClass()的作用就是根據(jù)給定的class源文件返回一個對應(yīng)的Class對象
        return defineClass(name, res);
       } catch (IOException e) {
        throw new ClassNotFoundException(name, e);
       }
      } else {
       return null;
      }
     }
    }, acc);
  } catch (java.security.PrivilegedActionException pae) {
   throw (ClassNotFoundException) pae.getException();
  }
  if (result == null) {
   throw new ClassNotFoundException(name);
  }
  return result;
 }