Skip to content

Java

这里主要整理 Java 这条线。比起把它写成一份语法清单,我更想把它在工程里到底由哪些部分组成讲清楚:

  1. Java 是什么
  2. 它为什么长期出现在企业级系统里
  3. 语言层、并发层、JVM 层分别在解决什么问题
  4. 哪些知识是“写代码会用到”,哪些知识是“排查问题绕不开”

Java 可以看成 一门运行在 JVM 之上的通用编程语言,以及围绕它形成的一整套运行时和工程生态

这里的重点不只是“会写 Java 语法”,还包括:理解 Java 程序从源码到运行、从对象创建到垃圾回收、从单线程逻辑到并发执行,整体是怎么工作的。


1. 为什么 Java 不只是“一门语言”

很多语言只需要关心:

  1. 语法怎么写
  2. 代码怎么执行

但 Java 的学习范围通常会自然扩展到:

  1. JDK / JRE / JVM
  2. 集合框架
  3. 并发编程
  4. IO 与网络
  5. JVM 内存模型
  6. 垃圾回收和性能排查

这说明 Java 在工程里更像是:语言 + 运行时 + 标准库 + 工具链 + 生态体系

的组合。


2. Java 最核心的几条主线是什么

如果把 Java 压缩成最值得优先掌握的几条线,可以看这些:

2.1 语言基础与面向对象

这条线解决的是:代码如何组织、抽象如何表达、扩展性如何建立。

2.2 集合框架

这条线解决的是:数据在内存里如何组织、如何查找、如何遍历、如何在不同场景下选择合适结构。

2.3 并发编程

这条线解决的是:多个线程同时工作时,如何避免竞态、如何保证可见性、如何提高吞吐又不破坏正确性。

2.4 IO 与网络

这条线解决的是:程序如何和文件、磁盘、网络连接、远程服务打交道。

2.5 JVM 运行时

这条线解决的是:Java 代码到底是怎么被加载、执行、分配内存、回收对象的。


3. Java 为什么会被认为“适合大规模工程系统”

可以从这些角度理解:

  1. 跨平台能力
  2. 语言规范稳定
  3. 标准库完整
  4. JVM 屏蔽底层系统差异
  5. 工具链和生态成熟

这里的 跨平台,不要简单理解成“源码到处都能直接跑”。

直接说:

  1. Java 源码先编译成字节码
  2. 字节码交给不同平台上的 JVM 去执行
  3. JVM 屏蔽底层系统差异

所以 Java 的跨平台能力,核心依赖的是:字节码 + JVM


4. 学 Java 最容易混的几个边界

4.1 Java、JDK、JRE、JVM 不是一回事

这四个词经常被混在一起,但它们分别处在不同层次。

可以这样记:

  1. Java:语言和生态
  2. JVM:执行字节码的运行时虚拟机
  3. JRE:运行 Java 程序需要的环境
  4. JDK:开发 Java 程序需要的完整工具链

如果只记一句更直白的话,可以看成:

JVM 负责“执行”,JRE 负责“运行”,JDK 负责“开发”。

4.1.1 它们之间的包含关系是什么

可以按传统理解记成:JDK = JRE + 开发工具

JRE 里通常又包含:

  1. JVM
  2. 运行 Java 程序所需的标准类库
  3. 一些基础运行时组件

所以如果继续往下拆,可以看成:

  1. JVM:只负责把字节码真正跑起来
  2. JRE:让 Java 程序“能运行”的整套环境
  3. JDK:让你“能开发、能编译、能打包、能诊断”的完整工具集合

看一张压缩关系表:

名称更准确的定位主要包含什么主要不负责什么
JVMJava 虚拟机类加载、字节码执行、内存管理、垃圾回收不直接负责源码编译、打包、文档生成
JREJava 运行环境JVM + 标准类库 + 运行所需组件不以“完整开发工具链”为目标
JDKJava 开发工具包JRE 能力 + 编译、打包、调试、诊断等工具不等于业务框架,也不等于整个 Java 生态

🌟 所以真正容易混的点是:

JVM 只是运行时核心之一,不等于整个运行环境;JRE 是运行环境;JDK 则是在运行环境之上再加开发工具。

4.1.2 各自常见会带哪些工具或能力

如果你从“平时会接触哪些命令”这个角度理解,会更直观。

JVM 更偏运行时能力

JVM 更偏向下面这些能力:

  1. 加载类
  2. 执行字节码
  3. 管理堆、栈、方法区等运行时内存
  4. 做垃圾回收
  5. 支持 JIT、解释执行、运行时优化

也就是说,JVM 更像一个:负责让字节码真正运行起来的执行引擎。

JRE 更偏运行能力

JRE 更偏向下面这些内容:

  1. JVM
  2. Java 标准类库
  3. 运行 Java 程序所需的基础支持文件

所以如果你只是“想运行一个已经编译好的 Java 程序”,理论上你更需要的是:JRE

而不是完整开发套件。

JDK 更偏开发与诊断能力

JDK 则在运行能力基础上,继续补上开发和排查常用工具。

