Java零基础入门指南：从JDK环境搭建到面向对象，夯实练气巅峰基本功

如果编程世界里也有修炼境界，Java入门这段路，我愿称之为“练气期”。最近后台很多朋友问我：电脑上连JDK都没装过，到底该从哪里开始？零基础学Java，第一步到底干什么？Java基础要学到什么程度才算“差不多”？这篇文章就是我对这些问题的完整回答——一份Java编程入门指南，从环境搭建讲到语法基础，从面向对象讲到集合与异常，最后再附上我这些年带新人踩过的坑和总结出来的学习路线。标题叫“练气巅峰”，意思很明确：入门阶段不求学多求深，但求把底子打扎实。这份指南适合完全零基础的小白，也适合那种“学过但总觉得自己地基不牢”的半吊子，看完你会有一种“原来Java的基础就这几块”的通透感。

1. 为什么把Java入门比作“练气”：先建立正确的认知框架

1.1 练气期的本质：基础决定上限

修真小说里的练气期，是凡人与修士的分水岭。练气阶段练的不是花哨法术，而是经脉、丹田、灵气的纯度。到了练气巅峰，哪怕不会高级神通，一拳一掌也带着扎实气劲。Java编程入门的本质完全是同一回事。很多人问我“Java难不难学”，我通常不直接回答，因为答案取决于你处在哪个阶段。Java的语法在主流语言里真不算难，难的是把“面向对象”“集合框架”“异常机制”这些底子打牢固。底子扎实的人，后面学Spring、学微服务、学消息队列都是顺着主干长枝叶，查文档就知道怎么用；底子虚浮的人，今天抄一个登录功能，明天抄一个爬虫，代码量越攒越多，自己写出来的东西却越来越心虚。

所以这篇指南的目标只有一个：把入门阶段的Java基础打磨到“巅峰”。学完它，你应该能独立写出一个多类、有继承、有接口、能处理异常、会用集合的小项目，而不是仅仅认识几个关键字。别小看这句话，能做到的人，练气就圆满了。

1.2 先分清三件事：JDK、JRE、JVM

装环境之前，有三样东西必须分清楚，很多新手在这一步就被绕晕了——反正都是Java，为什么一会儿JDK一会儿JVM？

• JVM（Java Virtual Machine）是Java虚拟机，负责执行字节码，是整个Java生态的“运行内核”。
• JRE（Java Runtime Environment）是Java运行时环境，等于JVM加上运行Java程序所需的核心类库，是你“跑”Java程序的最小环境。
• JDK（Java Development Kit）是Java开发工具包，等于JRE加上编译器（javac）、调试器、打包工具等一整套开发工具，是你“写”和“编译”Java程序必须要装的东西。

用做饭来类比：JDK是一间完整厨房，灶台、锅铲、食材全都有；JRE是一间只有灶台的厨房，能热菜但不能从生食材开始做；JVM就是那个灶台本身。你要开始学写代码，直接装JDK就够了，因为它已经把JRE和JVM包含在内，不需要再单独装第二遍。

之前见过一个新手把JDK、JRE、JVM各下载一份全装上，结果环境变量配来配去把自己绕进死胡同。记住一句话：装JDK是唯一正确姿势，其他两个只是概念，不用装。

1.3 Java的底层运行机制：一次编译，到处运行的真相

我更愿意在一开始就把Java的运行机制讲清楚，因为理解了底层，后面很多“灵异事件”你都能想通。一个.java源文件，先经过javac编译生成.class字节码文件；字节码不面向任何具体操作系统，而是面向JVM；不同平台（Windows、Linux、macOS）各自安装对应版本的JVM，JVM负责把字节码解释或编译成当前平台能执行的机器码。

这就是“一次编写，到处运行”的本质。Java程序之所以能在Windows上开发、部署到Linux服务器，不是因为它“不用编译”，而是因为字节码是跨平台的，真正适配系统的是JVM。所以你在自己电脑上跑通的程序，扔到服务器上只要装好JDK，基本能直接跑，这在新手期给你省去了大量跨平台移植的痛苦。

另外要提一句，Java是“半编译半解释”的语言。JVM对热点代码会做JIT即时编译，让频繁执行的代码接近原生性能；冷门代码则用解释执行。初学阶段不需要太纠结，但要知道“Java慢”的印象早就过时了，现代JVM的性能在业务开发领域完全够用。

