我对Java语言的理解

古城微笑少年丶 2021-10-19 06:46 474阅读 0赞 
  1.     去年七月初通过校招进入了现在的公司，转眼已经过去一年多了，经过一年多的实战开发，重新整理一下自己对java的理解，希望能对正在面试以及即将入职工作的blogger有所帮助。

1、平台无关性

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70

  1.     Java源码首先被编译成字节码，再由不同的平台的JVM(Java Virtual Machine)进行解析，Java语言在不同的平台上运行时不需要进行重新编译，Java虚拟机在执行字节码的时候，把字节码转换成具体平台上的机器指令。
  3.     下面我们简单看一下jvm执行的字节码，命令 javap
  5. public class T {
  6.     public static void main(String[] args) {
  7.         int i = 1;
  8.         System.out.println(i++);
  9.     }
  10. }
  12.    使用 javap查看字节码

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70 1

2、JVM加载class文件

  1.     JVM如何加载编译好的class文件呢？
  3.     Java虚拟机：是一种抽象化的虚拟机，通过在实际计算机上仿真模拟各种计算机功能来实现的。JVM有自己完善的硬件架构，如处理器、堆栈、寄存器等，还具有相应的指令系统，JVM屏蔽了与具体操作系统windows、linux等相关的信息，使得Java程序只需生成在Java虚拟机上运行的代码及字节码，就可以在多种平台上不加修改的运行。
  5.     通常呢，我们不需要知道JVM的运行原理，只需要专注于Java代码就可以了，当然，这也是虚拟机之所以存在的原因，即屏蔽底层操作系统的不同，并且，减少基于原生语言的开发的复杂性。只要虚拟机厂商在特定操作系统上实现了虚拟机，定义如何将字节码解析成本操作系统可执行的二进制码，java语言便能跨越各种的平台。
  7.     JVM的架构 = Class Loader + Runtime Data Access + Execution Engine + Native Interface

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70 2

  1.     Class Loader: 依据特定格式，加载class文件到内存。
  3.     Execution Engine: 对命令进行解析，即解析class文件中的字节码，解析完成之后，提交操作系统执行。
  5.     Runtime Data Area: JVM内存空间结构模型，我们所写的程序都会被加载到这里，之后才开始运行。
  7.     Native Interface: 融合不同开发语言的原生库为Java所用，JVM开辟了一块区域用来专门处理标记为native的代码，具体做法是，在Native Method Stack中登记native方法，在Excution执行时，加载Native Libraries。
  9.     Class.forName中调用的forName0
  11. /**
  12.      * Returns the {@code Class} object associated with the class or
  13.      * interface with the given string name.  Invoking this method is
  14.      * equivalent to:
  15.      *
  16.      * <blockquote>
  17.      *  {@code Class.forName(className, true, currentLoader)}
  18.      * </blockquote>
  19.      *
  20.      * where {@code currentLoader} denotes the defining class loader of
  21.      * the current class.
  22.      *
  23.      * <p> For example, the following code fragment returns the
  24.      * runtime {@code Class} descriptor for the class named
  25.      * {@code java.lang.Thread}:
  26.      *
  27.      * <blockquote>
  28.      *   {@code Class t = Class.forName("java.lang.Thread")}
  29.      * </blockquote>
  30.      * <p>
  31.      * A call to {@code forName("X")} causes the class named
  32.      * {@code X} to be initialized.
  33.      *
  34.      * @param      className   the fully qualified name of the desired class.
  35.      * @return     the {@code Class} object for the class with the
  36.      *             specified name.
  37.      * @exception LinkageError if the linkage fails
  38.      * @exception ExceptionInInitializerError if the initialization provoked
  39.      *            by this method fails
  40.      * @exception ClassNotFoundException if the class cannot be located
  41.      */
  42.     @CallerSensitive
  43.     public static Class<?> forName(String className)
  44.                 throws ClassNotFoundException {
  45.         Class<?> caller = Reflection.getCallerClass();
  46.         return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
  47.     }
  49. /** Called after security check for system loader access checks have been made. */
  50.     private static native Class<?> forName0(String name, boolean initialize,
  51.                                             ClassLoader loader,
  52.                                             Class<?> caller)
  53.         throws ClassNotFoundException;