常见工具包括:

  1. javac:把 .java 编译成 .class
  2. java:启动 Java 程序
  3. jar:打包和查看 JAR 文件
  4. javadoc:生成文档
  5. javap:查看字节码结构
  6. jps:查看 Java 进程
  7. jstat:查看 GC 和内存统计
  8. jmap:导出堆信息、看对象分布
  9. jstack:导出线程栈
  10. jcmd:统一的 JVM 诊断命令入口
  11. jshell:交互式运行 Java 代码

所以工程上更常见的感受其实是:JDK 不只是拿来写代码的,它还负责编译、打包、排查和诊断。

4.1.3 它们的能力边界到底怎么理解

这几个词最容易讲混的原因,是大家经常把“能运行”和“能开发”混成一件事。

可以这样区分:

  1. JVM 的边界是:负责执行,不负责开发工具链
  2. JRE 的边界是:负责运行,不强调完整开发能力
  3. JDK 的边界是:负责开发和诊断,但也建立在运行能力之上

更直白一点说:

  1. 你要把源码编译成字节码,得靠 JDK
  2. 你要把字节码真正运行起来,底层靠的是 JVM
  3. 你要让“运行 Java 程序所需的环境”完整具备,这说的是 JRE

4.1.4 为什么现在经常不再单独强调 JRE

如果你看一些较新的 Java 安装包或文档,会发现:

JRE 这个词不像早些年那样被频繁单独强调了。

一个很重要的背景是:

  1. 现代 Java 发布方式在变化
  2. Java 9 之后模块化增强
  3. 很多场景直接安装完整 JDK
  4. 运行时也可以按需裁剪

所以在今天的工程实践里,更常见的情况往往是:

  1. 开发机直接装 JDK
  2. 服务器或容器里使用完整 JDK,或者使用裁剪后的运行时镜像

这并不意味着 JRE 这个概念错了,而是说明:它作为“运行环境”这个概念仍然成立,但在现代分发方式里,不一定总是以一个独立安装包的形式被强调。

4.2 面向对象不是“会写 class”就够了

真正要理解的是:

  1. 封装为什么重要
  2. 继承的边界是什么
  3. 多态为什么能提升扩展性
  4. 面向接口编程到底在解什么耦

4.3 并发不是“会开线程”就够了

真正困难的是:

  1. 线程安全吗
  2. 数据可见吗
  3. 会不会死锁
  4. 锁竞争会不会拖垮吞吐

4.4 JVM 不是“内存分区背下来”就结束了

真正关键的是:

  1. 对象主要分配在哪
  2. 哪些区域是线程私有,哪些是线程共享
  3. 垃圾回收为什么要分代
  4. 程序卡顿、内存高、Full GC 频繁时应该往哪看

5. 当前目录下有哪些专题

推荐阅读顺序:

  1. 看“数据类型与类型转换”,打稳最基础的类型认知
  2. 再看“面向对象、泛型与异常”,建立语言层抽象能力
  3. 再看“集合详解”,理解最常见的数据结构选择
  4. 再看“Java 中的流:IO 流与 Stream API”,把两种最容易讲混的“流”先分开
  5. 再看“并发编程、JUC 与线程安全”,理解多线程主线
  6. 再看“IO、NIO 与网络编程”,把程序和外部世界的交互串起来
  7. 最后看“内存划分”和“JVM 执行、类加载、反射与垃圾回收”,进入运行时主线

6. Java 在项目里最常被追问什么

除了会不会写接口和业务逻辑,继续深问时,通常会落到这些问题:

  1. 为什么这里要用 ArrayList 而不是 LinkedList
  2. HashMap 为什么线程不安全
  3. synchronizedReentrantLock 有什么区别
  4. JUC 里常见的锁、同步器、原子类和线程池分别适合什么场景
  5. volatile 解决了什么,没有解决什么
  6. 为什么会出现 OOM 或 Full GC 频繁
  7. 类是怎么加载进 JVM 的
  8. 反射为什么总和 Spring、注解、动态代理放在一起讲
  9. 为什么 Java 里 BIO、NIO、AIO 会分开讨论

这些问题共同说明:Java 真正常用的知识,不只发生在语法层,而是发生在数据结构、并发模型和运行时行为里。


7. 常见误区

7.1 误区一:Java 学到集合就差不多了

集合当然重要,但如果没有并发、IO 和 JVM 这几条线,Java 知识结构会明显缺口。

7.2 误区二:会用框架就等于理解 Java

框架能帮你快速开发,但很多生产问题最终还是会落回 Java 基础、并发和 JVM。

7.3 误区三:JVM 调优就是背参数

真正关键的是先理解:

  1. 程序为什么占内存
  2. 对象为什么回收不掉
  3. GC 为什么频繁
  4. 哪类对象和哪种业务模式导致了这些现象

8. 一句话总结

Java 最值得先建立的认知不是“语法会不会写”,而是:

它如何通过语言、标准库、并发模型和 JVM 运行时一起支撑起大规模工程系统。

基于 VitePress 构建的个人技术笔记。