Java学习路线PDF：从零基础到后端的全景学习地图

简介：面向Java初学者与进阶开发者的系统学习路线PDF，用一张知识地图回应“先学什么、后学什么、哪些必须补”的规划难题，覆盖从语言基础到后端架构的技能层级。内容按模块展开：Java语法、面向对象、集合、异常、泛型、反射与注解，JVM类加载、内存模型、GC与调优，并发编程与JUC工具，数据结构与算法，计算机网络、数据库与SQL优化；再延伸至Spring全家桶、缓存、消息队列、微服务治理、前端基础、Linux、设计模式、容器化与Kubernetes，并含任务调度、链路追踪、ELK日志等工程化主题，便于对照自查和阶段复盘。压缩包内含1个PDF文件，约92KB，轻量易存，可在电脑或手机上随时翻阅并标记进度。已有492人学习，说明其路线框架具备一定参考度。读者可借目录梳理知识盲区，把零散概念串成可执行的进阶顺序，减少无效摸索。

1. 先搞懂一件事：Java 学习路线 PDF 到底是一张什么图

刚接触 Java 的人，最常卡住的地方往往不是“难不难”，而是“我该从哪儿开始”。打开任何一个教程站，左边目录一长串：基础语法、集合、多线程、JVM、Spring、Redis、微服务……每一章看上去都得学，可先学哪个、学到什么程度算过关，没人说清。这份 Java 学习路线 PDF 干的就是这件事——它把 Java 后端从零到能上手干活的全部知识点，按先易后难、先会用再懂原理的顺序编成一张完整的图，让你一眼看到起点、中途和终点在哪。它适合三类人：完全没写过代码的零基础新手、学过一点语法但不知道下一步学什么的学生、以及从别的方向转过来需要一份全局地图的人。它不负责把你教会，它负责让你少走弯路。

2. 先看全景再动手：这张图把 Java 拆成了哪三层

很多人拿到一份路线图，第一反应是从最上面开始一条一条往下背。这是个挺典型的翻车姿势。这份路线真正的用法是倒过来：先用十几分钟看清它分了哪几层，搞明白每层之间是什么关系，再决定自己现在该站在哪一层。这就跟拿到一张城市地图一样，你要先找到自己在哪、目的地在哪，才谈得上选路线，而不是一上来就记住每条街的名字。

2.1 三层结构：语言层、原理层、工程层

这份路线图里的知识点看着密密麻麻，其实可以归成三层。第一层是语言层，也就是 Java 这门语言本身怎么用；第二层是原理层，解释程序为什么快为什么慢、数据存在哪里、网络怎么把请求送到你面前；第三层是工程层，解决的是“一个人写的小 Demo，怎么变成一群人维护、能上线运行的系统”。

这三层不是并列关系，是有依赖的。语言层没打牢，直接看 Spring 的自动配置，你只会觉得那是一堆魔法；原理层完全跳过，工作两三年之后就会在性能问题上反复吃亏，因为那是排查问题的底层工具；工程层则决定你能不能把学到的东西变成一份能拿出手的项目。路线图把它们画在一起，就是为了让你知道哪一段可以慢一点，哪一段不能跳。

2.2 为什么零基础更需要先看全景

有基础的人看路线图，是在查漏补缺；零基础的人看路线图，是在防止迷路。这两种用法完全不一样。

新手最容易陷入的状态是“局部正确、全局混乱”。比如花两周把集合框架的十几个类背得滚瓜烂熟，却不知道集合在实际项目里到底解决什么问题；或者跟着视频敲完了 Spring Boot 的增删改查，却说不出“Bean”到底是个什么东西。这些都不是因为不努力，而是因为脑子里没有那张全景图，每学一个点都是孤立地挂在那，风一吹就掉。

先看全景还有一个很实际的好处：能帮你判断什么现在不用学。路线图里那些 Nacos、Seata、Skywalking、Kubernetes，对一个还在写第一个 Hello World 的人来说，属于“知道有这么个东西，但现在碰它纯属浪费生命”。全景图的作用之一，就是把这些“以后再说”的东西明确标出来，让你不至于一开始就被吓退。

