从语言核心到企业级

public class Main {                    // 类 = 一切代码的容器
    public static void main(String[] args) {   // 入口方法
        System.out.println("你好，Java！");
    }
}
// Python: print("你好，Python！") —— 看到差距了吧：Java 仪式感十足

// 面向对象四件套速览
class Account {                          // 封装：属性私有
    private double balance;
    public void deposit(double v) { balance += v; }   // 方法公开
}

interface Payable { void pay(double v); }   // 接口：多态的地基
class CreditCard implements Payable { ... } // 实现接口

// 集合框架（后端日常）
List<String> names = new ArrayList<>();   // 有序
Set<Long> ids = new HashSet<>();          // 去重
Map<String, Integer> scores = new HashMap<>();  // 键值

// 泛型：一套代码多种类型（第一本的老朋友）
List<Account> accounts = new ArrayList<>();

// 异常：try/catch/finally（第一本老朋友）
try { risky(); } catch (IOException e) { log(e); } finally { cleanup(); }

┌────────────── JVM 内存 ──────────────┐
│ 堆 Heap（对象）：新生代 + 老年代        │ ← GC 主战场
│  新生代：伊甸园 Eden → 幸存区 S0/S1    │   大部分对象朝生夕死
│  老年代：熬过多次 GC 的对象            │
│ 栈 Stack（每线程）：局部变量/方法帧     │ ← 溢出=递归太深
│ 方法区/元空间：类信息/静态变量/常量     │
└─────────────────────────────────────┘

【调优参数（-X 家族）】
  -Xms2g -Xmx2g     初始/最大堆（生产要相等，防抖动）
  -Xss512k          栈大小
  -XX:+UseG1GC      用 G1（默认）
  -XX:MaxGCPauseMillis=100   GC 停顿目标

【GC 触发与回收器】
  新生代满 → Minor GC（快）
  老年代满 → Full GC（慢，卡顿元凶）
  G1：把堆分成 Region，优先回收「垃圾最多」的区域
  ZGC：并发回收，停顿 < 10ms（超大堆场景）

【OOM 与排查（第9站展开）】
  OutOfMemoryError: Java heap space   堆满了
  GC overhead limit exceeded          回收太多次还满

【Java 与 Python 内存对比】
  Python：引用计数 + 分代 GC（CPython 的痛）
  Java：可达性分析 + 成熟的分代 GC——大厂后端首选

// 线程池：复用线程，控制并发度
ThreadPoolExecutor pool = new ThreadPoolExecutor(
    10,                  // 核心线程数：常驻 10 个
    50,                  // 最大线程数：高峰 50 个
    60, TimeUnit.SECONDS,// 空闲回收时间
    new ArrayBlockingQueue<>(100),   // 任务队列：缓冲
    new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
);

// 同步：synchronized vs Lock
synchronized (lock) { balance -= amount; }        // 简单内置锁

Lock lock = new ReentrantLock();
if (lock.tryLock(3, TimeUnit.SECONDS)) {          // 可超时！
    try { balance -= amount; } finally { lock.unlock(); }
}

// volatile：可见性（不加锁的轻量同步）
volatile boolean running = true;   // 多线程都能看到最新值

// 并发容器：高并发安全的「武器库」
ConcurrentHashMap<String, Integer> cache = new ConcurrentHashMap<>();
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

【CAS vs AQS（底层）】
  CAS：Compare And Swap——无锁比较交换（乐观锁）
  AQS：抽象同步队列——ReentrantLock/Semaphore 的骨架

【四大并发问题】
  原子性（加锁）· 可见性（volatile）· 有序性（指令重排）
  死锁（两个线程互相等对方的锁——排查靠 dump）

【BIO：一连接一线程】
  Thread1 ← 连接1（阻塞等待数据）
  Thread2 ← 连接2
  Thread3 ← 连接3
  → 10000 连接 = 10000 线程 = 内存爆炸

【NIO：一线程多连接（Selector）】
  Thread ← Selector（多路复用器）← 连接1/2/3...
  事件驱动：哪个连接有数据，处理哪个
  → 10000 连接 = 1 个线程搞定（事件模型）

