深入研究Java类加载机制

       public class HelloWorld {
              public static void main(String[] args) {
                       HelloWorld hello = new HelloWorld();
                       Class c = hello.getClass();
                       ClassLoader loader = c.getClassLoader();
                       System.out.println(loader);
                       System.out.println(loader.getParent());
                       System.out.println(loader.getParent().getParent());
               }
       }
   
  

       sun.misc.Launcher$AppClassLoader@19821f
       sun.misc.Launcher$ExtClassLoader@addbf1
       null
       Process finished with exit code 0
   
  

       public class HelloWorld {
              public static void main(String[] args) throws ClassNotFoundException {
                       ClassLoader loader = HelloWorld.class.getClassLoader();
                       System.out.println(loader);
                       //使用ClassLoader.loadClass()来加载类，不会执行初始化块 
                       loader.loadClass("Test2");
                       //使用Class.forName()来加载类，默认会执行初始化块 
       //                Class.forName("Test2"); 
                       //使用Class.forName()来加载类，并指定ClassLoader，初始化时不执行静态块 
       //                Class.forName("Test2", false, loader); 
               }
       }
   
  

       public class Test2 {
              static {
                       System.out.println("静态初始化块执行了！");
               }
       }
   
  

       System.out.println("before loadClass... ");
       Class c =Test.class.getClassLoader().loadClass("com.hundsun.test.ClassInfo");
       System.out.println("after loadClass... ");
       System.out.println("before newInstance... ");
       ClassInfo info1 =(ClassInfo) c.newInstance();
       System.out.println("after newInstance... ");
       输出结果:
       before loadClass...
       after loadClass...
       before newInstance...
       static invoked...
       contruct invoked...
       after newInstance...
   
  

       System.out.println("before class.forName");
       Class cc =Class.forName("com.hundsun.test.ClassInfo");
       System.out.println("after class.forName");
       ClassInfo info2 =(ClassInfo) cc.newInstance();
       输出结果：
       before class.forName
       static invoked...
       after class.forName
       before newInstance...
       contruct invoked...
       after newInstance...
   
  

       1. 类加载：Bootstrap Loader——》Extended Loader——》System Loader
       2. 静态代码块初始化
       3. 链接：
       a) 验证：是否符合java规范
       b) 准备：默认初始值
       c) 解析：符号引用转为直接引用，解析地址
       4. 初始化
       a) 赋值：java代码中的初始值
       b) 构造:构造函数
   
  

       public Class<?> loadClass(String name)throws ClassNotFoundException {
              return loadClass(name, false);
       }
       protectedsynchronized Class<?> loadClass(String name, boolean resolve)
                  throws ClassNotFoundException {
              // 首先判断该类型是否已经被加载
               Class c = findLoadedClass(name);
              if (c == null) {
                  //如果没有被加载，就委托给父类加载或者委派给启动类加载器加载
                  try {
                      if (parent != null) {
       //如果存在父类加载器，就委派给父类加载器加载
                           c = parent.loadClass(name, false);
                       } else {
       //如果不存在父类加载器，就检查是否是由启动类加载器加载的类，通过调用本地方法native Class findBootstrapClass(String name)
                           c = findBootstrapClass0(name);
                       }
                   } catch (ClassNotFoundException e) {
              // 如果父类加载器和启动类加载器都不能完成加载任务，才调用自身的加载功能
                       c = findClass(name);
                   }
               }
              if (resolve) {
                   resolveClass(c);
               }
              return c;
           }