3、谈谈反射

  1.     Java反射机制是在运行状态中，对任意一个类，都能够知道这个类的所有属性和方法；对任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。
  3.     简单例子
  5. public class Dog {
  7.     private String name;
  9.     public void sayHi(String hi) {
  10.         System.out.println(hi + " " + name);
  11.     }
  13.     private String returnHello(String hello) {
  14.         return hello;
  15.     }
  16. }
  18. public class ReflectDemo {
  20.     public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
  22.         Class c = Class.forName("Dog");
  23.         if(!c.isAssignableFrom(Dog.class))
  24.             return ;
  25.         Dog dog = (Dog) c.newInstance();
  26.         System.out.println("Class name is " + c.getName());
  27.         Method returnHello = c.getDeclaredMethod("returnHello", String.class);
  28.         returnHello.setAccessible(true);
  29.         String str = (String) returnHello.invoke(dog, "ao wu");
  30.         System.out.println(str);
  31.         Method sayHi = c.getMethod("sayHi", String.class);
  32.         sayHi.invoke(dog, "hi");
  33.         Field name = c.getDeclaredField("name");
  34.         name.setAccessible(true);
  35.         name.set(dog, "Doge");
  36.         sayHi.invoke(dog, "hi");
  37.     }
  38. }
  40.     编译运行
  42. Class name is Dog
  43. ao wu
  44. hi null
  45. hi Doge
  47.     通过这个例子，我们可以知道，反射就是把Java类中的各种成分映射成一个个Java对象，Method、Field、Class。