【Netty 架构（重点概念）】
  Channel：一条连接
  EventLoop：事件循环线程（一个 EventLoop 管多个 Channel）
  Pipeline：处理器链（入站/出站 Handler）
  ChannelHandler：业务处理器（编解码/业务逻辑）
  编解码器：ByteBuf 与对象的互转（Protobuf/JSON）

【Netty 的应用】
  Dubbo（RPC）、RocketMQ（消息）、Spark（网络通信）
  → 学 Netty = 看懂半个中间件源码

【对比 Python】
  Python asyncio 也是事件驱动——思路一样（第九本 Flink 的背压也是同源）

浏览器 → GET /api/account/100
   ↓
Tomcat（Web 容器，监听 8080）
   ↓ 解析 HTTP 请求
Filter 链（安检门：登录校验 → 编码 → 日志）
   ↓ 通过
Servlet（业务处理）
   ↓ 调用 Service/DAO → 数据库
   ↓ 返回 JSON
Tomcat 打包 HTTP 响应 → 浏览器

【Servlet 核心（简版）】
public class AccountServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        Long id = Long.parseLong(req.getParameter("id"));
        Account account = accountService.findById(id);
        writeJson(resp, account);           // 返回 JSON
    }
}

【Servlet 生命周期（面试必问）】
  加载 → 实例化 → init（一次）→ service（每次请求）
  → destroy（销毁）——容器全包，程序员只写业务

【Filter 用法】
  doFilter 里：before 处理（校验）→ chain.doFilter（放行）→ after（日志）

【Tomcat 核心参数】
  线程池（maxThreads）、连接数（acceptCount）
  连接器协议：BIO（老）/ NIO（现代，第4站知识）

@SpringBootApplication          // 启动类：自动配置全开
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

@RestController                   // Controller 层：接请求
@RequestMapping("/api/accounts")
public class AccountController {
    @Autowired                   // DI：依赖注入，不用自己 new
    private AccountService service;

    @GetMapping("/{id}")
    public Account get(@PathVariable Long id) {
        return service.findById(id);
    }
}

@Service                         // Service 层：业务逻辑
public class AccountService { ... }

@Repository                      // DAO 层：数据库（第7站）
public interface AccountMapper { ... }

【IoC 与 AOP 一句话】
  IoC：对象生命周期交给容器——你要啥我给你啥
  AOP：横切逻辑（日志/事务）织入——业务代码不掺杂质

【Spring Boot 魔法】
  内嵌 Tomcat → 一个 jar 直接跑（不用装容器！）
  自动配置 → 引入依赖即生效
  application.yml → 集中配置（第4站 K8s ConfigMap 喂给它）

【Spring Cloud 微服务（衔接第11本）】
  Nacos/Eureka 注册中心 · Gateway 网关 · OpenFeign 调用
  Sentinel 熔断限流 · Config 配置中心 → 微服务全家桶

@Mapper
public interface AccountMapper {
    @Select("SELECT * FROM accounts WHERE id = #{id}")
    Account findById(Long id);
}

// 事务：转账 = 扣 A + 加 B，必须一起成功
@Service
public class TransferService {
    @Transactional            // 事务边界：失败全回滚
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        accountMapper.debit(fromId, amount);   // 扣款
        accountMapper.credit(toId, amount);    // 加款
        // 任一失败 → 全部回滚，钱不会消失
    }
}

// 乐观锁：库存扣减（防超卖，第3站并发知识落地）
@Update("UPDATE products SET stock = stock - 1, version = version + 1 " +
        "WHERE id = #{id} AND stock > 0 AND version = #{version}")
int deductStock(Long id, int version);   // 影响行数=0 说明冲突，重试

【ORM 二选一】
  MyBatis：SQL 自己写（灵活、国内主流）
  JPA/Hibernate：实体自动映射（开发快、国外主流）

【连接池参数】
  maximumPoolSize（最大连接）、connectionTimeout（获取超时）
  → 连接池耗尽 = 数据库扛不住的第一个信号

【慢查询排查】
  数据库慢查询日志 + EXPLAIN 看索引（第八本老朋友）

<!-- Maven pom.xml：依赖声明 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- mvn clean package → 一个可运行 jar -->

