java 语言教程|零基础入门到实战精讲
从 JDK 安装到 Spring Boot 项目实战,覆盖 Java SE/EE 全栈知识体系,结合真实企业开发场景,助你系统掌握 Java 编程语言核心能力,高效应对开发、面试与项目挑战。
开始学习零基础入门:环境搭建与第一个程序
Java 开发环境三件套
构建 Java 应用离不开三大核心组件:JDK(Java Development Kit)、JRE(Java Runtime Environment)与 JVM(Java Virtual Machine)。它们构成完整的运行与开发闭环:
- JDK:Java 开发工具包,含编译器(javac)、调试器(jdb)、文档生成工具(javadoc)等,是程序员的“武器库”。
- JRE:Java 运行环境,包含 JVM + 核心类库(如 java.lang、java.util),用于运行已编译的 .class 文件。
- JVM:Java 虚拟机,负责字节码解释/编译执行、内存管理、垃圾回收(GC),是 Java 跨平台能力的基石。
💡 JDK 包含 JRE,JRE 包含 JVM —— 三者是包含关系,非并列关系。
JDK 安装与配置要点
以 JDK 17(长期支持版本)为例:
- 下载官网:jdk.java.net/17 或 Oracle 官方站点
- 解压后设置环境变量:
JAVA_HOME→ JDK 安装路径(如C:\jdk-17)PATH中追加%JAVA_HOME%\bin(Windows)或$JAVA_HOME/bin(Linux/macOS)
- 验证安装:
输出应包含 17.x.x 字样,如java -version javac -versionopenjdk version "17.0.9" 2022-10-18 - 推荐搭配 IDE:Eclipse(轻量)、IntelliJ IDEA(功能全面)、VS Code + Java Extension Pack(简洁)
Hello World 全解析
传统起点程序如下:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, Java!");
}
}
逐行解析:
- public class HelloWorld:定义公共类,文件名必须与类名一致(区分大小写)
- main 方法:程序入口点,签名固定为
public static void main(String[] args) - System.out.println:标准输出方法,底层调用
PrintStream.println - args:命令行参数数组,可接收外部输入(如
java HelloWorld arg1 arg2)
💡 命名规范提醒:类名采用大驼峰(PascalCase),方法/变量名用小驼峰(camelCase)
常见新手错误排查清单
| 错误现象 | 可能原因 | 解决方案 |
|---|---|---|
| javac: command not found | PATH 未配置 JDK/bin | 检查 JAVA_HOME 与 PATH 变量,重启终端 |
| Class name, HelloWorld, is invalid | 文件名与类名不一致或含非法字符 | 确保文件为 HelloWorld.java,无空格/中文 |
| Main method not found | main 签名错误(缺 static/void/args 类型) | 严格按 public static void main(String[] args) 编写 |
| java.lang.NoClassDefFoundError | 运行时类路径错误或未编译 | 先 javac HelloWorld.java 再 java HelloWorld |
核心语法:变量、运算与流程控制
数据类型与内存模型
Java 分为 8 种基本类型 与 引用类型(类、接口、数组):
| 类型 | 字节数 | 默认值 | 示例 |
|---|---|---|---|
| byte | 1 | 0 | byte b = 127; |
| short | 2 | 0 | short s = 32767; |
| int | 4 | 0 | int i = 2147483647; |
| long | 8 | 0L | long l = 9223372036854775807L; |
| float | 4 | 0.0f | float f = 3.14f; |
| double | 8 | 0.0d | double d = 3.1415926; |
| char | 2 | '\u0000' | char c = '中'; |
| boolean | 1位 | false | boolean flag = true; |
⚠️ 注意:int 是最常用整型;浮点数慎用 == 比较(用误差范围或 BigDecimal);char 实际存储 Unicode 编码值。
运算符优先级与陷阱
常见运算符优先级(从高到低):
- 括号 ()、数组下标 []、成员访问 .
- 自增 ++、自减 --(后置优先级高于前置)
- 一元运算符:+、-、!、~
- 乘除模:* / %
- 加减:+ -
- 位移:<< >> >>>
- 关系:< <= > >= instanceof
- 相等:== !=
- 按位与:&
- 按位异或:^
- 按位或:|
- 逻辑与:&&
- 逻辑或:||
- 三元:? :
- 赋值:= += -= *= /= %= &= ^= |= <<= >>= >>>=
💡 典型陷阱:
int a = 5;
int b = a++ + ++a + a; // 结果为 5 + 7 + 7 = 19
// a++ 先用后加:取5,a→6;++a 先加后用:a→7,取7;最后a=7
流程控制:循环与分支
Java 提供三种循环结构:
| 类型 | 适用场景 | 关键特性 |
|---|---|---|
| for | 已知循环次数 | 初始化→条件→迭代表达式三段式 |
| while | 循环次数未知,先判断再执行 | 条件为 false 时退出 |
| do...while | 至少执行一次的循环 | 先执行后判断,条件为 true 继续 |
💡 增强 for 循环(for-each)仅适用于可迭代对象(数组、Collection),无法获取索引:
String[] arr = {"Java","Spring","Hibernate"};
for (String s : arr) {
System.out.println(s);
}
⚠️ 循环嵌套建议:三层以上嵌套易读性下降,可提取方法或使用流式处理。
面向对象编程:封装、继承、多态
类与对象的定义规范
以 汽车 类为例:
public class Car {
// 封装:私有属性 + 公共访问器
private String brand; // 品牌
private double price; // 价格
// 构造器:初始化对象
public Car(String brand, double price) {
this.brand = brand;
this.price = price;
}
// Getter/Setter 方法(IDE 可自动生成)
public String getBrand() { return brand; }
public void setBrand(String brand) { this.brand = brand; }
public double getPrice() { return price; }
public void setPrice(double price) {
if (price > 0) this.price = price;
}
// 行为方法
public void start() {
System.out.println(brand + " 启动引擎 → 驾驶中...");
}
}
💡 设计原则:
- 属性私有化(封装性):防止外部随意修改内部状态
- 构造器重载(灵活性):支持不同初始化方式
- 方法命名动词化(行为语义):如 start、stop、run
继承与 super 关键字
定义 电动车 继承汽车:
public class ElectricCar extends Car {
private int batteryCapacity; // 电池容量(kWh)
public ElectricCar(String brand, double price, int battery) {
super(brand, price); // 调用父类构造器(必须首行)
this.batteryCapacity = battery;
}
@Override
public void start() {
System.out.println("无声启动 → 电池供电 " + batteryCapacity + "kWh");
super.start(); // 调用父类方法
}
}
⚠️ 重要规则:
- Java 单继承:一个类只能直接继承一个父类
- 子类构造器必须显式/隐式调用父类构造器(无参时自动调用 super())
@Override注解确保方法签名与父类一致(避免拼写错误)
多态:接口与抽象类的应用
定义 充电接口:
public interface Charging {
void charge(int voltage); // 接口方法默认 public abstract
}
电动车实现接口:
public class ElectricCar extends Car implements Charging {
// ...
@Override
public void charge(int voltage) {
System.out.println("接入 " + voltage + "V 充电桩");
}
}
多态调用示例:
Car car = new ElectricCar("Tesla", 350000, 100);
car.start(); // 输出:无声启动... → Tesla 启动引擎...
((Charging)car).charge(220); // 强制类型转换后调用接口方法
💡 设计建议:
- 优先使用接口编程(解耦)
- 抽象类适合有默认实现的基类(如模板方法模式)
- 多态是 Spring 依赖注入(DI)的底层机制
集合框架:List、Set、Map 深度解析
ArrayList vs LinkedList
ArrayList 基于动态数组实现,LinkedList 基于双向链表实现:
| 特性 | ArrayList | LinkedList |
|---|---|---|
| 随机访问 | ✅ O(1) 快 | ❌ O(n) 慢 |
| 插入/删除 | ❌ O(n) 慢(需移动) | ✅ O(1) 快(仅改指针) |
| 内存占用 | 低(仅存元素) | 高(每个节点含前后指针) |
| 线程安全 | ❌ 需外部同步 | ❌ 需外部同步 |
💡 使用场景:
- 频繁查询 → ArrayList
- 频繁插入/删除 → LinkedList
- 需要栈结构 → 使用 ArrayDeque(比 Stack 性能高)
HashSet vs TreeSet
HashSet 基于 HashMap 实现,TreeSet 基于红黑树实现:
| 特性 | HashSet | TreeSet |
|---|---|---|
| 存储顺序 | 无序(哈希分布) | 自然排序/自定义排序 |
| 元素唯一性 | ✅(通过 hashCode + equals) | ✅(通过 compareTo) |
| 时间复杂度 | 增删查 O(1) | 增删查 O(log n) |
| 空值支持 | ✅ 允许1个 null | ❌ 禁止 null(NPE) |
💡 关键点:
- 重写 equals 必须重写 hashCode(否则 HashSet 存重复)
- TreeSet 元素必须实现 Comparable 或传 Comparator
HashMap vs ConcurrentHashMap
HashMap 是非线程安全的哈希表,ConcurrentHashMap 是线程安全版本:
| 特性 | HashMap | ConcurrentHashMap |
|---|---|---|
| 线程安全 | ❌ | ✅(分段锁/CAS) |
| put 操作 | 直接覆盖旧值 | 返回旧值,无旧值则 null |
| 迭代器 | 快速失败(fail-fast) | 弱一致性(允许并发修改) |
| JDK 1.8 改进 | 链表转红黑树(>8) | 取消分段锁,用 CAS + synchronized |
💡 使用建议:
- 单线程 → HashMap
- 多线程高并发 → ConcurrentHashMap
- 需排序 → LinkedHashMap / TreeMap
Stream 流处理:函数式编程实战
Stream 三大操作类型
中间操作(返回新 Stream,惰性求值):
filter:过滤元素map:映射转换sorted:排序(自然/自定义)distinct:去重(依赖 equals/hashCode)limit/skip:截取子集
终止操作(触发执行,返回结果):
forEach:遍历collect:收集成集合(List/Map/Set)count:统计数量min/max:求极值anyMatch/allMatch/noneMatch:条件判断
实战案例:电商订单筛选
需求:筛选 2023 年 的 已支付 订单,按 金额降序 排列,取前 5 名:
import java.util.*;
import java.util.stream.Collectors;
public class StreamDemo {
public static void main(String[] args) {
List orders = Arrays.asList(
new Order("2023-01-10", "PAID", 1299.0),
new Order("2022-12-05", "PAID", 2599.0),
new Order("2023-03-22", "PAID", 899.0),
new Order("2023-05-18", "PAID", 3999.0),
new Order("2023-07-01", "PAID", 1599.0)
);
List top5 = orders.stream()
.filter(o -> o.year().equals("2023") && "PAID".equals(o.status()))
.sorted(Comparator.comparing(Order::amount).reversed())
.limit(5)
.collect(Collectors.toList());
top5.forEach(System.out::println);
}
}
class Order {
private final String date;
private final String status;
private final double amount;
public Order(String date, String status, double amount) {
this.date = date; this.status = status; this.amount = amount;
}
public String year() { return date.substring(0, 4); }
public String status() { return status; }
public double amount() { return amount; }
@Override
public String toString() {
return String.format("%s | ¥%.2f", date, amount);
}
}
💡 性能提示:
- 避免中间操作嵌套(如 map 内嵌 filter)
- 并行流仅适合 CPU 密集型任务(如大数据计算)
- 避免中途转集合(失去 Stream 优势)
并发编程:线程与同步机制
线程创建方式对比
| 方式 | 代码示例 | 适用场景 |
|---|---|---|
| 继承 Thread | class MyThread extends Thread { public void run() {} } |
简单任务,但无法继承其他类 |
| 实现 Runnable | class MyTask implements Runnable { public void run() {} } |
推荐:避免单继承局限,可共享数据 |
| Callable + Future | FutureTask |
需返回结果/抛异常的任务 |
💡 线程池统一管理:
ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> System.out.println("任务执行中..."));
pool.shutdown();
线程安全三大武器
1. synchronized 关键字
public synchronized void deposit(double amount) {
balance += amount; // 同步方法
}
2. Lock 显式锁(ReentrantLock)
private final Lock lock = new ReentrantLock();
lock.lock();
try {
balance += amount;
} finally {
lock.unlock();
}
3. 原子类(java.util.concurrent.atomic)
private final AtomicInteger balance = new AtomicInteger(0);
balance.addAndGet(amount);
💡 选择建议:
- 简单同步 → synchronized
- 高并发细粒度控制 → Lock
- 计数器/状态标志 → 原子类
死锁定位与避免策略
死锁条件(四个必须):
- 互斥:资源独占
- 请求与保持:进程已占资源,又申请新资源
- 不可剥夺:已获资源不可强行收回
- 循环等待:存在进程-资源循环链
典型死锁代码:
public void deadlock() {
new Thread(() -> {
synchronized(a) {
synchronized(b) { ... }
}
}).start();
new Thread(() -> {
synchronized(b) {
synchronized(a) { ... }
}
}).start();
}
避免策略:
- 按固定顺序加锁(如先 a 后 b)
- 使用定时锁(tryLock)
- 减少锁的粒度与持有时间
- 使用 java.util.concurrent 工具类
Spring 生态:企业级开发核心框架
Spring 核心特性概览
- 控制反转(IoC):对象创建权由容器管理
- 依赖注入(DI):通过构造器/Setter 注入依赖
- 面向切面编程(AOP):日志、事务、安全等横切关注点统一处理
- 声明式事务:@Transactional 注解简化事务管理
- 测试支持:Spring TestContext Framework
💡 Spring Boot 自动配置:
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Controller 层开发规范
RESTful 风格接口示例:
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
// 查询用户列表
@GetMapping
public List list() {
return userService.findAll();
}
// 新增用户
@PostMapping
public User create(@Valid @RequestBody User user) {
return userService.save(user);
}
// 删除用户
@DeleteMapping("/{id}")
public ResponseEntity delete(@PathVariable Long id) {
userService.delete(id);
return ResponseEntity.noContent().build();
}
}
⚠️ 关键注解:
@RequestBody:JSON 转 Java 对象@PathVariable:提取 URL 路径变量@Valid:触发 JSR-303 参数校验@ResponseStatus:自定义响应码
JVM 深度解析:内存模型与 GC 原理
JVM 运行时数据区
| 区域 | 功能 | 异常 | 是否线程共享 |
|---|---|---|---|
| 程序计数器 | 当前线程执行字节码行号 | 无异常 | 否 |
| 虚拟机栈 | 方法调用栈帧(局部变量/操作数) | StackOverflowError | 否 |
| 本地方法栈 | 执行 native 方法 | StackOverflowError | 否 |
| 堆 | 对象实例存储区 | OutOfMemoryError | 是 |
| 方法区 | 类元数据/常量/静态变量 | OutOfMemoryError | 是 |
💡 堆内存划分:
- 新生代(Eden + S0/S1):对象刚创建
- 老年代:长期存活对象
- 永久代(JDK8 前)/元空间(JDK8+):存放类信息
垃圾回收机制(GC)
标记-清除:标记存活对象 → 清除未标记区域 → 产生内存碎片
复制算法:新生代使用,将 Eden/S0 中存活对象复制到 S1 → 清空 Eden/S0
标记-整理:老年代使用,移动存活对象到一端 → 清理边界外空间
分代收集:新生代(Minor GC) + 老年代(Major GC/Full GC)
💡 GC 日志关键参数:
-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:gc.log
调试与性能优化:实战技巧
IDE 调试技巧
- 断点:点击行号左侧设置,右键可设置条件(如
i > 100) - 监控变量:右键变量 → Watch,实时跟踪值变化
- 异常断点:Debug → View Breakpoints → Java Exception Breakpoints
- 方法返回值:在 return 行设置断点
💡 远程调试:
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005 -jar app.jar
性能优化三板斧
- 数据库层:索引优化、慢查询分析(EXPLAIN)、连接池配置
- 应用层:缓存(Redis)、异步处理(@Async)、线程池调优
- 系统层:JVM 参数调优(堆大小/GC 型号)、操作系统参数(ulimit)
💡 常见瓶颈:
- SQL 无索引 → 全表扫描
- 大对象频繁创建 → GC 频繁
- 同步块过大 → 线程阻塞
- 未关闭资源 → 连接池耗尽
高频面试题精讲
1. == 与 equals 的区别
== 比较内存地址;equals 默认比较地址,但 String/包装类已重写比较值:
Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true(缓存池 -128~127)
System.out.println(a.equals(b)); // true
Integer c = 200;
Integer d = 200;
System.out.println(c == d); // false(超出缓存范围)
System.out.println(c.equals(d)); // true
2. String、StringBuilder、StringBuffer
| 类 | 可变性 | 线程安全 | 性能 |
|---|---|---|---|
| String | 不可变 | 安全 | 低 |
| StringBuilder | 可变 | 不安全 | 高 |
| StringBuffer | 可变 | 安全 | 中 |
💡 使用建议:单线程用 StringBuilder;多线程用 StringBuffer
3. ArrayList 扩容机制
默认初始容量 10,扩容为原容量的 1.5 倍(oldCapacity + (oldCapacity >> 1)):
newCapacity = oldCapacity + (oldCapacity >> 1);
// 例:10 → 15;15 → 22(15+7)
⚠️ 优化建议:预估大小时指定初始容量,减少扩容次数