01 课程简介与学习路径

本教程面向零基础至进阶开发者,系统构建java语言程序设计知识体系,覆盖JDK 8至JDK 21主流特性(含lambda、stream API、record、pattern matching等新语法),融合企业级开发规范与主流技术栈。全站采用“理论→示例→实战→拓展”四阶教学法,确保学习者不仅能理解语法,更能掌握工程化思维与问题建模能力。

课程设计严格遵循OOP(面向对象编程)范式,强调封装、继承、多态三大特性在真实场景中的应用;同步讲解设计模式(如单例、工厂、策略、观察者)如何提升代码可维护性与扩展性。每章节均配:核心概念图解、典型错误示例、避坑指南、扩展阅读四类内容,形成完整认知闭环。

本教程特别强化工程实践能力培养:包含Maven项目结构规范、Git协作流程、单元测试(JUnit 5)覆盖率提升、日志管理(SLF4J+Logback)最佳实践、接口设计(RESTful风格)等高频实战技能,直面校招/社招核心考察点。

⚡ 学习目标

  • 掌握Java语法体系与JVM运行机制
  • 熟练使用集合框架、泛型、注解等高级特性
  • 具备高并发系统开发基础能力
  • 能独立构建Spring Boot微服务应用
  • 理解企业级项目工程化全流程

⚙️ 适配人群

  • 计算机专业在校学生(夯实基础)
  • 转行开发者(系统化补缺)
  • 初级工程师(查漏补缺)
  • 技术面试准备者(高频考点全覆盖)

〔学习资源〕

  • 配套IDEA开发环境一键配置脚本
  • JDK源码精读笔记(JDK 8/11/17)
  • 常见问题速查手册(PDF)
  • 20+真实企业案例源码

〔JDK版本演进简史〕

Java自1995年发布以来,已历经17个主版本演进。以下为关键里程碑:

JDK版本发布时间核心特性长期支持
JDK 1.01996基础语法、AWT GUI否
JDK 1.21998Java2平台、集合框架否
JDK 52004泛型、注解、枚举、自动装箱是
JDK 82014Lambda表达式、Stream API、Date Time API是
JDK 112018HTTP Client API、ZGC初步、Lambda参数本地变量推断是
JDK 172021密封类、模式匹配(switch)、Vector API(孵化)是
JDK 212023虚拟线程(Project Loom)、Record模式匹配、Structured Concurrency是

当前主流企业项目仍以JDK 8/11为主,但新项目已加速向JDK 17/21迁移。本教程所有代码均通过JDK 17兼容性验证,新特性标注适用版本。

02 语言核心语法深度解析

〔数据类型与变量〕

Java提供8种基本数据类型与引用类型(类、接口、数组)。理解其内存布局对性能调优至关重要:

  • byte(1字节)、short(2字节)、int(4字节)、long(8字节):整数类型
  • float(4字节)、double(8字节):浮点类型(注意精度丢失风险)
  • char(2字节,UTF-16编码)
  • boolean:仅true/false, JVM规范未规定具体大小

【典型错误】

double d = 0.1 + 0.2;
System.out.println(d); // 输出0.30000000000000004

【解决方案】金融计算使用BigDecimal:

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
BigDecimal sum = a.add(b);
System.out.println(sum); // 输出0.3

〔控制流程〕

if-else与switch是核心分支结构。JDK 12+对switch进行了革命性增强:

int day = 3;
String dayName = switch (day) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3, 4 -> "Mid-week";
    default -> {
        yield "Unknown";
    }
};

支持:箭头语法、多值合并、表达式返回、yield语句,显著提升可读性。

〔数组与字符串〕

数组是固定长度的连续内存块,而String是不可变类(final修饰)。常见陷阱:

  • 数组越界:访问索引超出[0, length-1]范围
  • 字符串拼接:循环中使用+号导致频繁创建对象

【优化方案】

// 错误示范
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i; // 每次循环创建新String对象
}
// 正确做法
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

StringBuilder线程不安全但效率高;StringBuffer线程安全(方法加synchronized)但性能低10%~15%。

