JVM 高频面试题

上篇码之初整理汇总了 Java 并发高频面试题，乡亲们似乎都很满意，说明做这个系列是有意义的，当有了意义也便有了更多的快乐，这一切都要谢谢乡亲们，就不多寒暄了，直接进入主题，今天要讲解的是关于 JVM 方面的一些高频面试题，基本上面试必问，所以这篇真的很重要，希望看完的乡亲们都能有收获。

1. JVM 内存模型以及分区，需要详细到每个区放什么。

答：JVM 分为堆区和栈区，还有方法区，初始化的对象放在堆里面，引用放在栈里面，class 类信息常量池 (static 常量和 static 变量) 等放在方法区。

• 方法区：主要是存储类信息，常量池 (static 常量和 static 变量)，编译后的代码 (字 节码) 等数据。

• 堆：初始化的对象，成员变量 (那种非 static 的变量)，所有的对象实例和数组都要 在堆上分配。

• 栈：栈的结构是栈帧组成的，调用一个方法就压入一帧，帧上面存储局部变量表，操 作数栈，方法出口等信息，局部变量表存放的是 8 大基础类型加上一个应用类型，所 以还是一个指向地址的指针。

• 本地方法栈：主要为 Native 方法服务。

• 程序计数器：记录当前线程执行的行号。

2、JVM 每个区的作用是什么？

方法区:

1. 有时候也成为永久代，在该区内很少发生垃圾回收，但是并不代表不发生 GC，在这里 进行的 GC 主要是对方法区里的常量池和对类型的卸载。

2. 方法区主要用来存储已被虚拟机加载的类的信息、常量、静态变量和即时编译器编译后 的代码等数据。

3. 该区域是被线程共享的。

4. 方法区里有一个运行时常量池，用于存放静态编译产生的字面量和符号引用。该常量池 具有动态性，也就是说常量并不一定是编译时确定，运行时生成的常量也会存在这个常量 池中。

虚拟机栈:

1. 虚拟机栈也就是我们平常所称的栈内存，它为 java 方法服务，每个方法在执行的时候都 会创建一个栈帧，用于存储局部变量表、操作数栈、动态链接和方法出口等信息。

2. 虚拟机栈是线程私有的，它的生命周期与线程相同。

3. 局部变量表里存储的是基本数据类型、returnAddress 类型 (指向一条字节码指令的地 址) 和对象引用，这个对象引用有可能是指向对象起始地址的一个指针，也有可能是代表 对象的句柄或者与对象相关联的位置。局部变量所需的内存空间在编译器间确定。

4. 操作数栈的作用主要用来存储运算结果以及运算的操作数，它不同于局部变量表通过索 引来访问，而是压栈和出栈的方式。

5. 每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用是为了 支持方法调用过程中的动态连接。动态链接就是将常量池中的符号引用在运行期转化为直接 引用。

本地方法栈：

本地方法栈和虚拟机栈类似，只不过本地方法栈为 Native 方法服务。

堆：

java 堆是所有线程所共享的一块内存，在虚拟机启动时创建，几乎所有的对象实例都在这 里创建，因此该区域经常发生垃圾回收操作。

程序计数器：

内存空间小，字节码解释器工作时通过改变这个计数值可以选取下一条需要执行的字节码 指令，分支、循环、跳转、异常处理和线程恢复等功能都需要依赖这个计数器完成。该内 存区域是唯一一个 java 虚拟机规范没有规定任何 OOM 情况的区域。

3、堆里面的分区：Eden，survival (from+ to)，老年代，各自的特点。

答：堆里面分为新生代和老生代 (java8 取消了永久代，采用了 Metaspace)，新生代包含 Eden+Survivor 区，survivor 区里面分为 from 和 to 区，内存回收时，如果用的是复制算法，从 from 复制到 to，当经过一次或者多次 GC 之后，存活下来的对象会被移动到老年区，当 JVM 内存不够用的时候，会触发 Full GC，清理 JVM 老年区当新生区满了之后会触发 YGC, 先把存活的对象放到其中一个 Survice 区，然后进行垃圾清理。因为如果仅仅清理需要删除的对象，这样会导致内存碎片，因此一般会把 Eden 进行完全的清理，然后整理内存。那么下次 GC 的时候，就会使用下一个 Survive，这样循环使用。如果有特别大的对象，新生代放不下，就会使用老年代的担保，直接放到老年代里面。因为 JVM 认为，一般大对象的存活时间一般比较久远。