2. 丹田初成：安装JDK、配置环境、跑通第一个程序

2.1 JDK版本怎么选：长期支持版优先，别追新

第一个决策就卡住不少人：到底装哪个版本的JDK？我的建议非常明确——选长期支持版（LTS）。目前最主流的选择是JDK 17或JDK 21，企业在生产环境大量使用这两个版本；老项目还有不少跑在JDK 8上，但新人不建议从JDK 8开始学，因为语法太老，后面还要学新特性。

怎么下载？说几个靠谱渠道：

• Oracle官网：最官方，但下载体验一般，需要登录。
• Adoptium（Eclipse Temurin）：社区维护的开源JDK发行版，干净免费，是我个人最推荐的下载来源。
• 国内不少开源镜像站也有JDK安装包，下载速度快，适合网络不太稳的情况。

安装JDK本身没什么技术含量，一路下一步。但我强烈建议把JDK安装到一个不带空格和中文的路径下，比如D:\dev\jdk-17。之前见过有人装到C:\Program Files\Java，后续配置某些工具时因为路径空格出各种幺蛾子，非常闹心。

2.2 环境变量配置：PATH和JAVA_HOME

JDK装完不等于能用，你还需要让操作系统在任何目录下都能找到java和javac命令。这就是环境变量的作用。

Windows下的配置步骤：

1. 右键“此电脑” → 属性 → 高级系统设置 → 环境变量。
2. 新建一个系统变量，变量名JAVA_HOME，变量值填你的JDK安装路径，比如D:\dev\jdk-17。
3. 找到Path变量，点击编辑，新增一行%JAVA_HOME%\bin。
4. 重新打开一个命令行窗口，输入java -version和javac -version进行验证。

Linux/macOS用户可以在~/.bashrc或~/.zshrc里添加：

export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64 export PATH=$JAVA_HOME/bin:$PATH

配置完成后，记得执行source ~/.bashrc让配置生效。

JAVA_HOME这个变量千万别觉得多余——后面你学Maven、Gradle、Spring Boot，它们都会主动去找这个变量。现在一步到位，后面省心。验证命令输出能看到类似“openjdk 17.0.x”字样，就说明环境已经通了。

2.3 Hello World：从手写到编译运行的完整过程

环境就绪后，我们写第一个程序。别急着打开IDE，先用最原始的方式体验一次“从源码到运行”的完整链路。创建一个Hello.java文件，内容如下：

public class Hello { public static void main(String[] args) { System.out.println("Hello, Java!"); } }

然后打开命令行，进入文件所在目录，依次执行：

javac Hello.java java Hello

javac会把Hello.java编译成Hello.class字节码，java Hello则启动JVM执行这个字节码。第一个坑通常出现在这里：文件名叫Hello.java，类名也叫Hello，二者必须完全一致，否则编译直接报错。这是Java对“文件名与public类名一致”的硬性规定，没有商量余地。

还要先养成一个好习惯：把代码里的括号、分号当成语法质量的象征。新手初学经常漏分号、括号不匹配，这种错误编译期就会提示，但看多了会麻木。我的经验是，前两周写代码刻意放慢速度，每次写完都自己默读一遍，把“每个左括号都有右括号、每个语句都有分号”变成肌肉记忆。

顺带解释一下main方法为什么长这样：

• public：JVM要从外部调用它，必须是公开的。
• static：JVM启动时还没有创建任何对象，它必须是通过类直接调用的静态方法。
• void：main方法不需要返回任何值给操作系统。
• String[] args：留给外部传入的命令行参数，现在用不上，但语法必须保留。

把这四行拆开理解了，你的Java就算正式迈过第一道门槛。

2.4 从记事本到IDE：让工具替你干杂活

命令行跑完Hello World，学习体验就该升级了。后续代码越来越长，再拿记事本写就是自虐。IDE（集成开发环境）能让你的精力集中在语法和设计上，而不是纠结文件路径和编译命令。