03 面向对象编程体系

〔三大特性实现机制〕

  • 封装:通过private字段+getter/setter隐藏实现细节,结合访问修饰符(public/protected/default/private)控制可见性
  • 继承:使用extends实现代码复用,但需警惕“脆弱基类”问题(父类修改导致子类崩溃)
  • 多态:方法重写(override)+动态绑定,核心是虚方法表(vtable)机制

【多态典型应用】

abstract class Animal {
    abstract void speak();
}
class Dog extends Animal {
    @Override
    void speak() { System.out.println("Woof!"); }
}
class Cat extends Animal {
    @Override
    void speak() { System.out.println("Meow!"); }
}
public class Main {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat()};
        for (Animal a : animals) {
            a.speak(); // 运行时绑定具体实现
        }
    }
}

〔构造器与this/super〕

构造器特点:无返回类型、名称与类名相同、可重载。关键规则:

  • 子类构造器必须显式调用父类构造器(super()),否则编译器插入默认super()
  • this()与super()不能共存(必须是构造器第一条语句)
  • 构造器中可使用this调用本类其他构造器

【设计建议】

  1. 优先使用组合而非继承(“组合优于继承”原则)
  2. 避免在构造器中调用可被重写的方法
  3. 使用Builder模式构建复杂对象(避免 telescoping constructor)

04 集合框架深度剖析

〔核心接口体系〕

Collection

  • List:有序可重复(ArrayList/LinkedList)
  • Set:无序不重复(HashSet/TreeSet/LinkedHashSet)
  • Queue:队列(LinkedList/PriorityQueue)

Map

  • HashMap:哈希表实现,JDK8+红黑树优化
  • TreeMap:红黑树,有序
  • LinkedHashMap:双向链表维护插入顺序
  • ConcurrentHashMap:线程安全,分段锁→CAS+synchronized

〔HashMap工作原理〕

核心流程:

  1. 计算key的hashCode() → 确定桶索引(扰动函数+位运算)
  2. 若桶为空:直接插入
  3. 若桶非空:遍历链表/红黑树,调用equals()比较
  4. 链表长度≥8且数组长度≥64:转为红黑树

【扩容机制】

默认容量16,加载因子0.75。当size > capacity * 0.75时触发resize(),新容量=旧容量×2,元素重哈希分布。

【常见问题】

  • 为什么String、Integer适合作为key? → 不可变性保证hashCode稳定
  • 如何避免HashMap死循环? → JDK8已修复(链表转红黑树)
  • 如何选择List实现? → 随机访问用ArrayList,频繁插入删除用LinkedList

〔Stream API实战〕

JDK 8引入的函数式编程工具,支持链式操作:

List names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);

【并行流陷阱】

parallelStream()适用于CPU密集型任务(如大数据计算),但I/O操作会导致线程阻塞。建议:数据库查询/网络请求使用同步流。

05 多线程编程体系

〔线程状态转换〕

NEW(新建)

线程对象创建后

RUNNABLE(可运行)

调用start()后,等待CPU调度

BLOCKED(阻塞)

等待synchronized锁释放

WAITING(等待)

调用wait()/join()后无限期等待

TIMED_WAITING(超时等待)

调用sleep()/wait(timeout)等

TERMINATED(终止)

run()方法执行完毕

〔线程安全方案〕

〔synchronized〕

  • 对象锁:synchronized(this)
  • 类锁:synchronized(MyClass.class)
  • 方法锁:synchronized method
  • 缺点:不可中断、无超时、公平性差

〔Lock接口〕

  • ReentrantLock:可重入锁,支持公平锁/非公平锁
  • ReadWriteLock:读写分离,提升并发性能
  • StampedLock:乐观锁,支持读写分离+优化写锁

〔原子类〕

  • AtomicInteger:基于CAS(Compare-And-Swap)
  • LongAdder:高并发下性能优于AtomicLong
  • AtomicReference:对象引用原子操作

〔线程池最佳实践〕