4、GC 的两种判定方法？

• 引用计数法：指的是如果某个地方引用了这个对象就 + 1，如果失效了就 - 1，当为 0 就会回收但。是 JVM 没有用这种方式，因为无法判定相互循环引用 (A 引用 B,B 引用 A) 的情况。

• 引用链法：通过一种 GC ROOT 的对象 (方法区中静态变量引用的对象等 - static 变量) 来判断，如果有一条链能够到达 GC ROOT 就说明，不能到达 GC ROOT 就说明可以回收。

5、SafePoint 是什么？

答：比如 GC 的时候必须要等到 Java 线程都进入到 safepoint 的时候 VMThread 才能开始 执行 GC。

1. 循环的末尾 (防止大循环的时候一直不进入 safepoint，而其他线程在等待它进入 safepoint)。

2. 方法返回前。

3. 调用方法的 call 之后 4。

4. 抛出异常的位置。

6、GC 的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用 在什么地方，如果让你优化收集方法，有什么思路？

（1）标记清除算法

分为标记和清除两个阶段，首先标记所有需要回收的对象，在标记完成后统一回收所有被标记的对象。它主要有两个问题：一个是效率问题，标记清除的效率较低；第二个是碎片问题，清除后会产生大量不连续的内存碎片。

（2）复制算法 — 回收新生代，回收比例较大

原理就是把内存划分为大小相等的两块，每次只使用其中的一块。当这一块上的内存用完了，就把还存活的对象（可达性分析）复制到另一块上，然后把已使用过的内存空间一次性清理掉，这样每次都不用考虑内存碎片的情况，并且实现的更加简单。如果存活的比例很低，那么复制的操作就很小，效率会比较高。只是如果一次只使用其中一半，那么代价太大了。现在主要都是用于新生代的回收，98% 的新生代对象都是很快就不用的，所以只需要把内存分为一块较大的 Eden 空间和两块 Survivor 空间，每次只使用 Eden 和一块 Survivor 空间，当回收时把两个区域存活的对象复制到那一块剩余的 Survivor 上。一般比例为 8:1，这样浪费的空间只有 10%。如果 Survivor 内存不够，就是用老年代的内存进行担保。

（3）标记整理算法 — 回收老年代，回收比例较小

对于老年代，存活的比例一般会比较高，如果使用复制算法那么复制操作的效率就会比较低。根据老年代的特点，提出了标记整理算法，先标记需要回收的对象；第二部不是进行回收，而是将存活对象都移动向一端，然后直接清除掉边界外的内存。

（4）分代收集算法 — 常见虚拟机的方式

分代收集算法就是综合 2、3，对于堆中的不同区域使用不同的收集算法。

7、GC 收集器有哪些？CMS 收集器与 G1 收集器的特点。

（1）Serial 收集器

Serial 收集器是最基本的收集器，这是一个单线程收集器，它 “单线程” 的意义不仅仅是说明它只用一个线程去完成垃圾收集工作，更重要的是在它进行垃圾收集工作时，必须暂停其他工作线程，直到它收集完成。Sun 将这件事称之为”Stop the world“。没有一个收集器能完全不停顿，只是停顿的时间长短。虽然 Serial 收集器的缺点很明显，但是它仍然是 JVM 在 Client 模式下的默认新生代收集器。它有着优于其他收集器的地方：简单而高效（与其他收集器的单线程比较），Serial 收集器由于没有线程交互的开销，专心只做垃圾收集自然也获得最高的效率。在用户桌面场景下，分配给 JVM 的内存不会太多，停顿时间完全可以在几十到一百多毫秒之间，只要收集不频繁，这是完全可以接受的。

（2）ParNew 收集器

ParNew 是 Serial 的多线程版本，在回收算法、对象分配原则上都是一致的。ParNew 收集器是许多运行在 Server 模式下的默认新生代垃圾收集器，其主要在于除了 Serial 收集器，目前只有 ParNew 收集器能够与 CMS 收集器配合工作。

（3）Parallel Scavenge 收集器