再说得直白一点，学 Java 的过程里，最贵的成本不是智商，是时间分配。同样三个月，有人学完能写个小系统，有人还在纠结 JDK 装哪个版本。差别往往不在勤奋程度，而在一开始有没有人告诉他“这个阶段该学什么、不该学什么”。

2.3 这份 PDF 的三遍读法：扫、标、拆

拿到这份路线图，别急着从头背。我建议分三遍读，每一遍目的都不一样。

第一遍是扫，控制在五分钟以内。从头到尾快速滑一遍，只看那些大块的标题——编程基础、JVM、并发、数据结构与算法、计算机网络、数据库、Spring 家族、中间件、微服务、前端。这一遍不要求记住任何细节，只要在脑子里建立一个印象：哦，原来总共就这么几大块。很多人第一次看到路线图会觉得“天呐这么多”，扫完这一遍反而会松一口气，因为大块其实没几个。

第二遍是标，用三种标记把每个知识点分成三类。绿色是“我已经会了或者能讲清楚”，黄色是“听说过、能看懂一点但写不出来”，红色是“完全没概念”。标完之后你会发现，真正让你焦虑的红色区域，其实比你想象的窄很多。这一遍建议隔一段时间做一次，比如每学完一个月重标一遍，你会很直观地看到红色在变少——这种看得见的进度，对熬过中间那段枯燥期特别有用。

第三遍是拆，只针对黄色区域动手。把离你最近的那一块拆成能在两周内完成的小任务，写在一张纸上贴在屏幕边上。比如“容器”这一块，可以拆成：会用 ArrayList 和 HashMap 完成增删改查、能说清 ArrayList 和 LinkedList 的区别、能手写一个简单的哈希冲突处理。拆到这种颗粒度，你每天打开电脑就知道该干什么，不用再花半小时纠结从哪开始。

提示：第二遍标记时不要追求准确。你对某个知识点的判断本来就会随着学习不断变化，标错了也没关系，重点是让那张图从“别人的目录”变成“你自己的进度表”。

3. 第一步怎么迈：从装环境到让第一个 Java 程序跑起来

全景看清了，接下来是最容易劝退人的一步：动手。这一章的目标很单纯，就是让你在半小时内看到屏幕上真的打印出一行字，顺便搞明白刚才那几步到底发生了什么。别小看这个“跑通”的动作，它是后面所有学习的地基——所有复杂的框架、中间件、微服务，本质上都是在一个能跑起来的 Java 程序上加东西。

3.1 语言基础这一层，具体要学哪些

先把这一层的内容摆出来，你心里有个数。路线图里列的是：基础语法、面向对象、接口、容器、异常、泛型、反射、注解、I/O。这九块看着多，其实有明确的先后顺序。

基础语法是最底下的那层，包括变量、数据类型、运算符、条件语句、循环语句、方法。这部分不需要“理解”，需要的是“熟练”——看到一个需求，能立刻反应出该用 for 还是 while，该用 int 还是 long。

面向对象是第二个台阶，包括类、对象、封装、继承、多态。这四个词几乎所有教程都会讲，但新手最容易犯的错是背定义。判断自己有没有真的懂，有个很土但有效的标准：能不能用“类”这个概念，把身边一个具体的东西（比如一台自动售货机）描述出来，包括它有哪些属性、能做哪些动作。

接口、容器、异常、泛型、反射、注解、I/O 这六块，可以理解成“在面向对象之上长出来的工具”。它们之间没有严格的先后，但按“接口 → 容器 → 异常 → 泛型 → 反射与注解 → I/O”这个顺序走会比较顺，因为每一块都会用到前面一块的东西。比如容器里到处是泛型，反射又经常和注解一起出现。

3.2 第一个例子：三步跑通 Hello