新手我推荐用IntelliJ IDEA Community版，免费、轻量、在Java领域占有率最高。下载安装后创建一个新项目，它会自动帮你搞定JDK关联、项目结构、编译运行这些琐事，点一下绿色三角就能跑程序。IDEA还内置了强大的自动补全、代码提示和反编译工具，写Java极其顺手。另一个选项是VSCode加Java扩展包，插件配置好之后也够用，但论Java支持深度，IDEA仍是首选。

需要提醒的是：IDE帮你把javac藏在了后台，你不该因此把命令行编译忘光。遇到构建问题时，退到命令行跑一次javac往往能看清报错本质。练习阶段我甚至建议你两天用命令编译一次，保持对构建流程的体感。

3. 感知灵力运转：Java基础语法与核心数据类型

3.1 变量、字面量、基本数据类型：定义灵力容量

Java是强类型语言，这一点和Python、JavaScript有本质区别。所谓“强类型”，意思是每个变量在声明时必须明确类型，一旦声明，这个变量只能装对应类型的数据。这对新手来说像戴上了枷锁，但从长远看是保护：很多运行时才暴露的类型问题，在编译期就被挡在门外。

Java的基本数据类型一共有八种，我习惯称为“四整二浮一符一布尔”：

声明变量的语法很简单：类型 变量名 = 值;。比如：

int age = 20; double price = 99.5; char grade = 'A'; boolean passed = true;

注意几个容易踩坑的点：long类型的赋值，如果值超过int范围，末尾必须加L。float类型的赋值，末尾必须加F，否则小数默认是double，精度不匹配会编译报错。char用的是单引号，字符串用的是双引号，这两者别混。

变量命名规则也要记住：可以由字母、数字、下划线、美元符号组成，但不能以数字开头，不能是Java保留字（比如class、public、if）。规范建议用驼峰命名，studentName、totalCount这种风格。这里多啰嗦一句：命名别用a、b、x这种，代码是给人读的，变量名本质是给未来的自己写注释。

3.2 运算符与流程控制：给灵力指定走向

变量只是存储数据，程序真正做事靠的是运算和控制流程。Java的运算符分成几类：

• 算术运算符：+ - * / %，其中%是取余数，判断奇偶、判断闰年、拆解数字都常用。
• 比较运算符：> < >= <= == !=，结果为boolean。
• 逻辑运算符：&&（与）、||（或）、!（非），注意&&和||有短路效果——左边能决定结果时，右边不会执行。
• 赋值运算符：=以及+=、-=、*=、/=这类复合赋值。

流程控制就是分支与循环，Java里最常见的就是if-else、switch、for、while。看一个实际例子，判断一个年份是不是闰年：

int year = 2024; if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) { System.out.println(year + "是闰年"); } else { System.out.println(year + "不是闰年"); }

switch在JDK 17里已经有很现代的新写法，用箭头而不是冒号，不需要写break：

String day = "Monday"; switch (day) { case "Monday", "Tuesday", "Wednesday" -> System.out.println("工作日"); case "Saturday", "Sunday" -> System.out.println("周末"); default -> System.out.println("未知"); }

循环结构里，for适合知道循环次数的情况，while适合不确定次数、只依赖条件的情况。初学阶段不用搞什么花哨技巧，但必须把for嵌套循环练熟——九九乘法表、打印三角形、冒泡排序，都是从这里演化出来的基本功。

3.3 数组与字符串：最常用的两类“容器”

数组是相同类型数据的集合，长度固定，声明方式有两种：

int[] nums = new int[5]; // 默认值全是0，长度为5 int[] initNums = {1, 3, 5, 7, 9};

遍历数组最简洁的是增强for循环：

for (int num : nums) { System.out.println(num); }

字符串String是Java里最特殊的类型：它是引用类型，但使用频率比基本类型还高。字符串本质是不可变对象，每次对字符串做修改操作（比如+拼接），底层都会创建新对象。所以判断字符串内容是否相等，必须用equals()方法，不能用==——==比较的是两个引用是否指向同一个对象，初学者在这里翻车的概率极高。

String s1 = "hello"; String s2 = new String("hello"); System.out.println(s1.equals(s2)); // true，比较内容 System.out.println(s1 == s2); // false，比较引用地址