推荐使用ThreadPoolExecutor而非Executors工厂类:

ExecutorService pool = new ThreadPoolExecutor(
    4,  // corePoolSize
    8,  // maximumPoolSize
    60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1000),
    new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

【拒绝策略选择】

  • CallerRunsPolicy:调用者线程执行(限流)
  • AbortPolicy:抛异常(默认)
  • DiscardOldestPolicy:丢弃最旧任务
  • DiscardPolicy:静默丢弃

06 IO/NIO体系对比

〔传统IO模型〕

基于流(Stream)的阻塞式I/O,特点:

  • InputStream/OutputStream:字节流
  • Reader/Writer:字符流(自动处理编码)
  • Buffered流:缓冲区优化性能

【问题】每个连接需独立线程,高并发下线程切换开销大。

〔NIO模型〕

JDK 1.4引入,核心组件:

  • Channel:双向通道(如FileChannel)
  • Buffer:缓冲区(如ByteBuffer)
  • Selector:多路复用器(单线程管理多连接)

【NIO服务端示例】

Selector selector = Selector.open();
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ssc.register(selector, SelectionKey.OP_ACCEPT);
while (selector.select() > 0) {
    Set keys = selector.selectedKeys();
    Iterator it = keys.iterator();
    while (it.hasNext()) {
        SelectionKey key = it.next();
        if (key.isAcceptable()) {  }
        if (key.isReadable()) {  }
        it.remove();
    }
}

〔AIO(异步IO)〕

JDK 7新增,基于事件驱动:

  • AsynchronousSocketChannel:异步通道
  • CompletionHandler:回调处理

适用于高吞吐量、低延迟场景(如游戏服务器),但API复杂度较高。

07 反射机制与注解

〔反射核心API〕

  • Class.forName("com.example.User"):加载类
  • Class.getDeclaredMethods():获取方法
  • Method.invoke(obj, args):动态调用
  • Constructor.newInstance():动态创建对象

【性能影响】

反射比直接调用慢100倍以上,但JDK 8+通过MethodHandle优化至5~10倍差距。建议:

  • 仅在框架开发中使用反射(如Spring IOC)
  • 缓存反射结果(Method/Field对象)
  • 避免在热点路径中使用

〔注解处理器〕

自定义注解需配合处理器使用:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Loggable {
    String value() default "";
}

运行时处理:

public class LogInterceptor {
    public static void intercept(Object obj, Method method, Object[] args) {
        if (method.isAnnotationPresent(Loggable.class)) {
            Loggable loggable = method.getAnnotation(Loggable.class);
            System.out.println("执行方法:" + method.getName() + ",参数:" + Arrays.toString(args));
        }
    }
}

08 Spring生态全景

〔Spring核心模块〕

Spring Core

  • IOC容器:依赖注入(@Autowired/@Value)
  • AOP代理:JDK动态代理/CGLIB
  • 资源管理:Resource抽象层

Spring Boot

  • 自动配置:@ConditionalOnClass
  • 起步依赖:简化Maven配置
  • 内嵌Tomcat:无需外部部署

Spring Cloud

  • 服务治理:Eureka/Nacos
  • 负载均衡:Ribbon
  • 熔断降级:Sentinel/Hystrix

〔事务管理机制〕

声明式事务(@Transactional)核心属性:

  • propagation:传播行为(REQUIRED/REQUIRES_NEW等)
  • isolation:隔离级别(READ_COMMITTED/REPEATABLE_READ)
  • rollbackFor:指定异常回滚
  • timeout:超时控制

【常见陷阱】

  • 同类方法调用导致代理失效(需通过self-invocation或@Lazy注入)
  • 异常被catch捕获但未抛出(事务不回滚)
  • 数据库引擎不支持事务(如MySQL MyISAM)

09 JVM运行时详解

〔内存区域模型〕

区域作用异常GC影响
程序计数器当前线程执行字节码行号无否
虚拟机栈方法调用栈帧(局部变量表/操作数栈)StackOverflowError否
本地方法栈Native方法调用StackOverflowError否
堆对象实例存储区OutOfMemoryError是(主要GC区域)
方法区类元数据/常量/静态变量OutOfMemoryError部分(JDK8后为元空间)