// JUnit 单元测试
class TransferServiceTest {
    @Test
    void transfer_should_deduct_and_credit() {
        // given / when / then 三段式
        service.transfer(1L, 2L, new BigDecimal("100"));
        assertEquals(new BigDecimal("-100"), accountMapper.balance(1L));
    }
}

// 日志（SLF4J 门面）
private static final Logger log = LoggerFactory.getLogger(AccountService.class);
log.info("查询账户 id={}", id);          // 生产排障靠它
log.error("转账失败 from={} to={}", fromId, toId, e);

【部署链（现代 Java 应用）】
  源码 → Maven 构建 → jar 包 → Docker 镜像
  → 镜像仓库 → K8s 部署（第13本老朋友）
  → 日志进 ELK（第12本老朋友）→ 监控告警
  → 全链路自动化：CI/CD（第2本老朋友）

【Java 版本选择（2026）】
  LTS 版本是王道：Java 17（现役主流）/ Java 21（新 LTS）
  每半年一个非 LTS，别追新——生产用 LTS

【IDE 与效率】
  IntelliJ IDEA（事实标准）· Lombok 省样板代码
  代码规范：阿里巴巴 Java 开发手册（国内事实标准）

【兵器库】
  jps / jstat    ：看进程 / JVM 状态（GC 频率、堆使用）
  jmap           ：导出堆 dump（OOM 分析）
  jstack         ：线程 dump（死锁/热点线程）
  jcmd / jinfo   ：诊断 / 看启动参数
  Arthas         ：线上神兵——方法耗时/反编译/热更新
  可视化：VisualVM / JProfiler / MAT（堆分析）

【OOM 排查七步（实战流程）】
  ① 启动参数加 -XX:+HeapDumpOnOutOfMemoryError（自动留证据）
  ② 等 OOM → 拿到 dump 文件
  ③ MAT/VisualVM 打开 → 看「Dominator Tree」（谁占内存）
  ④ 定位大对象/泄漏点（缓存无限涨？连接没关？）
  ⑤ 修代码（限流缓存/close 资源/分批加载）
  ⑥ 压测验证不再 OOM
  ⑦ 加监控（堆使用率告警，第12本 ELK 老朋友）

【接口慢排查口诀】
  先看数据库慢查询 → 再看连接池 → 再看锁等待
  → 再看 GC 频率 → 最后看代码热点（Arthas trace）

【JVM 调优参数清单（生产标配）】
  -Xms = -Xmx（防抖动）· -XX:+UseG1GC · 最大停顿目标
  -XX:+HeapDumpOnOutOfMemoryError（必加！）
  -XX:MetaspaceSize（元空间初始值）

// ① record：不可变数据类（一行顶十行）
public record Order(Long id, BigDecimal amount) {}
Order o = new Order(1L, new BigDecimal("99.9"));
o.id();                                  // 自动有访问器，不用写 getter

// ② switch 表达式（更简洁）
String level = switch (score / 10) {
    case 9, 10 -> "A";
    case 7, 8  -> "B";
    default    -> "C";
};

// ③ 文本块（多行字符串）
String sql = """
    SELECT * FROM orders
    WHERE status = 'PAID'
    """;

// ④ sealed 密封类（限制继承范围）
public sealed interface Payable permits Card, Cash, Crypto {}
public record Card() implements Payable {}

【学习资源】
  书：《Java 核心技术》《Effective Java》《深入理解 Java 虚拟机》
  在线：廖雪峰 Java 教程、阿里巴巴 Java 开发手册
  练手：写一个「秒杀系统」（并发+事务+Redis 全家桶）
  刷题：LeetCode（面试算法关）

【职业方向（Java 后端）】
  CRUD 工程师 → 业务开发 → 中间件/基础架构 → 架构师
  Java 后端需求量大：银行/电商/政务/金融——中年危机？不存在的
  （大厂岗位：Java 开发、后端工程师、中间件开发、大数据开发）

【避坑清单】
  ✗ 只学语法不学 JVM（面试必挂）
  ✗ 不写项目光背八股（一问项目就露馅）
  ✗ 追新版本不用 LTS（生产事故）
  ✗ 忽略并发和事务（后端大忌）