如果需要频繁拼接字符串，比如循环里拼接一万次，用StringBuilder性能会好很多。这个知识点面试也经常考：“String、StringBuilder、StringBuffer”三兄弟的区别。入门阶段你只需要记住，普通拼接用+，循环拼接用StringBuilder就够了。

3.4 方法：把招式封装成固定套路

方法相当于把一段逻辑封装成带名字的操作，可以反复调用。Java方法定义的基本结构：

访问修饰符 返回值类型 方法名(参数列表) { 方法体 return 返回值; }

举个最简单的加法例子：

public static int add(int a, int b) { return a + b; }

调用时int result = add(3, 5);即可。

方法有两个概念必须吃透：

• 重载（Overload）：同一个类里，方法名相同、参数列表不同。比如add(int a, int b)和add(double a, double b, double c)可以同时存在。调用时Java根据参数个数和类型自动匹配。
• 值传递：Java传参永远是“值传递”，也就是说传给方法的是变量的副本。即使方法内部修改参数，外部变量也不变。这是面试常考的基础题，现在理解了，后面少走弯路。

方法设计的原则也很简单：一个方法只做一件事，方法名要能准确表达它做的事。不要去写五百行一个方法的大怪物，那会让维护变成灾难。

4. 练气核心心法：面向对象编程的三大支柱

4.1 为什么说面向对象是Java的灵魂

如果你只学了变量、循环、方法，那你用的还是“面向过程”的思路——自己一步步指挥程序执行。但Java是一门强制面向对象的语言，它的设计哲学是：用“对象”来模拟现实世界里的实体。对象有状态（属性/字段）和行为（方法），程序就是对象与对象之间互相调用、协作的过程。

有个很经典的教学类比：类是图纸，对象是按图纸造出来的实际产品。图纸定义了产品有哪些属性、能做什么行为，但图纸本身不住人；真正住人的是图纸造出来的那一栋栋房子——对象。同一个图纸可以造出千千万万间结构相同的房子，这就是“类→实例”的关系。

Java里一切代码，能直接写出去的都放在类里。你创建的每个文件都是一个类，每个类中都定义着描述或行为。

4.2 类与对象：从图纸到实例的完整过程

定义一个学生类：