动手之前先确认环境。你需要的是 JDK，不是 JRE。这两个名字只差一个字母，但 JRE 只能运行程序，JDK 才能编译程序，新手装错版本是极常见的事。

打开命令行，敲下面两条命令：

# 检查 JDK 是否可用，两条命令都能打印出版本号才算装好 java -version javac -version

java是启动器，负责把编译好的程序跑起来；javac是编译器，负责把 Java 源码翻译成 JVM 能读的字节码。两条都出版本号，说明环境和 PATH 都配对了。如果java有输出而javac提示“不是内部或外部命令”，基本可以确定装的是 JRE，或者 PATH 没配到 JDK 的 bin 目录。

环境确认完，新建一个文件，名字必须叫Hello.java，内容和文件名的大小写要完全一致：

// 文件名必须叫 Hello.java，和 public class 的名字完全一致（含大小写） public class Hello { // 程序入口：固定写法，JVM 靠这个方法名找到起点 public static void main(String[] args) { System.out.println("Hello, Java"); } }

这里的public表示这个类对外可见，class是定义类的关键字，Hello是类名。main方法的四个部分各有作用：public让 JVM 能调用它，static让它不需要创建对象就能执行，void表示不返回结果，String[] args是启动时传进来的参数。System.out.println就是往控制台输出一行文字并换行。

然后在同一个目录下执行两条命令：

# 编译：把源码翻译成字节码，成功后目录里会多出一个 Hello.class javac Hello.java # 运行：启动 JVM 并加载 Hello.class，注意这里不加 .class 后缀 java Hello

javac Hello.java里的参数是带后缀的源文件名；java Hello里的参数是类名，不带后缀，也不是文件路径。这两个写反了是新手最常见的报错来源之一——java Hello.class会直接告诉你找不到这个类。

注意：如果你的代码里出现了中文，编译时可能遇到编码报错。可以在编译时显式指定编码，例如javac -encoding UTF-8 Hello.java，让编译器和源文件用同一套字符集。

3.3 第二个例子：把类、对象和容器串起来

Hello World 只证明了环境没问题，还说明不了语言基础。第二步写一个稍微像样的例子，把类、字段、构造方法、方法、List、泛型、增强 for 循环全串一遍。这五六个概念在路线图里是分散在好几块里的，但它们其实可以出现在同一个二十行的程序里。

