Java学习路线：先掌握哪些知识，再开始写项目

学 Java 容易走两个极端：一边是只看语法、迟迟不动手；另一边是刚会写几个类，就照着教程搭 Spring Boot，遇到报错便复制粘贴。更有效的路线，是先掌握能解释代码行为的基础，再通过小项目逐步接触数据库、测试和框架。

这篇文章面向初学者，按“先学什么、达到什么程度、何时开始写项目”展开。示例以 Java 17 为基准；多数基础语法也适用于较新的 Java 版本。示例代码可保存为同名的 .java 文件后运行。不同版本的 JDK、构建工具和框架有各自的兼容要求，开始项目时应查看对应项目的官方文档。

一、先确定学习目标与开发环境

Java 常见于服务端应用、企业系统、桌面程序、Android 开发及各类工具。不同方向后续所需技能不同：服务端通常要学 HTTP、数据库、并发和 Spring；Android 应以 Android 平台文档和 Kotlin/Java 的平台实践为主；桌面或工具开发则会更多接触文件、界面或操作系统接口。因此，基础阶段不必先把所有 Java 技术都学完，先建立共同的语言基础，再按目标分支。

安装 JDK 后，在终端运行 java -version 和 javac -version，确认运行时和编译器可用。选择一个支持所用 JDK 的 IDE，例如 IntelliJ IDEA 或 VS Code，并练习从终端编译、运行一个类。IDE 能减少重复操作，但不能代替对编译错误、运行时异常和程序输出的理解。

建议从命令行程序开始，不急着配置复杂框架。先熟悉源文件、类名、入口方法和包的关系，再使用 Maven 或 Gradle 管理依赖。团队项目以项目自身的 JDK 版本和构建配置为准，不要仅因为本机装了较新的 JDK，就擅自升级项目运行版本。

二、第一阶段：语法、表达式与控制流程

先掌握变量、基本类型、字符串、运算符、条件判断、循环、数组和方法。重点不是背语法，而是能读懂数据如何变化，并知道每段代码的输入、输出与边界。

• 了解 int、long、double、boolean、char 等基本类型，以及引用类型的基本概念。
• 理解局部变量必须先赋值再使用；实例字段会有默认值，但不应依赖隐含默认值表达业务含义。
• 会使用 if、switch、for、while，并能识别循环终止条件。
• 会拆分方法，使用参数和返回值表达职责；理解方法重载与作用域。
• 掌握数组下标从 0 开始，访问超出范围会导致运行时异常。

下面是一个完整的命令行示例。它读取一组整数，计算平均值，并显式处理空数组。保存为 AverageDemo.java，执行 javac AverageDemo.java 和 java AverageDemo 即可运行。

public class AverageDemo {
    public static double average(int[] values) {
        if (values == null) {
            throw new IllegalArgumentException("values 不能为 null");
        }
        if (values.length == 0) {
            throw new IllegalArgumentException("至少需要一个数值");
        }

        long sum = 0;
        for (int value : values) {
            sum += value;
        }
        return (double) sum / values.length;
    }

    public static void main(String[] args) {
        int[] scores = {80, 92, 75};
        System.out.println(average(scores));
    }
}

这里用 long 累加，而不是直接用 int，是为了降低多个较大整数相加时发生溢出的风险；但 long 也有上限，不能据此认为任意规模的求和都安全。若业务数值可能超过整数范围，应先明确取值范围，再选用合适的数据类型或处理策略。

常见错误包括用 == 比较字符串内容、忽略整数除法截断，以及循环边界多一位或少一位。字符串内容通常用 equals 比较；整数相除会丢弃小数部分，例如 5 / 2 的结果是 2。遇到除法、空值和数组访问时，应主动想一遍边界情况。

三、第二阶段：面向对象与类的职责

写过几个方法后，开始学习类、对象、构造器、封装、继承和多态。面向对象不是“每个名词都建一个类”，而是把相关状态和行为组织起来，并明确对象允许外部怎样使用。