4、ClassLoader

  1.     在上面我们之所以能够获得类的属性或者方法，并对其进行调用，必须要获取Class对象，而要获取该类的Class对象必先获取该类所对应字节码文件对象。
  3.     编译器将Dog.java源文件编译成Dog.class字节码文件。
  5.     ClassLoader将字节码转换成JVM中的Class<Dog>对象。
  7.     JVM利用Class<Dog>对象实例化为Dog对象。
  9.     ClassLoader: ClassLoader在Java中有着非常重要的作用，它主要工作在Class装载的加载阶段，其主要作用是从系统外部获得Class二进制数据流。它是Java的核心组件，所有的Class都是由ClassLoader进行加载的，ClassLoader负责通过将Class文件里的二进制数据流装进系统，然后交给Java虚拟机进行连接、初始化等操作。
  11.     ClassLoader的种类
  13.             BootStrapClassLoader: C++编写，加载Java自带的核心类库java.\*，比如java.lang包。
  15.             ExtClassLoader: Java编写，加载扩展库javax.\*，加载位于jre/lib/ext目录下的jar包。
  17.             AppClassLoader: Java编写，加载程序所在目录。
  19.             自定义ClassLoader: Java编写，定制化加载。
  21.     我们可以看一下ExtClassLoader的代码
  23. private static File[] getExtDirs() {
  24.             String var0 = System.getProperty("java.ext.dirs");
  25.             File[] var1;
  26.             if (var0 != null) {
  27.                 StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);
  28.                 int var3 = var2.countTokens();
  29.                 var1 = new File[var3];
  31.                 for(int var4 = 0; var4 < var3; ++var4) {
  32.                     var1[var4] = new File(var2.nextToken());
  33.                 }
  34.             } else {
  35.                 var1 = new File[0];
  36.             }
  38.             return var1;
  39.         }
  41.     可以看一下 "java.ext.dirs" 的路径
  43. System.out.println(System.getProperty("java.ext.dirs"));
  46. C:\ProgramFiles\Java\jdk1.8.0_131\jre\lib\ext;
  47. C:\Windows\Sun\Java\lib\ext
  49.     我们可以看一下AppClassLoader的代码
  51. public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
  52.             final String var1 = System.getProperty("java.class.path");
  53.             final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
  54.             return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
  55.                 public Launcher.AppClassLoader run() {
  56.                     URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
  57.                     return new Launcher.AppClassLoader(var1x, var0);
  58.                 }
  59.             });
  60.         }
  62.     可以看一下 "java.class.path" 的路径
  64. System.out.println(System.getProperty("java.class.path"));
  67. C:\Program Files\Java\jdk1.8.0_131\jre\lib\charsets.jar;
  68. C:\Program Files\Java\jdk1.8.0_131\jre\lib\deploy.jar;
  69. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\access-bridge-64.jar;
  70. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\cldrdata.jar;
  71. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\dnsns.jar;
  72. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jaccess.jar;
  73. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jfxrt.jar;
  74. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\localedata.jar
  75. ;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\nashorn.jar;
  76. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunec.jar;
  77. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunjce_provider.jar;
  78. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunmscapi.jar;
  79. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunpkcs11.jar;
  80. C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\zipfs.jar;
  81. C:\Program Files\Java\jdk1.8.0_131\jre\lib\javaws.jar;
  82. C:\Program Files\Java\jdk1.8.0_131\jre\lib\jce.jar;
  83. C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfr.jar;
  84. C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfxswt.jar;
  85. C:\Program Files\Java\jdk1.8.0_131\jre\lib\jsse.jar;
  86. C:\Program Files\Java\jdk1.8.0_131\jre\lib\management-agent.jar;
  87. C:\Program Files\Java\jdk1.8.0_131\jre\lib\plugin.jar;
  88. C:\Program Files\Java\jdk1.8.0_131\jre\lib\resources.jar;
  89. C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar;
  90. D:\IdeaProjects\JavaStudy\target\classes;
  91. D:\maven\repository\org\projectlombok\lombok\1.18.4\lombok-1.18.4.jar;
  92. D:\maven\repository\org\springframework\boot\spring-boot-starter-security\2.1.6.RELEASE\spring-boot-starter-security-2.1.6.RELEASE.jar;
  93. D:\maven\repository\org\springframework\boot\spring-boot-starter\2.1.6.RELEASE\spring-boot-starter-2.1.6.RELEASE.jar;
  94. D:\maven\repository\org\springframework\boot\spring-boot\2.1.6.RELEASE\spring-boot-2.1.6.RELEASE.jar;
  95. D:\maven\repository\org\springframework\boot\spring-boot-autoconfigure\2.1.6.RELEASE\spring-boot-autoconfigure-2.1.6.RELEASE.jar;
  96. D:\maven\repository\org\springframework\boot\spring-boot-starter-logging\2.1.6.RELEASE\spring-boot-starter-logging-2.1.6.RELEASE.jar;
  97. D:\maven\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;
  98. D:\maven\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;
  99. D:\maven\repository\org\slf4j\slf4j-api\1.7.25\slf4j-api-1.7.25.jar;
  100. D:\maven\repository\org\apache\logging\log4j\log4j-to-slf4j\2.11.2\log4j-to-slf4j-2.11.2.jar;
  101. D:\maven\repository\org\apache\logging\log4j\log4j-api\2.11.2\log4j-api-2.11.2.jar;D:\maven\repository\org\slf4j\jul-to-slf4j\1.7.26\jul-to-slf4j-1.7.26.jar;
  102. D:\maven\repository\javax\annotation\javax.annotation-api\1.3.2\javax.annotation-api-1.3.2.jar;
  103. D:\maven\repository\org\yaml\snakeyaml\1.23\snakeyaml-1.23.jar;D:\maven\repository\org\springframework\spring-aop\5.1.8.RELEASE\spring-aop-5.1.8.RELEASE.jar;
  104. D:\maven\repository\org\springframework\spring-beans\5.1.8.RELEASE\spring-beans-5.1.8.RELEASE.jar;
  105. D:\maven\repository\org\springframework\security\spring-security-config\5.1.5.RELEASE\spring-security-config-5.1.5.RELEASE.jar;
  106. D:\maven\repository\org\springframework\security\spring-security-core\5.1.5.RELEASE\spring-security-core-5.1.5.RELEASE.jar;
  107. D:\maven\repository\org\springframework\spring-context\5.1.6.RELEASE\spring-context-5.1.6.RELEASE.jar;
  108. D:\maven\repository\org\springframework\security\spring-security-web\5.1.5.RELEASE\spring-security-web-5.1.5.RELEASE.jar;
  109. D:\maven\repository\org\springframework\spring-expression\5.1.6.RELEASE\spring-expression-5.1.6.RELEASE.jar;
  110. D:\maven\repository\org\springframework\spring-web\5.1.6.RELEASE\spring-web-5.1.6.RELEASE.jar;
  111. D:\maven\repository\org\springframework\spring-core\5.1.5.RELEASE\spring-core-5.1.5.RELEASE.jar;
  112. D:\maven\repository\org\springframework\spring-jcl\5.1.5.RELEASE\spring-jcl-5.1.5.RELEASE.jar;
  113. C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.1\lib\idea_rt.jar
  115.     自定义ClassLoader的实现
  117.     关键函数 findClass、defineClass
  119. /**
  120.      * Finds the class with the specified <a href="#name">binary name</a>.
  121.      * This method should be overridden by class loader implementations that
  122.      * follow the delegation model for loading classes, and will be invoked by
  123.      * the {@link #loadClass <tt>loadClass</tt>} method after checking the
  124.      * parent class loader for the requested class.  The default implementation
  125.      * throws a <tt>ClassNotFoundException</tt>.
  126.      *
  127.      * @param  name
  128.      *         The <a href="#name">binary name</a> of the class
  129.      *
  130.      * @return  The resulting <tt>Class</tt> object
  131.      *
  132.      * @throws  ClassNotFoundException
  133.      *          If the class could not be found
  134.      *
  135.      * @since  1.2
  136.      */
  137.     protected Class<?> findClass(String name) throws ClassNotFoundException {
  138.         throw new ClassNotFoundException(name);
  139.     }
  141. /**
  142.      * Converts an array of bytes into an instance of class <tt>Class</tt>.
  143.      * Before the <tt>Class</tt> can be used it must be resolved.
  144.      *
  145.      * <p> This method assigns a default {@link java.security.ProtectionDomain
  146.      * <tt>ProtectionDomain</tt>} to the newly defined class.  The
  147.      * <tt>ProtectionDomain</tt> is effectively granted the same set of
  148.      * permissions returned when {@link
  149.      * java.security.Policy#getPermissions(java.security.CodeSource)
  150.      * <tt>Policy.getPolicy().getPermissions(new CodeSource(null, null))</tt>}
  151.      * is invoked.  The default domain is created on the first invocation of
  152.      * {@link #defineClass(String, byte[], int, int) <tt>defineClass</tt>},
  153.      * and re-used on subsequent invocations.
  154.      *
  155.      * <p> To assign a specific <tt>ProtectionDomain</tt> to the class, use
  156.      * the {@link #defineClass(String, byte[], int, int,
  157.      * java.security.ProtectionDomain) <tt>defineClass</tt>} method that takes a
  158.      * <tt>ProtectionDomain</tt> as one of its arguments.  </p>
  159.      *
  160.      * @param  name
  161.      *         The expected <a href="#name">binary name</a> of the class, or
  162.      *         <tt>null</tt> if not known
  163.      *
  164.      * @param  b
  165.      *         The bytes that make up the class data.  The bytes in positions
  166.      *         <tt>off</tt> through <tt>off+len-1</tt> should have the format
  167.      *         of a valid class file as defined by
  168.      *         <cite>The Java™ Virtual Machine Specification</cite>.
  169.      *
  170.      * @param  off
  171.      *         The start offset in <tt>b</tt> of the class data
  172.      *
  173.      * @param  len
  174.      *         The length of the class data
  175.      *
  176.      * @return  The <tt>Class</tt> object that was created from the specified
  177.      *          class data.
  178.      *
  179.      * @throws  ClassFormatError
  180.      *          If the data did not contain a valid class
  181.      *
  182.      * @throws  IndexOutOfBoundsException
  183.      *          If either <tt>off</tt> or <tt>len</tt> is negative, or if
  184.      *          <tt>off+len</tt> is greater than <tt>b.length</tt>.
  185.      *
  186.      * @throws  SecurityException
  187.      *          If an attempt is made to add this class to a package that
  188.      *          contains classes that were signed by a different set of
  189.      *          certificates than this class (which is unsigned), or if
  190.      *          <tt>name</tt> begins with "<tt>java.</tt>".
  191.      *
  192.      * @see  #loadClass(String, boolean)
  193.      * @see  #resolveClass(Class)
  194.      * @see  java.security.CodeSource
  195.      * @see  java.security.SecureClassLoader
  196.      *
  197.      * @since  1.1
  198.      */
  199.     protected final Class<?> defineClass(String name, byte[] b, int off, int len)
  200.         throws ClassFormatError
  201.     {
  202.         return defineClass(name, b, off, len, null);
  203.     }
  205.     自定义装载简单demo
  207. public class T {
  208.     static {
  209.         System.out.println("Hello I'm T");
  210.     }
  211. }
  215. import java.io.*;
  217. public class MyClassLoader extends ClassLoader {
  219.     private String path;
  220.     private String classLoadername;
  222.     public MyClassLoader(String path, String classLoadername) {
  223.         this.path = path;
  224.         this.classLoadername = classLoadername;
  225.     }
  227.     @Override
  228.     protected Class<?> findClass(String name) throws ClassNotFoundException {
  229.         byte[] bytes = classLoaderName(name);
  230.         return defineClass(name, bytes, 0, bytes.length);
  231.     }
  233.     private byte[] classLoaderName(String name) {
  234.         name = path + name + ".class";
  235.         InputStream in = null;
  236.         ByteArrayOutputStream out = null;
  237.         try {
  238.             in = new FileInputStream(new File(name));
  239.             out = new ByteArrayOutputStream();
  240.             int i = 0;
  241.             while((i = in.read()) != -1) {
  242.                 out.write(i);
  243.             }
  244.         } catch (IOException e) {
  245.             e.printStackTrace();
  246.         } finally {
  247.             try {
  248.                 out.close();
  249.                 in.close();
  250.             } catch (IOException e) {
  251.                 e.printStackTrace();
  252.             }
  253.         }
  254.         return out.toByteArray();
  255.     }
  257.     public String getClassLoadername() {
  258.         return classLoadername;
  259.     }
  261.     public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
  262.         MyClassLoader myClassLoader = new MyClassLoader("C:\\Users\\Administrator\\Desktop\\", "myClassLoader");
  263.         Class c = myClassLoader.loadClass("T");
  264.         System.out.println(myClassLoader.getClassLoadername());
  265.         System.out.println(myClassLoader.getParent());
  266.         System.out.println(myClassLoader.getParent().getParent());
  267.         System.out.println(myClassLoader.getParent().getParent().getParent()); 
  268.         c.newInstance();
  269.     }
  270. }
  272.     运行测试main函数
  274. myClassLoader
  275. sun.misc.Launcher$AppClassLoader@18b4aac2
  276. sun.misc.Launcher$ExtClassLoader@5ca881b5
  277. null
  278. Hello I'm T
  280. 进程完成，退出码 0