import java.util.ArrayList; import java.util.List; public class StudentDemo { // 静态内部类：把"学生"这个概念的属性和行为放在一起 static class Student { String name; // 姓名 int score; // 分数 // 构造方法：创建对象时给字段赋值 Student(String name, int score) { this.name = name; this.score = score; } // 判断是否及格，返回布尔值 boolean passed() { return score >= 60; } } public static void main(String[] args) { // 泛型写在尖括号里，表示这个 List 只能装 Student 类型的对象 List<Student> list = new ArrayList<>(); list.add(new Student("A同学", 58)); list.add(new Student("B同学", 92)); list.add(new Student("C同学", 76)); int passCount = 0; // 增强 for 循环：把 list 里每个元素依次取出来赋给 s for (Student s : list) { if (s.passed()) { passCount++; } } System.out.println("总人数：" + list.size()); System.out.println("及格人数：" + passCount); } }

这段代码里，Student是一个类，new Student(...)创建出来的是对象，this.name = name是构造方法在给字段赋值，passed()是对象自己的行为。List<Student>是容器加泛型，ArrayList是 List 的一种具体实现。for (Student s : list)是增强 for 循环，比传统的下标循环少写不少代码，但代价是拿不到当前元素的下标。

把这段代码存成StudentDemo.java，照样用javac StudentDemo.java编译、java StudentDemo运行，屏幕上应该出现总人数 3、及格人数 2。如果这两个数字对上了，恭喜，语言层最难迈的那道坎已经过去了——你已经完成了“定义类、创建对象、装进容器、遍历判断、输出结果”这一整条链路。

3.4 基础阶段的顺序建议和一个“及格线”

接下来的路怎么排，我给一个自己用过、也见过不少人用过的顺序：基础语法两周，面向对象两周，接口和容器三周，异常和泛型一周，反射注解和 I/O 各一周。这个节奏不算快，但对零基础来说足够稳。

至于学到什么程度可以往下走，我建议用一个很具体的及格线来衡量：能不能在不看教程的情况下，写一个读文本文件、统计词频、按次数排序输出的控制台程序。这个小任务把 I/O、容器、泛型、异常、排序全用上了，能独立写出来，说明语言层已经够用了，可以放心进入下一阶段。写不出来也不用慌，回去把卡住的那一块补一下，比硬着头皮往下翻要划算得多。

4. 中场怎么排：JVM、并发、算法、数据库和 Spring 的先后顺序

语言层过了之后，会进入整个学习过程中最熬人的一段。路线图上这一段的密度最高：JVM、并发编程、数据结构与算法、计算机网络、数据库与 SQL、操作系统、设计模式，再往后还有 Spring 家族、中间件、微服务。新手在这一段最常见的状态是“每个都想学，每个都学不深”，最后哪块都没立住。这一章的重点不是把每块讲透，而是告诉你它们之间该怎么排、什么时候该碰、什么时候可以先放着。

4.1 JVM 与并发：先会用，再深挖

先说 JVM。路线图里把它拆成了六块：类加载机制、字节码执行机制、内存模型、GC 垃圾回收、性能监控与故障定位、调优。这六块的难度是递增的，但很多人一上来就从内存模型和 GC 算法啃起，结果被“分代收集”“可达性分析”这些词绕晕，直接放弃。

更合理的顺序是反过来的：先知道类是怎么被加载进来的，字节码是什么样子，再理解内存被划成了哪几块区域，然后才去碰 GC，最后才是监控和调优。前面几块是理解后面几块的前提，跳着学一定会卡。

而且 JVM 有个特点，它更像一个黑匣子，你不写代码、不遇到问题，光看理论是很难有体感的。所以我建议的做法是：先把概念过一遍，知道有这回事，然后等到你能写出一段会内存溢出的代码、能亲手用工具看到堆内存的曲线变化，再回头精读。这个顺序比一上来死磕原理要高效得多。

并发编程也是同理。路线图里列的是并发编程基础、线程池、锁、并发容器、原子类、JUC 工具类。这里最该先拿下的是线程池——不是为了面试，而是因为它是实际项目里出现频率最高的并发工具。会用ThreadPoolExecutor创建线程池、知道核心线程数和最大线程数分别管什么、知道队列满了会走拒绝策略，这三件事搞明白，比背下synchronized的锁升级过程有用得多。

锁和并发容器可以放在线程池之后。synchronized和volatile先会用，能说清什么场景下必须加锁；ConcurrentHashMap和CopyOnWriteArrayList先知道什么时候该用它们替代普通容器。原子类和 JUC 工具类是最后一步，CountDownLatch、Semaphore、CyclicBarrier这些东西，等你在实际场景里真的需要“等几个任务都完成”或者“限制同时访问的线程数”时再学，印象会深得多。

4.2 算法与数据库：先拿最小够用集

数据结构与算法这一块，路线图列得挺全：字符串、数组、链表、二叉树、堆栈队列、哈希、查找排序，再加上贪心、分治、动态规划、回溯。看到这一长串，很多非科班的新手会直接心态崩掉。

我的建议是分两档。第一档是必须熟的：数组、链表、栈、队列、哈希表、二叉树的基本操作，以及二分查找和几种常见排序。这些不是为了刷题，而是因为你在写业务代码时会不断用到它们的思路——比如什么时候该用 Map 做缓存、为什么链表插入快查询慢、为什么数据库索引用 B+ 树。第二档是了解即可：贪心、分治、动态规划、回溯。这四个属于“知道它解决哪类问题”就够了，除非你要面算法岗，否则不必在这一阶段投入大量时间。

数据库与 SQL 是另一块必须优先拿下的。路线图里列的是 SQL 语句书写、SQL 优化、事务与隔离级别、索引、锁。顺序很清楚：先会写，再会优。写这一层包括 CRUD、联接查询、子查询、分组聚合；优这一层才是索引、执行计划、事务隔离级别。新手最容易犯的错是反过来，SQL 还写不利索就去研究索引原理，结果两头都虚。

计算机网络和操作系统，我建议放在这一段的“并行阅读”位置，不要专门停下来啃。TCP 的三次握手、HTTP 和 HTTPS 的区别、进程和线程的差别、内存管理的基本概念，这些属于“看一遍有个印象，遇到问题再回来查”的内容。设计模式也一样，单例、工厂、代理、策略、模板方法、观察者这几个先认识，剩下的责任链、建造者、适配器，等你在框架源码里真的见到了再补。

4.3 一个可跟做的练习：用集合和 SQL 各做一次统计

概念说再多，不如动手做一次。这个练习分两半，一半用 Java 的集合，一半用 SQL，做的是同一件事——统计。做对比的时候你会发现，这两套工具解决的是同一类问题，只是数据放在不同的地方。

先看 Java 这一半：

import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; public class ScoreStat { public static void main(String[] args) { // Arrays.asList 快速造一个不可变长度的列表，方便练习 List<Integer> scores = Arrays.asList(88, 59, 92, 73, 59, 100, 45, 73); // HashMap 统计每个分数出现的次数：key 是分数，value 是次数 Map<Integer, Integer> counter = new HashMap<>(); for (Integer s : scores) { // getOrDefault：取不到就返回默认值 0，省掉一次判空 counter.put(s, counter.getOrDefault(s, 0) + 1); } // 遍历 entrySet，找出出现次数最多的那个分数 int maxScore = -1; int maxCount = 0; for (Map.Entry<Integer, Integer> e : counter.entrySet()) { if (e.getValue() > maxCount) { maxCount = e.getValue(); maxScore = e.getKey(); } } System.out.println("出现最多的分数：" + maxScore + "，次数：" + maxCount); } }

这段代码的关键在两处。getOrDefault(s, 0)是 HashMap 的一个便捷方法，当 key 不存在时返回你给的默认值，避免写一堆if (counter.containsKey(s))。entrySet()返回的是键值对的集合，遍历它比先拿 keySet 再逐个 get 效率更高，因为省掉了重复查找。运行结果会告诉你 59 和 73 都出现了两次，取到哪一个取决于遍历顺序，这一点先不用纠结。

再看 SQL 那一半：

-- 建一张最小可用的成绩表，只保留分析真正需要的字段 CREATE TABLE score ( id BIGINT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(32) NOT NULL, subject VARCHAR(32) NOT NULL, score INT NOT NULL ); -- 按科目统计人数和平均分，过滤掉样本太少的科目，再按平均分从高到低排 SELECT subject, COUNT(*) AS cnt, AVG(score) AS avg_score FROM score GROUP BY subject HAVING COUNT(*) >= 3 ORDER BY avg_score DESC;

GROUP BY把数据按科目分成几堆，COUNT(*)和AVG(score)是在每一堆内部做计算。HAVING和WHERE的区别是新手最容易混的一点：WHERE在分组之前过滤原始行，HAVING在分组之后过滤分组结果，所以聚合函数只能写在HAVING里。ORDER BY放在最后，对最终结果排序。这条语句可以在本机装个 MySQL 跑一遍，插十几条假数据进去，看结果对不对。

同一个统计需求，用集合写是“把数据装进内存再算”，用 SQL 写是“让数据库帮你算”。前者适合处理程序运行时产生的数据，后者适合处理已经存在库里的数据。两套都跑一遍，你对“容器”和“数据库”的分工就会有具体的感受，而不是停留在概念上。

4.4 Spring 家族和微服务：什么时候才该碰

路线图的后半段密度更高：Spring 的 IoC、AOP、Spring MVC、Spring Boot，接着是整合 Web、整合数据库、整合权限、整合各种中间件，再往后是 Spring Cloud 的一整串组件。

我的建议很明确：Spring 要学，但要按 IoC → AOP → Spring MVC → Spring Boot 的顺序，而且必须在前面的语言基础和数据库基础都过关之后再开始。原因很简单，Spring 的核心是“帮你管理对象的创建和依赖关系”，如果你连对象、接口、依赖这些概念都还没立住，看 Spring 只会觉得它在变魔术。

Spring Boot 是这一段的重点。路线图里它下面挂了一串“整合”：整合 Web、整合数据库（还要处理事务问题）、整合权限（Shiro 和 Spring Security）、整合各种中间件。这些才是实际干活时天天用的东西，比自己从零搭一个 Spring MVC 项目要实用得多。

至于微服务，我劝你把它放到最后。Eureka、Nacos、Zuul、Gateway、Ribbon、Feign、Hystrix、Config、Apollo、Seata、Skywalking，这一串名字看起来很有分量，但它们解决的是“系统大到一定程度之后的问题”。一个还写不出完整单体应用的人去学微服务，就像还没学会走路就去研究怎么跑马拉松的配速策略。中间件也一样，Redis、消息队列、Dubbo 这些，先知道它们是干什么的，等你手上有一个真正需要缓存、需要异步、需要远程调用的场景，再学不迟。

5. 新手最容易踩的五个坑：现象、原因和排查办法

这一章写的都是从零开始学 Java 的人反复踩到的坑。每个坑我按“现象、原因、解决办法”三段说，你遇到的时候可以直接对号入座，不用再从第一行翻起。

5.1 环境明明装了，命令行还是说找不到 java

现象：安装包双击装完，教程里让打开命令行敲java -version，结果弹出一行“不是内部或外部命令”，或者提示找不到这个程序。

原因：Windows 装完 JDK 之后，命令行并不会自动知道它在哪。系统需要靠一个叫 PATH 的环境变量去各个目录里找可执行文件，如果 JDK 的 bin 目录没被加进 PATH，命令行就找不到。还有一种情况是装了 JRE 而不是 JDK，java有反应但javac没有，编译不了代码。

解决办法：先确认装的是 JDK 而不是 JRE，再找到 JDK 的安装目录，把里面的 bin 目录路径加进系统环境变量 PATH。改完之后一定要重开一个新的命令行窗口，原来开着的窗口不会自动读取新配置。如果还是不行，在命令行里敲where java看看系统实际找到的是哪个路径，有时候是之前装过别的版本，旧的路径排在前面。

5.2 视频看得懂，自己写就一片空白

现象：跟着教程敲代码一路顺畅，关掉视频自己动手，连第一行该写什么都要想半天。

原因：看懂和写出来是两种完全不同的能力。视频里代码是现成的，你的大脑在做的是“识别”而不是“构造”，这两件事消耗的认知资源差着量级。这就解释了为什么很多人学了三个月，遇到空白编辑器还是发怵。

解决办法：把“跟着敲”改成“看完关掉，凭记忆写一遍，写不出来再看”。写不出来的地方，正是你没真正掌握的地方，比看十遍视频都有价值。另一个办法是每学完一个小节，给自己出一道稍微变形的小题，比如学完 for 循环，就写一个打印九九乘法表的程序。能独立写出来，才算真的过了。

5.3 教程里的版本和你装的对不上，代码直接报错

现象：照着教程抄的代码，编译时报一堆红字，错误信息看不懂，去搜也搜不到一样的。

原因：Java 的版本更新会带来语法和 API 的变化，有些教程录得比较早，用的写法在新版本里已经不推荐了。另一种常见情况是包名、类名、文件名不一致，比如public class的名字和文件名不同，或者 import 的包路径写错了。

解决办法：先看报错信息的第一行，它通常会指出是哪个文件第几行出的问题。如果是版本相关，去查这门语言官方文档里对应版本的说明，而不是继续在论坛里翻旧帖。如果是类名文件名不一致，养成习惯：每建一个类，先把文件名和类名对齐，再开始写内容。排查的时候从第一个报错看起，因为后面的报错往往是第一个引起的连锁反应。

5.4 一上来就啃 JVM 和源码，两周后放弃

现象：刚开始学没多久，就去找 JVM 调优的视频和框架源码解析，看的时候云里雾里，看完什么也没记住，慢慢就没了动力。

原因：原理和源码属于“有了具体问题之后才有意义”的知识。你没有写过会内存溢出的代码，就看不懂 GC 参数为什么要那么调；你没用过 Spring 写过业务，看源码也看不出它在解决什么问题。跳过应用直接看原理，等于在没有地图的情况下研究城市地下管网的走向。

解决办法：老老实实按路线图的顺序走。先把语言层写熟，再用框架做出一个能跑的小项目，然后带着“为什么这里要这么配”的疑问回头补原理。这个时候再去看 JVM，你会发现很多原本抽象的概念突然有了对应物。学习顺序错了，再努力也是事倍功半。

5.5 资料存了一堆，一个都没打开

现象：网盘里躺着几十 G 的视频、PDF、源码，收藏夹里存了几百个链接，但真正完整学完的没几个。

原因：收集资料这个动作本身会带来一种“我在进步”的错觉，它能缓解焦虑，却不产生任何实际进展。资料越多，选择成本越高，最后反而什么都开始不了。

解决办法：只留一份主线资料，其余全部先放到一边。这份 Java 学习路线 PDF 本身就是很好的主线，因为它已经把顺序排好了，你不需要再纠结“下一本该看哪本”。给自己定一条规矩：在一个阶段结束之前，不打开任何新的学习资料。这条规矩看起来简单，执行起来能省下大量内耗。

6. 下一步学什么：把路线图拆成一份能执行的 12 周计划

路线图看完，最怕的就是“觉得很有道理，然后没有然后了”。所以最后这一章不讲新知识，只讲怎么把这张图变成你每天能执行的计划。下面这份 12 周的表是我自己用过、也给不少人推荐过的节奏，你可以按自己的时间调整，但最好不要把周期拉得太长——拖过半年，前两周学的东西基本就忘干净了。

这张表有两个设计原则，值得说一下。第一是每一周都有产出物，而不是“学完某章”。产出物可以很小，小到一个只有几十行的控制台程序也行，但它必须是你能拿出来给别人看的东西。第二是原理部分只占两周，而且放在应用之后。第 9 周讲线程池，是因为前面已经写过不少代码，能感受到“单线程处理太慢”的痛；第 10 周看 JVM，是因为你已经开始关心程序为什么占内存了。带着问题去学原理，效率比漫无目的地读要高得多。

还有一件事我想单独说。学会用工具，比多背几个知识点更值钱。路线图里的研发工具那一栏列了 Git、Maven、IDEA、Linux 常用命令，这些东西看起来不起眼，但在实际工作里天天用。我的建议是在第 3 周左右就把 Git 用起来，哪怕只是自己在本机提交、回滚、看历史，也比等到做项目时才现学要好。Maven 也是一样，等你开始引入第三方依赖，就会明白为什么不能靠手动下载 jar 包。

最后说说我自己的教训。我刚开始学的时候，特别喜欢在周末一口气学八个小时，周中完全不碰。结果就是每个周末都在重新捡起上周忘掉的东西，进度慢得让人绝望。后来改成每天固定一小时，反而在三个月里把基础那块走完了。从那以后我每次排学习计划，都强制走一遍“把大块拆成每天能完成的小块”这个动作，哪怕拆出来的任务看起来很琐碎。学习这件事，稳定比强度重要得多，能每天坐下来写二十行代码的人，最后一定比一周写五百行然后停两周的人走得远。希望帮到你。

本文还有配套的精品资源，点击获取