封装通常意味着将字段设为 private，通过方法维护不变量。例如，账户余额不能随意被外部改成负数。构造器负责建立合法对象；方法则负责在后续操作中维持约束。继承用于表达稳定的“是一种”关系，但不应为了复用几行代码就随意继承。组合往往更容易调整：一个对象持有另一个对象，并委托其完成工作。

public class BankAccount {
    private final String owner;
    private long balanceInCents;

    public BankAccount(String owner, long openingBalanceInCents) {
        if (owner == null || owner.isBlank()) {
            throw new IllegalArgumentException("账户名不能为空");
        }
        if (openingBalanceInCents < 0) {
            throw new IllegalArgumentException("初始余额不能为负数");
        }
        this.owner = owner;
        this.balanceInCents = openingBalanceInCents;
    }

    public String getOwner() {
        return owner;
    }

    public long getBalanceInCents() {
        return balanceInCents;
    }

    public void deposit(long amountInCents) {
        if (amountInCents <= 0) {
            throw new IllegalArgumentException("存款金额必须大于零");
        }
        balanceInCents = Math.addExact(balanceInCents, amountInCents);
    }
}

金额用整数“分”表示，避免使用二进制浮点数直接承担货币精度要求；这仍不是完整的财务方案，实际系统还要明确币种、舍入规则、并发更新和审计要求。Math.addExact 在整数加法溢出时抛出异常，不会悄悄回绕，但调用方仍需决定如何处理该异常。

学到这里，可以开始写小型领域模型，比如图书、订单或任务。不要急着给每个字段都生成访问器，也不要让一个类承担输入、存储、业务规则和输出格式化的全部工作。判断类是否合适，可以看它是否有清楚的职责，以及修改它时是否会牵连许多无关代码。

四、第三阶段：集合、泛型与异常处理

实际程序经常处理一组数据，因此应先掌握集合框架中的常用类型：

• List：有顺序的元素序列，适合按位置遍历；允许重复元素。
• Set：用于表达不重复元素；具体顺序和性能取决于实现类。
• Map：键值映射，适合按键查找；键的相等性由相关类型的 equals 与 hashCode 约定影响。

泛型让集合元素类型在编译期更明确，例如 List<String>。不要把所有数据塞进原始类型集合再到处强制转换。也要理解集合与数组不同：集合通常可以动态增删，但并不意味着任何集合都线程安全，或可以无限增大。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CollectionDemo {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Lin");
        names.add("Mei");
        names.add("Lin");

        Map<String, Integer> counts = new HashMap<>();
        for (String name : names) {
            counts.merge(name, 1, Integer::sum);
        }

        System.out.println(counts);
        System.out.println(counts.getOrDefault("Kai", 0));
    }
}

输出中 HashMap 的键顺序不应被当成固定顺序；如果业务要求按插入顺序遍历，应选择合适的集合实现，或显式排序。修改集合时也要注意迭代行为：不要一边用增强 for 遍历，一边随意删除元素，否则可能遇到 ConcurrentModificationException。需要删除时，使用迭代器的删除方法或其他明确的集合操作。

异常用于表达程序无法按预期继续的情况。能在当前层合理恢复或补充信息时再捕获；不要用空的 catch 把错误吞掉，也不要捕获过宽的异常后返回一个看似正常的默认值。调用方需要知道的业务失败，可以设计明确的返回结果或业务异常；参数非法通常应在边界处及时拒绝。

五、第四阶段：文件、日期、枚举与常用库

继续学习输入输出、资源管理、日期时间 API、枚举、正则表达式和基本调试。文件、网络流、数据库连接等资源应及时关闭，通常使用 try-with-resources。它会在代码块结束时关闭实现了 AutoCloseable 的资源，即使处理中发生异常也会执行关闭。

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class FileReadDemo {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("notes.txt");
        String text = Files.readString(path);
        System.out.println(text);
    }
}

该示例要求当前工作目录下存在可读取的 notes.txt，否则会抛出异常。真实程序不能假设文件必然存在，也不应把用户提供的路径直接当作可信路径。若程序只允许访问某个目录，需要将目标路径规范化并验证其仍位于允许目录内，同时考虑符号链接等文件系统行为；单纯做字符串前缀比较并不足以构成可靠的路径安全检查。