〔垃圾回收机制〕

【垃圾判定算法】

  • 引用计数法:循环引用问题(已淘汰)
  • 可达性分析:GC Roots根节点遍历(Java主流)

【GC Roots包括】

  • 虚拟机栈中引用的对象
  • 方法区中类静态属性引用的对象
  • 方法区中常量引用的对象
  • 本地方法栈中JNI引用的对象

【垃圾回收算法】

  • 标记-清除:产生内存碎片
  • 复制算法:新生代(Eden/Survivor)
  • 标记-整理:老年代(减少碎片)

〔JVM调优参数〕

java -Xms2g -Xmx2g \
     -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/logs/heap.hprof \
     -jar app.jar

【调优原则】

  1. 优先保证GC停顿时间(P99 < 500ms)
  2. 堆大小 = 常驻内存 × 2(避免频繁扩容)
  3. 监控指标:GC频率、停顿时间、内存占用率

10 企业级项目实战

〔典型项目架构〕

需求分析

用户故事地图(User Story Mapping)

技术选型

Spring Boot 2.7 + MyBatis-Plus + Redis + Elasticsearch + RabbitMQ

核心功能

用户认证(JWT)、权限控制(RBAC)、商品搜索(ES)、异步任务(RabbitMQ)

性能优化

数据库索引优化、缓存穿透/击穿/雪崩防护、热点数据预热

部署运维

Docker容器化 + Kubernetes编排 + Prometheus监控

〔高频面试题示例〕

Q:Java内存模型(JMM)核心规则是什么?

A:JMM通过happens-before规则定义操作间的可见性,包括:

  • 程序顺序规则:线程内代码按顺序happens-before
  • 监视器锁规则:unlock() happens-before后续lock()
  • volatile变量规则:写 happens-before 读
  • 线程启动规则:start() happens-before 新线程执行
  • 线程终止规则:线程内操作 happens-before join()

Q:为什么HashMap线程不安全?

A:三方面原因:

  • 扩容时多线程导致链表死循环(JDK7)
  • put操作覆盖其他线程数据
  • size计数非原子操作

11 网友们还关心的问题

Q:Java和Python在Web开发中的对比?

A:Java适合高并发、强事务性系统(如银行、电商),优势在于生态成熟、性能稳定;Python适合快速开发、数据处理(如爬虫、AI),语法简洁但高并发需配合异步框架(如FastAPI+Uvicorn)。实际项目中常采用Java做后端服务,Python做数据分析子系统。

Q:如何选择IDE?

A:推荐IntelliJ IDEA(社区版免费+Ultimate付费),优势:智能代码补全、强大调试器、内置Maven/Gradle、Git集成;Eclipse内存占用高、插件兼容性差;VS Code适合轻量级开发(需手动配置插件)。

Q:Java学习路线图?

A:

  1. 基础语法(1~2周)
  2. OOP与设计模式(2~3周)
  3. 集合/IO/多线程(3~4周)
  4. Web基础(Servlet/JSP,1周)
  5. Spring生态(3~4周)
  6. 数据库(JDBC/MyBatis,2周)
  7. 项目实战(2~4周)

12 扩展学习资源

〔官方文档〕

  • Java SE API:https://docs.oracle.com/en/java/javase/
  • Spring官方文档:https://spring.io/projects/spring-framework
  • OpenJDK源码:https://github.com/openjdk/jdk

〔开源项目推荐〕

Spring Boot

快速开发微服务的脚手架,内置自动配置与起步依赖。

MyBatis-Plus

简化CRUD操作的ORM框架,无侵入、轻量级。

Lombok

通过注解减少样板代码(@Data/@Getter/@Setter)。

〔学习社区〕

  • Stack Overflow:https://stackoverflow.com/questions/tagged/java
  • 掘金:https://juejin.cn/frontend/java
  • 知乎专栏:Java技术栈