┌─────────────────────────────────────────────┐
│                    JDK                      │
│  ┌───────────────────────────────────────┐  │
│  │                JRE                    │  │
│  │  ┌─────────────────────────────────┐  │  │
│  │  │              JVM                │  │  │
│  │  │  - 类加载子系统 ClassLoader     │  │  │
│  │  │  - 运行时数据区（堆/栈/方法区） │  │  │
│  │  │  - 执行引擎（解释器/JIT/GC）    │  │  │
│  │  └─────────────────────────────────┘  │  │
│  │  + Java 核心类库（rt / java.base 等） │  │
│  └───────────────────────────────────────┘  │
│  + 编译器 javac、打包 jar、javadoc          │
│  + 诊断工具 jps / jstack / jmap / jcmd      │
│  + 交互式工具 jshell                        │
└─────────────────────────────────────────────┘

:: 1. 从 https://adoptium.net 下载 Temurin 21 (Windows x64) 的 .msi 安装包
:: 2. 双击安装，默认路径通常是：
::    C:\Program Files\Eclipse Adoptium\jdk-21.0.x-hotspot\
:: 3. 验证安装（打开新的 CMD 或 PowerShell，注意必须是新窗口）
java -version
javac -version

:: 4. winget 方式（可选，需管理员权限）
winget search EclipseAdoptium.Temurin.21.JDK
winget install EclipseAdoptium.Temurin.21.JDK

# 方式一：Homebrew（推荐，便于版本管理）
brew install openjdk@21

# Homebrew 安装的 JDK 不会自动软链到系统目录，需要手动做一次
sudo ln -sfn /opt/homebrew/opt/openjdk@21/libexec/openjdk.jdk \
             /Library/Java/JavaVirtualMachines/openjdk-21.jdk

# Apple Silicon 芯片是 /opt/homebrew，Intel 芯片是 /usr/local
java -version

# 方式二：下载 .pkg 安装包
# https://adoptium.net 选择 macOS / aarch64 (M 系列) 或 x64 (Intel)
# 安装后位于 /Library/Java/JavaVirtualMachines/jdk-21.jdk/Contents/Home

# 列出机器上所有已安装的 JDK
/usr/libexec/java_home -V

# 输出示例：
# Matching Java Virtual Machines (3):
#     21.0.5 (arm64) "Eclipse Adoptium" - /Library/Java/JavaVirtualMachines/temurin-21.jdk/Contents/Home
#     17.0.9 (arm64) "Eclipse Adoptium" - /Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home
#     1.8.0_392 (x86_64) "Oracle" - /Library/Java/JavaVirtualMachines/jdk8.jdk/Contents/Home

# 动态获取指定版本的 JAVA_HOME（写进 ~/.zshrc 的金标准写法）
export JAVA_HOME=$(/usr/libexec/java_home -v 21)
export PATH=$JAVA_HOME/bin:$PATH

# Ubuntu / Debian（apt）
sudo apt update
sudo apt install openjdk-21-jdk        # 只装运行时用 openjdk-21-jre-headless
java -version

# CentOS / Rocky / AlmaLinux（yum / dnf）
sudo dnf install java-21-openjdk-devel

# 多版本共存时切换系统默认 JDK（Debian 系）
sudo update-alternatives --config java
sudo update-alternatives --config javac

# 手动安装：下载 tar.gz 解压到统一目录
sudo mkdir -p /usr/local/java
sudo tar -zxvf OpenJDK21U-jdk_x64_linux_hotspot_21.0.5_11.tar.gz -C /usr/local/java
export JAVA_HOME=/usr/local/java/jdk-21.0.5+11
export PATH=$JAVA_HOME/bin:$PATH