Parallel Scavenge 收集器是一个新生代垃圾收集器，其使用的算法是复制算法，也是并行的多线程收集器。Parallel Scavenge 收集器更关注可控制的吞吐量，吞吐量等于运行用户代码的时间 /(运行用户代码的时间 + 垃圾收集时间)。直观上，只要最大的垃圾收集停顿时间越小，吞吐量是越高的，但是 GC 停顿时间的缩短是以牺牲吞吐量和新生代空间作为代价的。比如原来 10 秒收集一次，每次停顿 100 毫秒，现在变成 5 秒收集一次，每次停顿 70 毫秒。停顿时间下降的同时，吞吐量也下降了。停顿时间越短就越适合需要与用户交互的程序；而高吞吐量则可以最高效的利用 CPU 的时间，尽快的完成计算任务，主要适用于后台运算。

（4）Serial Old 收集器

Serial Old 收集器是 Serial 收集器的老年代版本，也是一个单线程收集器，采用 “标记 - 整理算法” 进行回收。其运行过程与 Serial 收集器一样。

（5）Parallel Old 收集器

Parallel Old 收集器是 Parallel Scavenge 收集器的老年代版本，使用多线程和标记 - 整理算法进行垃圾回收。其通常与 Parallel Scavenge 收集器配合使用，“吞吐量优先” 收集器是这个组合的特点，在注重吞吐量和 CPU 资源敏感的场合，都可以使用这个组合。

（6）CMS 收集器

CMS（Concurrent Mark Sweep）收集器是一种以获取最短停顿时间为目标的收集器，CMS 收集器采用标记 – 清除算法，运行在老年代。主要包含以下几个步骤：

• 初始标记

• 并发标记

• 重新标记

• 并发清除

其中初始标记和重新标记仍然需要 “Stop the world”。初始标记仅仅标记 GC Root 能直接关联的对象，并发标记就是进行 GC Root Tracing 过程，而重新标记则是为了修正并发标记期间，因用户程序继续运行而导致标记变动的那部分对象的标记记录。由于整个过程中最耗时的并发标记和并发清除，收集线程和用户线程一起工作，所以总体上来说，CMS 收集器回收过程是与用户线程并发执行的。虽然 CMS 优点是并发收集、低停顿，很大程度上已经是一个不错的垃圾收集器，但是还是有三个显著的缺点：

• CMS 收集器对 CPU 资源很敏感。在并发阶段，虽然它不会导致用户线程停顿，但是会因为占用一部分线程（CPU 资源）而导致应用程序变慢。

• CMS 收集器不能处理浮动垃圾。所谓的 “浮动垃圾”，就是在并发标记阶段，由于用户程序在运行，那么自然就会有新的垃圾产生，这部分垃圾被标记过后，CMS 无法在当次集中处理它们，只好在下一次 GC 的时候处理，这部分未处理的垃圾就称为 “浮动垃圾”。也是由于在垃圾收集阶段程序还需要运行，即还需要预留足够的内存空间供用户使用，因此 CMS 收集器不能像其他收集器那样等到老年代几乎填满才进行收集，需要预留一部分空间提供并发收集时程序运作使用。要是 CMS 预留的内存空间不能满足程序的要求，这是 JVM 就会启动预备方案：临时启动 Serial Old 收集器来收集老年代，这样停顿的时间就会很长。

• 由于 CMS 使用标记 – 清除算法，所以在收集之后会产生大量内存碎片。当内存碎片过多时，将会给分配大对象带来困难，这是就会进行 Full GC。

（7）G1 收集器

G1 收集器与 CMS 相比有很大的改进：

• G1 收集器采用标记 – 整理算法实现。

• 可以非常精确地控制停顿。

G1 收集器可以实现在基本不牺牲吞吐量的情况下完成低停顿的内存回收，这是由于它极力的避免全区域的回收，G1 收集器将 Java 堆（包括新生代和老年代）划分为多个区域（Region），并在后台维护一个优先列表，每次根据允许的时间，优先回收垃圾最多的区域 。

8、Minor GC 与 Full GC 分别在什么时候发生？

• 新生代内存不够用时候发生 MGC，也叫 YGC。

• JVM 内存不够的时候发生 FGC 。

9、JVM 类加载的几个过程？

答：JVM 类加载过程分为：加载、验证、准备、解析、初始化。

1. 加载