日期和时间优先熟悉 java.time，例如 LocalDate 表示日期，Instant 表示时间线上的一个瞬间。时间戳、时区和本地日期不是一回事。涉及跨地区业务时，要明确时区；不要用一个格式化后的字符串替代时间语义。

六、第五阶段：写可测试的代码

项目开发不只是“程序能运行”，还要能够验证行为。先学会把输入与核心逻辑分开：核心方法接收参数并返回结果，命令行、网页或数据库负责调用它。这样逻辑可以脱离外部环境单独测试。

之后再学习 JUnit 等测试框架，覆盖正常情况、边界情况和失败情况。以平均值方法为例，应测试普通输入、只有一个元素、空数组以及 null。测试不是保证程序绝对正确的证明，而是帮助发现回归问题的一种工具；测试本身也可能漏掉需求、写错断言或没有覆盖重要路径。

调试时先构造最小复现：记录输入、预期结果、实际结果和异常堆栈，再用断点或日志观察变量。不要把“重启后暂时好了”当成问题已经解决。日志不要输出密码、访问令牌、完整银行卡号等敏感信息；日志内容也应避免未经处理的用户输入造成伪造日志或泄露隐私。

七、何时开始第一个项目

不必等到学完所有 Java 内容才写项目。掌握变量、方法、类、集合和异常后，就可以做一个不依赖框架的小项目；掌握文件和测试后，再扩展它。判断是否适合开始，不是看是否能背出 API，而是能否把需求拆成输入、规则、数据和输出，并能定位基本错误。

第一个项目适合选择范围有限、能在本机验证的主题，例如：

• 命令行记账本：新增、查询、汇总记录，先用集合保存，再练习文件读写。
• 图书管理程序：添加、借出、归还和查询，练习对象建模与状态规则。
• 任务清单：创建、完成、删除任务，练习集合、枚举和测试。

为项目写一页需求说明，列出允许的操作、输入格式、错误情况和数据是否需要持久化。实现时先让一条最小流程跑通，再逐步添加功能。比如记账本第一步只需接收一笔记录并显示总额，不必同时做用户系统、图形界面、云部署和复杂报表。

可以按以下顺序推进：

1. 定义数据模型和业务规则，说明空值、重复值、范围和失败时的行为。
2. 实现核心逻辑，并用测试验证关键规则。
3. 接入命令行或简单界面，把输入解析与业务逻辑分开。
4. 需要重启后保留数据时，再加入文件或数据库存储。
5. 记录运行方法、配置要求和已知限制，确保别人能复现。

八、再进入数据库、网络与服务端框架

如果目标是 Java 服务端，项目进入多用户、跨机器访问或需要持久化时，应学习 SQL、关系型数据库、HTTP 和 JSON，再了解 JDBC 与 Web 框架。不要把数据库、网络和框架一次性混成一个黑盒：知道 HTTP 请求由什么组成、SQL 如何查询，排查问题时才有抓手。

数据库先学表、主键、约束、索引、事务和常见查询。SQL 语句不要通过字符串拼接用户输入来构造。以 JDBC 查询为例，应使用参数化语句：

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class UserLookup {
    public static String findNameById(Connection connection, long id)
            throws SQLException {
        String sql = "SELECT name FROM users WHERE id = ?";

        try (PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setLong(1, id);

            try (ResultSet result = statement.executeQuery()) {
                if (result.next()) {
                    return result.getString("name");
                }
                return null;
            }
        }
    }
}

这里的 Connection 由调用方提供，因此方法只关闭自己创建的 PreparedStatement 和 ResultSet，不关闭连接。实际项目通常通过连接池管理连接，并应明确事务边界。参数化查询可以让驱动将参数作为数据处理，降低这类 SQL 查询中由输入拼接导致的注入风险；它不能替代访问控制、权限最小化和其他安全措施，也不能把表名、列名等任意 SQL 结构都当作普通参数绑定。动态排序字段等结构应通过固定白名单选择。

连接数据库时，账号密码应放在受控配置或密钥管理系统中，避免提交到公开代码仓库。数据库用户只应拥有完成任务所需的权限。密码存储也不能用明文或可逆加密代替密码哈希；应使用专为密码设计、带盐并具有适当成本参数的密码哈希方案，由可靠库或平台实现，具体参数按当前安全建议和系统资源评估。不要自行设计哈希算法。