# CLASSPATH 典型写法（Linux/macOS 用冒号分隔，Windows 用分号分隔）
export CLASSPATH=.:$JAVA_HOME/lib/tools.jar:./lib/*

# 现代写法：JDK 9 之后 tools.jar 已被移除，且强烈不建议设置全局 CLASSPATH
# 推荐用 -cp 参数在运行时显式指定，作用域可控
java -cp "target/classes:lib/*" com.example.Main

# ========== SDKMAN ==========
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

sdk list java                 # 列出所有可安装版本
sdk install java 21.0.5-tem   # 安装指定版本
sdk install java 17.0.9-tem
sdk use java 17.0.9-tem       # 当前 shell 会话切换到 17
sdk default java 21.0.5-tem   # 设置全局默认版本

# ========== jenv ==========
brew install jenv
jenv add /Library/Java/JavaVirtualMachines/temurin-21.jdk/Contents/Home
jenv add /Library/Java/JavaVirtualMachines/temurin-8.jdk/Contents/Home
jenv versions
jenv global 21                # 全局默认
jenv local 1.8                # 当前目录写 .java-version，进入目录自动切到 8

# ========== 手工切换（macOS / Linux，写进 ~/.zshrc）==========
# 定义函数而不是写死变量，随时可切
jdk() {
    version=$1
    export JAVA_HOME=$(/usr/libexec/java_home -v"$version")
    export PATH=$JAVA_HOME/bin:$PATH
    java -version
}
# 使用：jdk 8  /  jdk 17  /  jdk 21

// HelloWorld.java
// 注意：public 类的名字必须与文件名完全一致（含大小写），这是 Java 的强制规定
public class HelloWorld {
    // main 方法是 JVM 的入口约定，签名必须严格为：public static void main(String[] args)
    public static void main(String[] args) {
        System.out.println("Hello, Java 21!");
        // 打印当前 JVM 的关键信息，验证跑的到底是不是你期望的那个 JDK
        System.out.println("Java version: " + System.getProperty("java.version"));
        System.out.println("JAVA_HOME 之外，JVM 实际路径: " + System.getProperty("java.home"));
        System.out.println("当前类路径: " + System.getProperty("java.class.path"));
    }
}

# 1. 编译：javac 把 .java 源文件翻译成 .class 字节码文件
javac HelloWorld.java

# 2. 查看产物
ls -l
# HelloWorld.java   HelloWorld.class

# 3. 运行：注意 java 命令后面跟的是"类名"，不是文件名，绝不能写 .class 后缀
java HelloWorld

# 输出：
# Hello, Java 21!
# Java version: 21.0.5
# JAVA_HOME 之外，JVM 实际路径: /Library/Java/JavaVirtualMachines/temurin-21.jdk/Contents/Home
# 当前类路径: .

源码字符流
   ↓ ① 词法分析（Lexer / Scanner）
Token 流（关键字、标识符、字面量、运算符）
   ↓ ② 语法分析（Parser）
抽象语法树 AST
   ↓ ③ 符号表填充（Enter）
   ↓ ④ 注解处理（Annotation Processing，可多轮循环）
   ↓ ⑤ 语义分析与标注检查（Attribute：类型检查、方法重载解析）
   ↓ ⑥ 数据流分析与语法糖解糖（Flow / Desugar：泛型擦除、拆装箱、Lambda、增强 for、switch 字符串）
   ↓ ⑦ 字节码生成（Generate）
.class 字节码文件

# 查看 class 文件头 16 字节
xxd -l 16 HelloWorld.class
# 00000000: cafe babe 0000 0041 0034 0a00 0200 0307  .......A.4......

# 更友好的方式：javap 反编译
javap -c -p HelloWorld.class

# 查看常量池与完整字节码助记符
javap -v HelloWorld.class

# 只看方法签名（不含字节码）
javap HelloWorld.class

# 反编译出接近 Java 源码的伪代码（需第三方工具 CFR / Procyon / Fernflower）
java -jar cfr.jar HelloWorld.class

// javap -c 输出的 main 方法字节码（节选），逐条解读
public static void main(java.lang.String[]);
  Code:
     0: getstatic     #7   // Field java/lang/System.out:Ljava/io/PrintStream;
     3: ldc           #13  // String Hello, Java 21!     ← 从常量池加载常量入栈
     5: invokevirtual #15  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
     8: return

# 一次规范的编译命令（真实项目手工编译写法）
javac -encoding UTF-8 -parameters -Xlint:all \
      -d target/classes \
      -cp "lib/*" \
      $(find src/main/java -name "*.java")

# 交叉编译：用 JDK 21 编出 JDK 8 能跑的字节码
javac --release 8 -d out HelloWorld.java

# 单文件源码直接运行（JDK 11+），不产生 .class 文件，适合快速验证
java HelloWorld.java

# 打印类加载来源，排查"到底加载了哪个 jar 里的类"
java -verbose:class -cp "lib/*" com.example.Main | grep "com.example"

// 重载的静态分派：编译期就按"声明类型"选定了方法，与对象实际类型无关
public class DispatchDemo {
    static void say(Object o) { System.out.println("Object"); }
    static void say(String s) { System.out.println("String"); }

    public static void main(String[] args) {
        Object obj = "hello";   // 声明类型是 Object，实际类型是 String
        say(obj);               // 输出 Object，不是 String
    }
}

  加载 Loading          链接 Linking                    初始化 Initialization
┌──────────────┐   ┌──────────────────────────┐   ┌──────────────────────┐
│ 通过全限定名  │   │ 验证 Verify：            │   │ 执行 <clinit>()      │
│ 获取二进制流  │ → │ 魔数/版本/字节码合法性   │ → │ 静态变量赋值         │
│ 转为方法区内  │   │ 准备 Prepare：           │   │ 静态代码块执行       │
│ 的数据结构    │   │ 静态变量分配内存并置零值 │   │ 父类先于子类初始化   │
│ 生成 Class 对象│  │ 解析 Resolve：           │   │ JVM 保证线程安全加锁 │
└──────────────┘   │ 符号引用→直接引用        │   └──────────────────────┘
                   └──────────────────────────┘

public class InitDemo {
    public static void main(String[] args) {
        // ① 通过子类引用父类的静态字段：只有父类初始化，子类不初始化
        System.out.println(Sub.value);

        // ② 通过数组定义引用类：不触发类初始化，JVM 自动生成数组类
        Super[] arr = new Super[10];

        // ③ 引用编译期常量（static final + 字面量）：不触发初始化
        //    因为常量在编译期就已经被"常量传播"进调用方的常量池了
        System.out.println(Const.MESSAGE);
    }
}

// 场景：一个 10 万次的循环里，只有第 8888 次的数据有问题
// 条件断点表达式示例（直接写在这行左侧的断点上）：
//   i == 8888 && user != null && user.getAge() > 100
// 或者用断点命中次数：右键断点 → 勾选 "Pass count" 填 8888
for (int i = 0; i < list.size(); i++) {
    process(list.get(i));
}

# 远端启动（JDK 5-8 写法）
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 -jar app.jar

# JDK 9+ 必须指定 address 的主机名，否则只能本机连接；*:5005 表示允许任意网卡
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 -jar app.jar

# 参数说明：
#   transport=dt_socket  使用 socket 通信
#   server=y             本 JVM 作为被调试的服务端（等待 IDE 连入）
#   suspend=n            启动后不挂起，立即运行（设为 y 则会卡住等调试器连上再继续，
#                        适合调试"启动阶段"的代码）
#   address=*:5005       监听端口

$ jshell
|  欢迎使用 JShell -- 版本 21.0.5
jshell> int x = 10
x ==> 10

jshell> x * 2
$2 ==> 20

jshell> String s = new String("abc").intern()
s ==> "abc"

jshell> s == "abc"
$4 ==> true        // 验证字符串常量池行为，秒懂 intern()

jshell> var list = List.of(1, 2, 3)
list ==> [1, 2, 3]

jshell> /vars       // 列出所有定义的变量
jshell> /methods    // 列出所有定义的方法
jshell> /imports    // 查看已导入的包
jshell> /edit       // 打开编辑器批量修改
jshell> /save a.jsh // 保存会话
jshell> /open a.jsh // 加载会话
jshell> /exit

# 一条龙排查 CPU 飙高的标准流程
jps -l                          # 1. 找到 Java 进程 PID
top -Hp <pid>                   # 2. 找出占用 CPU 最高的线程 ID（十进制）
printf "%x\n" <tid>             # 3. 转成十六进制，如 1a2b
jstack <pid> | grep -A 20 "nid=0x1a2b"   # 4. 定位到具体代码行

# 用 jcmd 一把梭（JDK 推荐替代 jstack/jmap 的统一入口）
jcmd <pid> Thread.print         # 等价于 jstack
jcmd <pid> GC.heap_info         # 堆概要
jcmd <pid> VM.system_properties # 查看所有系统属性
jcmd <pid> help                 # 列出该 JVM 支持的所有命令

// 文件路径必须是：src/com/example/demo/UserService.java
package com.example.demo;

// 单类型导入：精确，推荐。IDEA 默认策略
import java.util.List;
import java.util.ArrayList;

// 按需导入：导入整个包下所有 public 类型
import java.util.*;
// 注意：按需导入只是"编译期省事"，不会增加运行期开销，
// 但会降低可读性并可能引入歧义，大型项目通常禁用

// 静态导入：可以直接用静态成员而不写类名
import static java.lang.Math.PI;
import static java.util.Arrays.asList;

public class UserService {
    // 全限定名（Fully Qualified Name）= 包名 + 类名
    // com.example.demo.UserService
    private List<String> names = new ArrayList<>(asList("Tom", "Jerry"));

    public double area(double r) {
        return PI * r * r;   // 静态导入后可直接用 PI
    }

    // 两个包都有同名类时，必须用全限定名消歧义
    public void ambiguous() {
        java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis());
        java.util.Date utilDate = new java.util.Date();
    }
}

// 文件路径：src/main/java/module-info.java
module com.example.app {
    // requires：声明本模块依赖哪些模块（传递性依赖需用 requires transitive）
    requires java.base;          // 隐式依赖，可省略（所有模块自动依赖 java.base）
    requires java.sql;           // 依赖 JDK 的 java.sql 模块
    requires transitive com.example.core;  // 传递依赖：依赖本模块的模块自动获得 com.example.core
    requires static com.example.optional;  // 编译期需要，运行期可选

    // exports：把本模块的哪些包暴露出去（不 export 的包外部完全不可见）
    exports com.example.app.api;
    exports com.example.app.spi to com.example.plugin;  // 限定导出给指定模块

    // opens：允许运行期反射访问（Spring/MyBatis/Hibernate 这类框架需要）
    opens com.example.app.entity;
    // 更宽松：整个模块开放反射
    // open module com.example.app { ... }

    // uses：声明本模块使用某个服务接口（配合 ServiceLoader 实现 SPI）
    uses com.example.spi.Parser;
    // provides ... with ...：声明本模块提供服务实现
    provides com.example.spi.Parser with com.example.app.JsonParser;
}

# 打包：c=create, v=verbose, f=file, -C 先切换目录再打包（避免把绝对路径打进去）
jar cvf app.jar -C target/classes .

# 指定主类（Main-Class），让 jar 可直接执行
# e 选项会自动在 MANIFEST.MF 中写入 Main-Class
jar cvfe app.jar com.example.Main -C target/classes .

# 查看 jar 内容
jar tf app.jar

# 解压
jar xf app.jar

# 查看清单文件
unzip -p app.jar META-INF/MANIFEST.MF

# 方式一：MANIFEST 声明 Class-Path（依赖放在 jar 同级的 lib/ 目录）
# MANIFEST.MF 内容：
# Manifest-Version: 1.0
# Main-Class: com.example.Main
# Class-Path: lib/gson-2.10.jar lib/commons-lang3-3.12.0.jar
java -jar app.jar

# 方式二：classpath 通配符（注意 * 必须加引号，防止被 shell 展开）
java -cp "app.jar:lib/*" com.example.Main      # Linux / macOS
java -cp "app.jar;lib\*" com.example.Main      # Windows（分隔符是分号）

# 方式三：模块化运行
java --module-path mods -m com.example.app/com.example.Main

# 常见排错参数
java -verbose:class -jar app.jar    # 打印每个类的加载来源

my-app/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/           # 主源码（会自动编译）
│   │   ├── resources/      # 主资源（会被复制到 classpath 根，如 application.yml）
│   │   └── webapp/         # Web 应用根目录（仅 war 工程）
│   └── test/
│       ├── java/           # 测试源码（仅测试阶段编译，不进生产包）
│       └── resources/      # 测试资源
└── target/                 # 构建输出目录（mvn clean 会删掉整个目录）
    ├── classes/            # 编译后的 .class
    ├── test-classes/       # 测试编译产物
    ├── surefire-reports/   # 测试报告
    └── my-app-1.0.0.jar    # 打包产物

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                             https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- POM 模型版本，固定 4.0.0，几乎不改 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 本项目坐标 -->
    <groupId>com.example</groupId>
    <artifactId>demo-app</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <!-- 属性：集中管理版本号，避免到处硬编码 -->
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <maven.compiler.release>21</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <gson.version>2.10.1</gson.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>${gson.version}</version>
        </dependency>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.10.2</version>
            <scope>test</scope>
        </dependency>

        <!-- 排除传递依赖：解决版本冲突、剔除不需要的间接依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.2.5</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <finalName>demo-app</finalName>
        <plugins>
            <!-- 指定编译版本，避免每次都用默认 1.5 的老版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.13.0</version>
                <configuration>
                    <release>21</release>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

<!-- 导入 Spring Boot BOM，之后声明 starter 无需写 version -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>3.2.5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- 版本由上面的 BOM 决定，无需写 <version> -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

项目 A
├── B:1.0  ──────→  C:1.0
└── D:1.0  ──→ E:1.0 ──→ C:2.0

路径：A → B → C:1.0   深度 2
     A → D → E → C:2.0  深度 3
结果：C:1.0 胜出（最短路径优先）

# 查看依赖树，排查冲突的第一手段
mvn dependency:tree

# 只看冲突（被仲裁掉的依赖会标 omitted for conflict）
mvn dependency:tree -Dverbose

# 找出哪些依赖被声明但未使用 / 使用了但未声明
mvn dependency:analyze

# 强制把某个版本固定下来（比 exclusions 更省心）

<!-- 方式一：dependencyManagement 锁定版本（推荐，对所有传递依赖生效） -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.17.1</version>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- 方式二：exclusions 排除掉不想要的那条传递路径 -->
<dependency>
    <groupId>com.example</groupId>
    <artifactId>some-lib</artifactId>
    <version>1.0</version>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

validate → compile → test → package → verify → install → deploy
   ↓          ↓        ↓        ↓        ↓        ↓         ↓
校验项目   编译主源  跑单元  打成jar/  集成测试  安装到本地  发布到
结构完整性   码      测试     war      质量检查   仓库      远程仓库

# 日常开发最常用的完整命令（带常用参数）
mvn -U clean install -DskipTests -B

# 多模块项目只构建指定模块及其依赖
mvn -pl user-service -am clean install

# 打印有效 POM（所有父 POM、BOM 合并后的最终配置），排查"这个配置到底从哪来"
mvn help:effective-pom

# 查看当前项目的可用插件与版本
mvn help:describe -Dplugin=compiler -Ddetail

# 加速：配置国内镜像（~/.m2/settings.xml）
# <mirror>
#   <id>aliyun</id>
#   <mirrorOf>central</mirrorOf>
#   <name>Aliyun Maven</name>
#   <url>https://maven.aliyun.com/repository/public</url>
# </mirror>

// 三种错误的触发代码示例，对照理解
public class ErrorDemo {
    public static void main(String[] args) throws Exception {
        // ① ClassNotFoundException：受检异常，必须 catch 或 throws
        //    类名必须是全限定名，写成 "Driver" 一定找不到
        Class<?> c = Class.forName("com.mysql.cj.jdbc.Driver");

        // ② NoClassDefFoundError 的典型场景：
        //    编译时 servlet-api 在（scope=provided），
        //    但用 java -jar 直接跑时 Tomcat 不在，HttpServletRequest 类缺失
        // HttpServletRequest req = ...;   ← 运行到这里才炸

        // ③ NoClassDefFoundError 的另一个隐蔽成因：静态初始化失败
        try {
            new BadStatic();
        } catch (Throwable t) {
            System.out.println("第一次： " + t);   // ExceptionInInitializerError
        }
        try {
            new BadStatic();
        } catch (Throwable t) {
            System.out.println("第二次： " + t);   // NoClassDefFoundError
        }
    }
}

class BadStatic {
    static int value = 1 / 0;   // 静态初始化抛异常 → 类被 JVM 标记为错误状态
}                               // 后续任何使用都直接 NoClassDefFoundError

# 一套标准的环境自检脚本，出问题先跑一遍
echo "=== 1. JAVA_HOME ==="
echo $JAVA_HOME          # Windows: echo %JAVA_HOME%

echo "=== 2. 实际生效的命令位置（可能有多个） ==="
which -a java javac mvn  # Windows: where java javac mvn

echo "=== 3. 版本一致性（javac 与 java 必须一致） ==="
javac -version
java -version

echo "=== 4. Maven 实际使用的 JDK（最容易不一致的地方） ==="
mvn -version
# 输出里有一行：Java version: 21.0.5, vendor: Eclipse Adoptium,
#              runtime: /Library/Java/JavaVirtualMachines/.../Contents/Home

echo "=== 5. 编码 ==="
locale                   # Windows: chcp（936=GBK，65001=UTF-8）