5、类加载器的双亲委派机制

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70 3

  1.     不同ClassLoader加载路径不同，逻辑明确，为了实现分工，各自负责各自的区块。
  3.     ClassLoader的loadClass源码如下，感兴趣可以了解一下。
  5. /**
  6.      * Loads the class with the specified <a href="#name">binary name</a>.  The
  7.      * default implementation of this method searches for classes in the
  8.      * following order:
  9.      *
  10.      * <ol>
  11.      *
  12.      *   <li><p> Invoke {@link #findLoadedClass(String)} to check if the class
  13.      *   has already been loaded.  </p></li>
  14.      *
  15.      *   <li><p> Invoke the {@link #loadClass(String) <tt>loadClass</tt>} method
  16.      *   on the parent class loader.  If the parent is <tt>null</tt> the class
  17.      *   loader built-in to the virtual machine is used, instead.  </p></li>
  18.      *
  19.      *   <li><p> Invoke the {@link #findClass(String)} method to find the
  20.      *   class.  </p></li>
  21.      *
  22.      * </ol>
  23.      *
  24.      * <p> If the class was found using the above steps, and the
  25.      * <tt>resolve</tt> flag is true, this method will then invoke the {@link
  26.      * #resolveClass(Class)} method on the resulting <tt>Class</tt> object.
  27.      *
  28.      * <p> Subclasses of <tt>ClassLoader</tt> are encouraged to override {@link
  29.      * #findClass(String)}, rather than this method.  </p>
  30.      *
  31.      * <p> Unless overridden, this method synchronizes on the result of
  32.      * {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method
  33.      * during the entire class loading process.
  34.      *
  35.      * @param  name
  36.      *         The <a href="#name">binary name</a> of the class
  37.      *
  38.      * @param  resolve
  39.      *         If <tt>true</tt> then resolve the class
  40.      *
  41.      * @return  The resulting <tt>Class</tt> object
  42.      *
  43.      * @throws  ClassNotFoundException
  44.      *          If the class could not be found
  45.      */
  46.     protected Class<?> loadClass(String name, boolean resolve)
  47.         throws ClassNotFoundException
  48.     {
  49.         synchronized (getClassLoadingLock(name)) {
  50.             // First, check if the class has already been loaded
  51.             Class<?> c = findLoadedClass(name);
  52.             if (c == null) {
  53.                 long t0 = System.nanoTime();
  54.                 try {
  55.                     if (parent != null) {
  56.                         c = parent.loadClass(name, false);
  57.                     } else {
  58.                         c = findBootstrapClassOrNull(name);
  59.                     }
  60.                 } catch (ClassNotFoundException e) {
  61.                     // ClassNotFoundException thrown if class not found
  62.                     // from the non-null parent class loader
  63.                 }
  65.                 if (c == null) {
  66.                     // If still not found, then invoke findClass in order
  67.                     // to find the class.
  68.                     long t1 = System.nanoTime();
  69.                     c = findClass(name);
  71.                     // this is the defining class loader; record the stats
  72.                     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
  73.                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
  74.                     sun.misc.PerfCounter.getFindClasses().increment();
  75.                 }
  76.             }
  77.             if (resolve) {
  78.                 resolveClass(c);
  79.             }
  80.             return c;
  81.         }
  82.     }
  84.     自底向上检查名字为name的类是否已被装载，如果没有，自顶向下装载名字为name的类，关键代码如下：
  86. if (parent != null) {
  87.                         c = parent.loadClass(name, false);
  88.                     } else {
  89.                         c = findBootstrapClassOrNull(name);
  90.                     }
  92.     上述代码也正可以和输出结果做对比，当parent为null时，则会调用我们的BootStrapClassLoader。
  94. myClassLoader
  95. sun.misc.Launcher$AppClassLoader@18b4aac2
  96. sun.misc.Launcher$ExtClassLoader@5ca881b5
  97. null
  98. Hello I'm T
  100. 进程完成，退出码 0
  102. // return null if not found
  103.     private native Class<?> findBootstrapClass(String name);
  105.     注意，findBootstrapClass为native标记的方法，在运行时，会调用本地库或外置的非Java代码。
  107.     如何确定findBootstrapClass为C++代码呢？查看网址[http://hg.openjdk.java.net/][http_hg.openjdk.java.net]，一下为ClassLoader.c截图

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70 4

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70 5

  1.     查看源码之后，再来回答一下，为什么要使用双亲委派机制：避免多分同样字节码的加载。

6、loadClass和forName的区别

  1.     隐式加载： new，隐式调用类加载器，加载对应类，创建对应实例。
  3.     显式加载： loadClass、forName等，显式加载构建Class对象，然后调用Class的newInstance创建实例。
  5.     loadClass和forName： 都能知道该类的所有属性和方法，对于任一对象都能调用它的任意防范和属性。
  7.     loadClass： ClassLoader.loadClass得到的class是还没有链接的。
  9.     forName： Class.forName得到的class是已经初始化完成的。
  11.     类的装载过程

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70 6

  1.     来看一下下面的小demo
  3. public class T {
  4.     static {
  5.         System.out.println("Hello I'm T");
  6.     }
  7. }
  9. public class T2 {
  10.     public static void main(String[] args) throws ClassNotFoundException {
  11.         System.out.println("我是ClassLoader.loadClass");
  12.         ClassLoader cl = T.class.getClassLoader();
  13.         Class<T> tLoadClass = (Class<T>) cl.loadClass("T");
  14.         System.out.println("我是Class.forName");
  15.         Class<T> tForName = (Class<T>) Class.forName("T");
  16.     }
  17. }
  19.     运行T2的main方法：
  21. 我是ClassLoader.loadClass
  22. 我是Class.forName
  23. Hello I'm T
  25.      从上述执行结果，我们可知道，Class.forName得到的class是已经初始化完成的，ClassLoader.loadClass得到的class是还没有链接的。比如，我们在程序中要加载我们的数据库驱动Driver，我们要使Class.forName。而为什么还会有ClassLoader.loadClass，主要是与LazyLoading有关，ClassLoader.loadClass不需要执行类的链接和初始化，加快了初始化速度。

7、Java的内存模型

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70 7

  1.     线程私有：程序计数器、虚拟机栈、本地方法栈。
  3.     线程共享：MetaSpace、Java堆。
  5.     Java虚拟机栈(Stack)
  7.             Java方法执行的内存模型。
  9.             包含多个栈帧。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70 8

  1.     局部变量表和操作数栈
  3.             局部变量表：包含方法执行过程中的所有变量。
  5.             操作数栈：入栈、出栈、复制、交换、产生消费变量。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzMyODI5_size_16_color_FFFFFF_t_70 9

  1.     递归为什么会引发 java.lang.StackOverflowError 异常： 当线程执行一个方法时，就会随之创建一个对应的栈帧，并将建立的栈帧压入虚拟机栈中，当方法执行完，便会将栈帧出栈，因此可知，线程当前执行的方法对应的栈帧位于Java栈的顶部，而我们的递归函数不断的去调用自身，每一次方法调用会涉及：（1）每新调用一个方法就会生成一个栈帧；（2）会保存当前方法的栈帧状态，将它放在虚拟机栈中；（3）栈帧上下文切换，会切换到最新的方法栈中，而我们每个虚拟机栈是固定的，递归过深，栈帧数超过虚拟机栈深度。解决思路：（1）限制递归次数；（2）使用循环替换递归等等。
  3.     虚拟机栈过多引发 java.lang.OutOfMemoryError异常：  当虚拟机栈可以动态扩展时，如果无法申请足够多的内存，就会抛出这个异常。
  5. public void stackLeakByThread() {
  6.         while(true) {
  7.             new Thread(() -> {
  8.                 while(true) {}
  9.             }).start();
  10.         }
  11.     }
  13.     本地方法栈
  15.             与虚拟机相似，主要作用于标注了native的方法。
  17.     元空间（MetaSpace）与永久代（PermGen）
  19.     存储class的相关信息，包括class的method、field等等，两者均是方法区的实现，方法区知识JVM的一种规范。Java1.7之后，原先位于方法区中的字符串常量池已被移动到了Java堆当中，并且，1.8之后，使用元空间替代了永久代。                                                                                                                                                                    元空间使用本地内存，而永久代使用的是jvm的内存。
  21.     Java堆（Heap）
  23.             对象实例的分配区域
  25.             GC管理的主要区域

发表评论

表情：
评论列表 （有 0 条评论，474人围观）

还没有评论，来说两句吧...

相关阅读

    相关 我对软件工程的理解

    最近在重学软件工程相关的知识，一方面是对自己过往工作经历的一个梳理总结；另一方面，是在和同行交流过程中，发现自己对于一些知识的理解还存在不足。后续一段时间的文章内容，会以软件工

    红太狼红太狼/ 0 赞/ 68 阅读

    相关 谈谈我对协程的理解

    协程相关视频解析： [linux系统下协程的实现与原理剖析训练营（上）][linux] [linux系统下协程的实现与原理剖析训练营（下）][linux 1] 什

    悠悠悠悠/ 0 赞/ 284 阅读

    相关 我对BFC的理解

    　　最初这篇文章打算回答寒冬大神的[第一问][Link 1]，谈谈CSS布局。本来呢我以为布局主要涉及float跟display相关属性，以及他们的包含框、静态位置等等。后来看

    绝地灬酷狼绝地灬酷狼/ 0 赞/ 323 阅读

    相关 我对模块化的理解

    模块化是一个"发现" 模块化(Modularity)这个概念与其说是一种创新，不如说是一个"发现"。这正是人们在解决问题时常用的行为方式和思维过程。它不是单纯的技术问题，

    小灰灰小灰灰/ 0 赞/ 297 阅读

    相关 我对Java语言的理解

            去年七月初通过校招进入了现在的公司，转眼已经过去一年多了，经过一年多的实战开发，重新整理一下自己对java的理解，希望能对正在面试以及即将入职工作的blogge

    古城微笑少年丶古城微笑少年丶/ 0 赞/ 475 阅读

    相关 我对虚函数的理解

           虚函数是具备这样一种能力的函数：能够在知道少量信息的情况下判断出自己的所属者，进而调用所属者里对应的函数。以虚析构函数为例解释下，当我们释放一个用基类的指针指向派

    系统管理员系统管理员/ 0 赞/ 502 阅读