加载时 jvm 做了这三件事：

1）通过一个类的全限定名来获取该类的二进制字节流

2）将这个字节流的静态存储结构转化为方法区运行时数据结构

3）在内存堆中生成一个代表该类的 java.lang.Class 对象，作为该类数据的访问入口

2. 验证

验证、准备、解析这三步可以看做是一个连接的过程，将类的字节码连接到 JVM 的运行状态之中

验证是为了确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，不会威胁到 jvm 的安全

验证主要包括以下几个方面的验证：

1）文件格式的验证，验证字节流是否符合 Class 文件的规范，是否能被当前版本的虚拟机处理

2）元数据验证，对字节码描述的信息进行语义分析，确保符合 java 语言规范

3）字节码验证 通过数据流和控制流分析，确定语义是合法的，符合逻辑的

4）符号引用验证 这个校验在解析阶段发生

**3. 准备  **为类的静态变量分配内存，初始化为系统的初始值。对于 final static 修饰的变量，

直接赋值为用户的定义值。如下面的例子：这里在准备阶段过后的初始值为 0，而不是 7

public static int a=7

4. 解析

解析是将常量池内的符号引用转为直接引用（如物理内存地址指针）

****5. 初始化    ****

到了初始化阶段，jvm 才真正开始执行类中定义的 java 代码

1）初始化阶段是执行类构造器 () 方法的过程。类构造器 < clinit>() 方法是由编译器自动收集。

类中的所有类变量的赋值动作和静态语句块 (static 块) 中的语句合并产生的。

2）当初始化一个类的时候，如果发现其父类还没有进行过初始化、则需要先触发其父类的初始化。

3）虚拟机会保证一个类的 () 方法在多线程环境中被正确加锁和同步。

10、如和判断一个对象是否存活？(或者 GC 对象的判定方 法)

答：判断一个对象是否存活有两种方法:
1. 引用计数法：****

所谓引用计数法就是给每一个对象设置一个引用计数器，每当有一个地方引用这个对象 时，就将计数器加一，引用失效时，计数器就减一。当一个对象的引用计数器为零时，说 明此对象没有被引用，也就是 “死对象”, 将会被垃圾回收.。引用计数法有一个缺陷就是无法解决循环引用问题，也就是说当对象 A 引用对象 B，对象 B 又引用者对象 A，那么此时 A,B 对象的引用计数器都不为零，也就造成无法完成垃圾回 收，所以主流的虚拟机都没有采用这种算法。

2. 可达性算法 (引用链法)：

该算法的思想是：从一个被称为 **GC Roots **的对象开始向下搜索，如果一个对象到 GC Roots 没有任何引用链相连时，则说明此对象不可用。在 java 中可以作为 GC Roots 的对象有以下几种:

• 虚拟机栈中引用的对象

• 方法区类静态属性引用的对象

• 方法区常量池引用的对象

• 本地方法栈 JNI 引用的对象

虽然这些算法可以判定一个对象是否能被回收，但是当满足上述条件时，一个对象比不一定会被回收。当一个对象不可达 GC Root 时，这个对象并 不会立马被回收，而是出于一个死缓的阶段，若要被真正的回收需要经历两次标记 如果对象在可达性分析中没有与 GC Root 的引用链，那么此时就会被第一次标记并且进行 一次筛选，筛选的条件是是否有必要执行 finalize () 方法。当对象没有覆盖 finalize () 方法 或者已被虚拟机调用过，那么就认为是没必要的。如果该对象有必要执行 finalize () 方法，那么这个对象将会放在一个称为 F-Queue 的对队 列中，虚拟机会触发一个 Finalize () 线程去执行，此线程是低优先级的，并且虚拟机不会承 诺一直等待它运行完，这是因为如果 finalize () 执行缓慢或者发生了死锁，那么就会造成 F- Queue 队列一直等待，造成了内存回收系统的崩溃。GC 对处于 F-Queue 中的对象进行 第二次被标记，这时，该对象将被移除” 即将回收” 集合，等待回收。

11、简述 java 垃圾回收机制？

答： 在 java 中，程序员是不需要显示的去释放一个对象的内存的，而是由虚拟机自行执行。在 JVM 中，有一个垃圾回收线程，它是低优先级的，在正常情况下是不会执行的，只有在虚 拟机空闲或者当前堆内存不足时，才会触发执行，扫面那些没有被任何引用的对象，并将 它们添加到要回收的集合中，进行回收。