学习 HTTP 时，理解方法、路径、状态码、请求头、请求体和超时。服务端输入不能因为“来自内部网络”就默认可信。要做身份认证、权限校验、输入校验和合理的资源限制，并区分认证失败与无权访问等情况。限制大小或数量时应结合业务设定，例如请求体最大字节数、分页上限、上传文件大小和处理超时；没有适用于所有系统的统一安全数值。还要注意限制是在进入昂贵处理之前生效，并评估并发请求带来的总体资源消耗。

这些基础清楚后，再学习 Spring Boot 等框架会更有效。框架能提供依赖注入、Web 路由、配置和数据访问等能力，但不会自动让业务规则正确，也不会替你决定事务边界、访问控制和错误处理。先看懂控制器、服务层、数据访问层的职责，再判断项目是否真的需要分层；不要为了套模板而制造大量只转发一次调用的类。

九、常见学习错误与修正方法

错误一：只看视频，不亲手修改代码

跟着敲出同样的代码，不代表能独立解决问题。每学完一个概念，至少改动一个条件、增加一个边界用例，并预测输出后再运行。预测与实际不一致时，追查原因比继续刷视频更有价值。

错误二：把 API 记忆当成编程能力

API 名称可以查文档。更重要的是知道选择某个类型的理由、它的行为边界以及失败方式。学集合时要会判断顺序、重复和并发要求；学异常时要知道谁负责恢复，而不是只记住如何写 try-catch。

错误三：过早堆叠技术栈

同时引入数据库、缓存、消息队列、容器和多个框架，会让初学者很难分清故障来源。每次只增加一种主要复杂度，并确保能解释它解决的问题和新增的运维成本。技术本身不是项目价值的替代品。

错误四：忽略边界与不可信输入

对数字要考虑范围和溢出，对字符串要考虑空值与长度，对文件和网络输入要考虑格式、大小、超时和权限。校验既要符合业务，也不能只依赖前端；服务端仍须验证。错误消息可以帮助定位问题，但不应向外部用户暴露堆栈、密钥或内部实现细节。

错误五：复制依赖和代码，却不看版本与用途

依赖版本应与 JDK、框架和项目构建配置兼容。复制示例前确认代码使用的 API 在目标版本中可用，并检查依赖来源、维护状态和许可证要求。安全敏感功能优先采用可信、持续维护的库，不要因为示例短就自行实现加密、认证或令牌校验。

十、一个可执行的阶段计划

学习速度因人而异，不必把计划理解为固定期限。可以按阶段设定验收结果：

1. 语法阶段：能独立编写带条件、循环、方法和数组的命令行程序，并解释输入输出。
2. 对象阶段：能为小需求设计类，控制字段访问，并说明对象如何保持合法状态。
3. 数据处理阶段：能选择合适集合，处理异常，读取文件，写出边界测试。
4. 小项目阶段：完成一个单机程序，具备清楚的运行说明、核心测试和错误处理。
5. 方向阶段：根据目标学习数据库、HTTP、并发、Spring、Android 或其他平台知识。

每个阶段都应留下可检查的成果：源代码、测试、运行命令和简短说明。遇到问题时先读完整错误信息，确认报错位置和输入，再缩小复现范围。学会查 Java 官方 API 文档、所用框架文档和错误堆栈，是比记住更多零散技巧更可靠的长期能力。

结语：先建立判断力，再扩大项目规模

Java 学习的顺序可以概括为：语法与控制流程，面向对象，集合与异常，文件和测试，然后用小项目检验基础；面向服务端，再补 SQL、HTTP 和数据库，最后学习框架与部署。项目可以提前开始，但项目的复杂度要与当前能力匹配。

真正值得追求的不是“会用多少框架”，而是能解释程序为什么这样运行，能发现输入和资源的边界，能用测试验证规则，并能在出现故障时逐层定位。把这些基础练扎实，再进入更大的项目，学习速度通常会更稳定，也更容易做出可维护的代码。