public class Student { // 属性 String name; int age; // 方法 void introduce() { System.out.println("我叫" + name + "，今年" + age + "岁"); } // 构造方法 public Student(String name, int age) { this.name = name; this.age = age; } }

然后使用它：

Student s1 = new Student("小明", 18); s1.introduce();

new Student(...)做了两件事：在堆内存中创建对象、调用构造方法完成初始化。变量s1其实是一个“引用”，指向堆里的那个对象。理解“引用”这个概念很关键——后面对比==和equals、理解集合存储，全都围绕它。

构造方法有几个特点：名字和类名完全相同、没有返回值类型、用new关键词触发。this关键字指的是“当前对象”，用来区分成员变量和参数，比如this.name = name。

以后每个类都尽量习惯性地问自己：“这个类的对象创建时需要哪些必要信息？”这个问题能让你顺手把构造方法设计好。

4.3 三大支柱之封装、继承、多态

面向对象的核心能力可以浓缩成六个字——封装、继承、多态。

封装：属性设为private（私有），通过public的getter/setter方法访问。它的价值在于：外部无法随意篡改内部数据，数据修改规则收口到类内部。

public class Person { private int age; public int getAge() { return age; } public void setAge(int age) { if (age < 0 || age > 150) { throw new IllegalArgumentException("年龄不合法"); } this.age = age; } }

看到没，直接暴露字段，外部就能把age改成200；封装之后，非法数据在入口就被拦截。这就是封装的第一价值——数据安全。第二价值是降低耦合：内部实现随便改，对外接口不变，调用方无感知。

继承：用一个子类extends父类，子类自动拥有父类的非私有成员。代码复用的主要手段。但新手很容易犯一个错——为了复用几行代码硬造继承关系。继承真正表达的是“is-a”关系：狗是动物，所以Dog extends Animal合理；但“吉他”和“乐器”具备is-a关系也合理。如果只是想用别人的方法，用组合（把对方作为自己字段）往往更合适。

子类可以**重写（Override）**父类方法，用@Override注解标明。重写时方法名、参数列表、返回值都必须和父类一致，否则就变成重载了。

多态：父类型的引用可以指向子类对象，同一个方法调用在不同子类上有不同表现。

Animal a = new Dog(); a.speak(); // 输出狗叫 Animal b = new Cat(); b.speak(); // 输出猫叫

多态的价值在于“面向接口编程”——你不需要关心具体是哪个子类，只要它满足父类的契约，就能统一处理。比如写一个void makeSound(Animal animal)，传狗传猫都能跑，不用写一堆if判断类型。这是解耦的核心思想，也是后面学习Spring依赖注入的前置知识。

4.4 抽象类、接口与设计模式的萌芽

多态要想用得爽，你得有“抽象”的能力。Java里有两种抽象工具：

• 抽象类（abstract class）：用abstract修饰的类，里面可以有抽象方法（只有声明、没有实现）和具体方法。抽象类不能new，只能被继承。它表达的是“类本身不完整，需要子类补齐”。
• 接口（interface）：更纯粹的契约。JDK 17里接口可以定义抽象方法、默认方法（default）和静态方法，但字段只能是常量。一个类可以实现多个接口，这就是Java弥补单继承限制的方式。

两者的使用场景可以这样区分：抽象类强调“是什么”的层级关系，适合模板方法场景；接口强调“能做什么”的能力契约，适合定义行为规范。

接口也是设计模式的基础。举个活例子，策略模式最核心的思想就是“把变化的部分抽象成接口，运行时再注入具体实现”：

public interface SortStrategy { void sort(int[] arr); } public class BubbleSort implements SortStrategy { @Override public void sort(int[] arr) { // 冒泡排序实现 } } public class QuickSort implements SortStrategy { @Override public void sort(int[] arr) { // 快速排序实现 } }

调用方只需要持有SortStrategy接口，想换算法就换实现类，基本不用改其他代码。入门阶段不需要背设计模式的名字，但一定要理解接口为什么而存在——它把“做什么”和“怎么做”拆开了。等你能自然地说出“这里应该抽一个接口”，你的面向对象就算练出气感了。

5. 练气巅峰前的实战：异常、集合与常用API

5.1 异常处理：报错不是灾难，是系统在跟你说话

程序运行出问题不可怕，可怕的是程序直接崩溃，连原因都不告诉你。Java用一套异常机制把问题处理得井井有条。异常体系顶部是Throwable，下面分两大支：Error是严重系统错误，你基本不用管；Exception是程序级异常，需要处理。Exception之下又分受检异常（编译期就必须处理，比如IOException）和运行时异常（RuntimeException，比如NullPointerException、ArithmeticException，编译期不管，运行期才爆）。

处理异常的标准姿势是try-catch-finally：

try { int result = 10 / 0; } catch (ArithmeticException e) { System.out.println("除数不能为0"); e.printStackTrace(); } finally { System.out.println("无论如何都会执行"); }

简单场景还可以用try-with-resources，打开的文件、流会自动关闭，这个后面写文件操作会经常碰到。异常处理有一个核心原则：不要吞异常。catch到异常什么也不做、只写一行e.printStackTrace()，日志里定位不到问题，是最典型的新手坏习惯。入门阶段的正确做法是：能处理的就处理，处理不了就向外throws，让上层去决定。

5.2 集合框架：替你把数据管起来

数组长度固定，真实业务里数据量多半是动态的，这时候就需要集合框架（Collection Framework）。Java的集合体系初学者最容易迷茫，但只需要抓住三个核心接口：

用法的核心是泛型，即声明集合里装什么类型：

List<String> names = new ArrayList<>(); names.add("张三"); names.add("李四"); names.add("张三"); // List允许重复 Set<Integer> scores = new HashSet<>(); scores.add(90); scores.add(95); scores.add(90); // 重复添加无效，Set天然去重 Map<String, Integer> scoreMap = new HashMap<>(); scoreMap.put("张三", 88); scoreMap.put("李四", 96); int score = scoreMap.get("张三");

遍历方式也要熟练，for-each最简单，Map用entrySet拿键值对：

for (Map.Entry<String, Integer> entry : scoreMap.entrySet()) { System.out.println(entry.getKey() + " = " + entry.getValue()); }

ArrayList和LinkedList的区别、HashMap的底层原理，这些属于练气巅峰后该研究的细节，现在只要会用、能理解“选容器就是在选数据结构特性”就够了：要随机访问选ArrayList，要频繁头尾插入选LinkedList，要查重选HashSet，要按规则排序选TreeSet/TreeMap。

5.3 字符串处理与正则表达式：日常剑招的威力

Java里字符串处理API很多，初学阶段最实用的几个是：substring（截取）、indexOf（定位）、split（拆分）、replace（替换）、trim（去除首尾空格）。

String email = "test@example.com"; String username = email.split("@")[0]; System.out.println(username); // test String clean = " hello world ".trim(); System.out.println(clean.equals("hello world")); // true

正则表达式也是热词里的高频需求。Java中String.matches()可以做简单校验，比如判断是否全是数字：

String phone = "13800138000"; System.out.println(phone.matches("1\\d{10}")); // true

这个正则里的\\d表示数字，{10}表示正好10位，整体匹配“1开头共11位数字”。正则上手有门槛，但入门阶段常见格式校验（手机号、邮箱、身份证）用那么十几个常用表达式就够了。记住，正则出问题的时候先检查“转义”——Java字符串里\必须写成\\，这是新手最常踩的坑。

5.4 文件读写与输入输出：和外部世界打交道

程序不能永远只在内存里自嗨，读写文件是编程入门的必修课。JDK 7以后的Files类极大简化了文件操作：

List<String> lines = Files.readAllLines(Paths.get("input.txt")); for (String line : lines) { System.out.println(line); } Files.write(Paths.get("output.txt"), "Hello Java".getBytes());

更底层、更传统的写法是InputStream/OutputStream，以及字符流的FileReader/FileWriter。学这些不是为了用，而是为了理解Java IO的分层：

• 字节流处理一切文件（图片、视频、压缩包）——本质是0/1。
• 字符流专门处理文本，因为涉及编码转换。

文本读写最容易出错的就是编码。文件里的中文到底是UTF-8还是GBK，一旦读错就是满屏乱码。我的建议是：项目里所有文件统一用UTF-8，写文件时明确指定编码，Files.write时传StandardCharsets.UTF_8。IDE里也把默认编码改成UTF-8，这个设置能帮你省掉后续大量乱码痛苦。

6. 最后一课：从练气巅峰到筑基的进阶路线与踩坑笔记

6.1 入门阶段最常见的五个坑及排查链路

我自己带过不少新人，也看着一批又一批人在同样的地方摔倒。我把几个高频问题整理出来，并按“问题现象→原因→解决”的顺序给你完整排查链路。

坑一：java -version正常，javac提示“不是内部或外部命令”。这几乎肯定是PATH里只配了JRE的bin，或者PATH没包含JDK的bin目录。拿着echo %JAVA_HOME%先看变量是否指向JDK目录，再看看%JAVA_HOME%\bin\javac.exe是否存在。JAVA_HOME指向JRE目录也会出现这个问题，因为JRE里根本没有javac。

坑二：编译报“找不到文件”。通常是命令行当前目录不在文件所在目录，或者文件名后缀不是.java。用cd切换到源码目录，用dir（Linux用ls）确认文件名拼写，千万别直接用全路径编译时把目录写错。我之前遇到过文件名叫hello.java（小写h），类名叫Hello，Windows下编译通过了但Linux下直接报错，养成统一大写的习惯能避免大小写敏感。

坑三：Exception in thread "main" java.lang.NullPointerException。这是你入门期碰到最多的运行时异常。排查思路是：先看报错行号，找到哪个对象为null，再问自己“这个对象为什么没初始化”。八成是某个成员变量没赋值，或者从方法接收的返回值本身就是null。别问“怎么会是null”——null不会无辜出现，每个null都有源头，顺藤摸瓜。

坑四：集合遍历时删除元素报ConcurrentModificationException。在for-each循环里直接list.remove()会触发这个异常。原因在于for-each底层依赖迭代器，你在迭代过程中修改了集合结构，迭代器发现不对劲直接就炸。正确做法是用迭代器自带的remove()，或者先收集要删除的元素，循环结束后再统一删。

// 反例：会抛异常的写法 for (String s : list) { if (s.contains("bad")) { list.remove(s); } } // 正例：用迭代器删除 Iterator<String> it = list.iterator(); while (it.hasNext()) { String s = it.next(); if (s.contains("bad")) { it.remove(); } }

坑五：中文乱码。源码里写中文注释，编译后输出乱码，十有八九是编译时没指定编码。用命令编译时加上javac -encoding UTF-8 Hello.java，IDE里把全局编码设置为UTF-8。Windows默认GBK编码，Linux/macOS默认UTF-8，跨平台项目不把编码钉死，后期非常容易出诡异乱码。

6.2 练气阶段的学习路线图：学什么、按什么顺序学

入门阶段的时间规划，我按四周给你拆成四个递进的阶段，每天保证两到三小时投入的话，这个节奏很舒服。

• 第一周：语法与基础API。数据类型、运算符、分支循环、数组、字符串、方法。这一周的产出很简单：把教材里每个程序都在IDE里亲手敲一遍，而不是复制粘贴。敲代码和看代码的区别，比你想的大得多。
• 第二周：面向对象入门。类与对象、构造方法、封装、继承、多态、抽象类、接口。这一周是精华中的精华，建议每天重新写一遍“定义动物类并让子类实现叫声”的小案例，直到你闭着眼能写出多态调用。
• 第三周：常用API与工具。异常处理、集合框架（List/Set/Map）、文件读写、正则、String常用操作。每个知识点配一个小任务：用Set做去重、用Map统计字符出现次数、从文件里读出数字求和。
• 第四周：综合小项目。做一个“图书管理系统”或者“学生成绩管理程序”，用类来建模，用集合存数据，用异常处理非法输入，用文件读写做数据持久化。这个小项目能把你前几周学的所有内容串起来。做完之后，练气期就毕业了。

学习资料方面，Oracle官方Java Tutorials永远是最权威的参考；视频课国内B站上高质量的免费课很多；刷题可以用免费入门网站和刷题平台，比如牛客网的Java专项练习。这里要特别说一句：刷题不是入门阶段的主线，它应该是查漏补缺的工具，每天十道选择题足够，别一上来就死磕算法题。

6.3 用面试题反向检验你的“气”够不够纯

热词里有一个高频组合“Java面试题”，这些本来就是老手整理的考察点。很多人觉得面试题是找工作才看的，大错特错——面试题是检验基础知识牢固度的最好工具。如果一道入门级面试题你答不上来，往往不是“没学过”，而是学的时候没想透。我建议每周抽时间自测几道，不会的不必惭愧，回到对应章节再看一遍。

练气阶段值得自测的基础题，我列几个代表性的：

• String、StringBuilder、StringBuffer有什么区别？
• ==和equals()到底在比什么？
• 重载（Overload）和重写（Override）有什么区别？
• 抽象类和接口有什么区别，什么场景下用哪个？
• HashMap的底层结构是什么？（知道“数组+链表/红黑树”即可，不用深入源码）
• 为什么说Java是值传递？
• ArrayList和LinkedList的区别？

答不上来的，说明对应的基础知识点还没内化。我见过不少同学，基础题一问三不知，却天天研究微服务。这就像一个练气期修士硬要去施展元婴期的法术，气不够，反噬的是自己。把上面的问题挨个搞清楚，你的练气期才算圆满，往后筑基（学Java Web、Spring Boot）、金丹（学并发、JVM）、元婴（学架构设计），才有扎实的底子可依。

最后分享一个我教新人时的经验：每学一个知识点，都在纸上画一遍它和Java整体结构的关系。学多态时，画“Animal→Dog/Cat”；学集合时，画“List/Set/Map→ArrayList/HashSet/HashMap”。这张关系图越画越完整，你对Java的认知就不停碎片的语法点，而是一张能随时调用的地图。

另外一个非常实用的动作是：刻意找一个已经运行的项目，点开每个Java文件追踪它调用了哪些类、继承了什么父类、实现了什么接口。初学阶段哪怕只是读懂别人代码里的类和继承关系，也比自己闷头写一堆没有结构的代码更有成长。练气巅峰讲究的是“看一眼就知道这体系怎么运转”，代码阅读速度就是靠这样的笨功夫练出来的。Java入门之路没有捷径，但走对方向的人，每一步都比乱闯的人快。