java 语言教程 www.xservx.com|蜀ICP备2026035467号-3

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(长期支持版本)为例:

  1. 下载官网:jdk.java.net/17 或 Oracle 官方站点
  2. 解压后设置环境变量:
    • JAVA_HOME → JDK 安装路径(如 C:\jdk-17)
    • PATH 中追加 %JAVA_HOME%\bin(Windows)或 $JAVA_HOME/bin(Linux/macOS)
  3. 验证安装:
    java -version
    javac -version
    输出应包含 17.x.x 字样,如 openjdk version "17.0.9" 2022-10-18
  4. 推荐搭配 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 种基本类型 与 引用类型(类、接口、数组):

类型 字节数 默认值 示例
byte10byte b = 127;
short20short s = 32767;
int40int i = 2147483647;
long80Llong l = 9223372036854775807L;
float40.0ffloat f = 3.14f;
double80.0ddouble d = 3.1415926;
char2'\u0000'char c = '中';
boolean1位falseboolean flag = true;

⚠️ 注意:int 是最常用整型;浮点数慎用 == 比较(用误差范围或 BigDecimal);char 实际存储 Unicode 编码值。

运算符优先级与陷阱

常见运算符优先级(从高到低):

  1. 括号 ()、数组下标 []、成员访问 .
  2. 自增 ++、自减 --(后置优先级高于前置)
  3. 一元运算符:+、-、!、~
  4. 乘除模:* / %
  5. 加减:+ -
  6. 位移:<< >> >>>
  7. 关系:< <= > >= instanceof
  8. 相等:== !=
  9. 按位与:&
  10. 按位异或:^
  11. 按位或:|
  12. 逻辑与:&&
  13. 逻辑或:||
  14. 三元:? :
  15. 赋值:= += -= *= /= %= &= ^= |= <<= >>= >>>=

💡 典型陷阱:

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 task = new FutureTask<>(() -> "done"); 需返回结果/抛异常的任务

💡 线程池统一管理:

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

性能优化三板斧

  1. 数据库层:索引优化、慢查询分析(EXPLAIN)、连接池配置
  2. 应用层:缓存(Redis)、异步处理(@Async)、线程池调优
  3. 系统层: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)

⚠️ 优化建议:预估大小时指定初始容量,减少扩容次数