14、java 中垃圾收集的方法有哪些？

1. 标记 - 清除：

这是垃圾收集算法中最基础的，根据名字就可以知道，它的思想就是标记哪些要被 回收的对象，然后统一回收。这种方法很简单，但是会有两个主要问题：1. 效率不 高，标记和清除的效率都很低；2. 会产生大量不连续的内存碎片，导致以后程序在 分配较大的对象时，由于没有充足的连续内存而提前触发一次 GC 动作。

2. 复制算法：

为了解决效率问题，复制算法将可用内存按容量划分为相等的两部分，然后每次只 使用其中的一块，当一块内存用完时，就将还存活的对象复制到第二块内存上，然 后一次性清楚完第一块内存，再将第二块上的对象复制到第一块。但是这种方式， 内存的代价太高，每次基本上都要浪费一般的内存。 于是将该算法进行了改进，内存区域不再是按照 1:1 去划分，而是将内存划分为 8:1:1 三部分，较大那份内存交 Eden 区，其余是两块较小的内存区叫 Survior 区。每次都会优先使用 Eden 区，若 Eden 区满，就将对象复制到第二块内存区上，然 后清除 Eden 区，如果此时存活的对象太多，以至于 Survivor 不够时，会将这些对 象通过分配担保机制复制到老年代中。(java 堆又分为新生代和老年代)

3. 标记 - 整理：

该算法主要是为了解决标记 - 清除，产生大量内存碎片的问题；当对象存活率较高 时，也解决了复制算法的效率问题。它的不同之处就是在清除对象的时候现将可回 收对象移动到一端，然后清除掉端边界以外的对象，这样就不会产生内存碎片了。

4. 分代收集：

现在的虚拟机垃圾收集大多采用这种方式，它根据对象的生存周期，将堆分为新生 代和老年代。在新生代中，由于对象生存期短，每次回收都会有大量对象死去，那 么这时就采用 复制 算法。老年代里的对象存活率较高，没有额外的空间进行分配担 保，所以可以使用 标记 - 整理 或者 标记 - 清除 。

15、简述 java 类加载机制？

答：虚拟机把描述类的数据从 Class 文件加载到内存，并对数据进行校验，解析和初始化，最 终形成可以被虚拟机直接使用的 java 类型。

16、类加载器双亲委派模型机制？

答：当一个类收到了类加载请求时，不会自己先去加载这个类，而是将其委派给父类，由父类去加载，如果此时父类不能加载，反馈给子类，由子类去完成类的加载。

17、什么是类加载器，类加载器有哪些？

答：实现通过类的权限定名获取该类的二进制字节流的代码块叫做类加载器。主要有一下四种类加载器:

1. 启动类加载器 (Bootstrap ClassLoader) 用来加载 java 核心类库，无法被 java 程序直接 引用。

2. 扩展类加载器 (extensions class loader): 它用来加载 Java 的扩展库。Java 虚拟机的 实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。

3. 系统类加载器 (system class loader): 它根据 Java 应用的类路径 (CLASSPATH) 来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader () 来获取它。

4. 用户自定义类加载器，通过继承 java.lang.ClassLoader 类的方式实现。

20、简述 java 内存分配与回收策率以及 Minor GC 和 Major GC

1. 对象优先在堆的 Eden 区分配。

2. 大对象直接进入老年代。

3. 长期存活的对象将直接进入老年代。

当 Eden 区没有足够的空间进行分配时，虚拟机会执行一次 Minor GC.Minor Gc 通 常发生在新生代的 Eden 区，在这个区的对象生存期短，往往发生 Gc 的频率较高， 回收速度比较快；Full Gc/Major GC 发生在老年代，一般情况下，触发老年代 GC 的时候不会触发 Minor GC, 但是通过配置，可以在 Full GC 之前进行一次 Minor GC 这样可以加快老年代的回收速度。

21、简述对象创建方法？

答：对象的创建方法主要是：new 的过程

1. 进行类加载检查。当遇到一个 new 指令，首先检查能否在方法区的常量池中能否定位到这个类的符号引用，并且检查类有没有进行加载、解析和初始化；

2. 分配空间。有两种常见的分配方式，一是指针碰撞，二是空闲列表，分别针对连续分配内存和不连续的，有空隙的，取决于虚拟机是否会压缩整理。内存分配的大小是在类加载完成之后就已经确定的，但是分配的时候修改指针的指向位置应该是线程安全的（栈上的 Reference），第一种方式就保证原子性；第二种是给每个线程分配自己的一小块内存，成为本地线程分配缓冲 (TLAB)，每个线程在自己的 TLAB 是哪个分配。

3. 初始化。将分配的内存初始化为 0 值。

4. 基本设置。进行基本的设置，确定这个对象是哪个类的实例，对象的 HASH 码，对象的年龄等等。

22、简述一下对象的内存布局？

答：对象在内存中的存储的布局可以分为 3 块区域：

1. 对象头（Header）：对象头包含两个部分的信息，第一部分是对象自身的运行时数据，如哈希码、GC 分代年龄、持有的锁等等；第二部分是类型指针，指向它的类元数据的指针，通过这个虚拟机来确定这个对象是哪个类的实例。

2. 实例数据（Instance Data）：对象真正存储的数据，就是程序代码中定义的字段内容。

3. 对齐填充（Padding）：用于使对象的开头必须是 8 字节的整数倍，无特殊意义。

23、说一下对象的访问定位？

对于这句代码：

Object objectRef = new Object();

Object objectRef  这部分将会反映到 Java 栈的本地变量中，作为一个 reference 类型数据出现。而 “new Object ()” 这部分将会反映到 Java 堆中，形成一块存储 Object 类型所有实例数据值的结构化内存，根据具体类型以及虚拟机实现的对象内存布局的不同，这块内存的长度是不固定。另外，在 java 堆中还必须包括能查找到此对象类型数据（如对象类型、父类、实现的接口、方法等）的地址信息，这些数据类型存储在方法区中。有两种基本的定位方式：

1. 句柄访问（间接）：在 Java 堆中划分一块内存作为句柄池（即一个句柄列表），reference 中存储的就是对象在句柄池中的地址，得到了句柄池的地址就可以知道对象的实例数据和类型数据的位置。

2. 直接指针访问（直接）：reference 中存储的直接就是对象的实例数据的地址，而实例数据中自己有一个指针存储对象类型数据的地址（方法区中），不需要 reference 来存储。

23、Minor GC 与 Full GC 分别在什么时候发生？

答：由于对象进行了分代处理，因此垃圾回收区域、时间也不一样。GC 有两种类型：Scavenge GC 和 Full GC。对于一个拥有终结方法的对象，在垃圾收集器释放对象前必须执行终结方法。但是当垃圾收集器第二次收集这个对象时便不会再次调用终结方法。

（1）Minor GC

一般情况下，当新对象生成，并且在 Eden 申请空间失败时，就会触发 Minor  GC，对 Eden 区域进行 GC，清除非存活对象，并且把尚且存活的对象移动到 Survivor 区，然后整理 Survivor 的两个区。这种方式的 GC 是对新生代的 Eden 区进行，不会影响到老年代。因为大部分对象都是从 Eden 区开始的，同时 Eden 区不会分配的很大，所以 Eden 区的 GC 会频繁进行。

（2）Full GC

对整个堆进行整理，包括 Young、Tenured 和 Perm。Full GC 因为需要对整个对进行回收，所以比 Minor GC 要慢，因此应该尽可能减少 Full GC 的次数。在对 JVM 调优的过程中，很大一部分工作就是对于 FullGC 的调节。有如下原因可能导致 Full GC：

• 老年代（Tenured）被写满

• 持久代（Perm）被写满

• System.gc () 被显示调用

---

白天陪长辈们打牌打了一天，所以到晚上才有时间整理关于 JVM 的高频面试题，JVM 知识的重要性不言而喻，也不要我多说，只要你走这条路，不管多晚，你都要和他打交道，所以这篇文章乡亲们一定要好好看看，哪怕知道一点概念也是好的，等静下心来的时候再慢慢研究。
【这里想说，因为自己也走了很多弯路过来的，所以才下定决心整理，收集过程虽不易，但想到能帮助到一部分自学java 的人，心里也是甜的！有需要的伙伴请点㊦方】↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