階段一：Java 語言基礎(chǔ)（1-2 周）
├── 環(huán)境搭建（JDK + IDEA + Maven）
├── 基礎(chǔ)語法（變量、類型、控制流）
├── 面向?qū)ο螅悺⒔涌?、繼承、多態(tài)）
└── 進階特性（泛型、集合、異常、Lambda、Stream）

階段二：構(gòu)建工具與生態(tài)（3-5 天）
├── Maven / Gradle（類似 npm）
└── 依賴管理與項目結(jié)構(gòu)

階段三：核心框架（2-3 周）
├── Spring / Spring Boot（核心，類似 Express 全家桶）
├── MyBatis / MyBatis-Plus（操作數(shù)據(jù)庫，類似 ORM）
└── Spring MVC（寫接口）

階段四：實戰(zhàn)配套（持續(xù)）
├── 數(shù)據(jù)庫（MySQL）
├── Redis（緩存）
├── 接口測試（Postman）
└── 部署（Docker、服務(wù)器）

java -version
javac -version

// JavaScript
let name = "張三";
const age = 18;
var flag = true;
let num = 3.14;

// Java：必須先聲明類型
String name = "張三";        // 字符串
final int age = 18;          // final = JS 的 const
boolean flag = true;
double num = 3.14;

// Java 10+ 也支持類型推斷（但仍是靜態(tài)類型）
var city = "北京";  // 編譯器自動推斷為 String

// 整數(shù)類
byte  b = 1;        // 1字節(jié)
short s = 2;        // 2字節(jié)
int   i = 100;      // 4字節(jié)，最常用
long  l = 100L;     // 8字節(jié)，注意加 L

// 浮點
float  f = 1.5f;    // 注意加 f
double d = 3.14;    // 最常用的小數(shù)類型

// 其他
char    c = 'A';    // 單個字符，用單引號
boolean flag = true;

// JS
let s = "hello";
let str = `你好 ${name}`;       // 模板字符串
let len = s.length;            // 屬性

// Java：String 是一個類，length() 是方法
String s = "hello";
int len = s.length();           // 注意是方法，要括號

// 拼接
String str = "你好 " + name;

// Java 15+ 文本塊（類似模板字符串的多行）
String json = """
    {
        "name": "張三"
    }
    """;

// 字符串格式化
String msg = String.format("你好 %s，今年 %d 歲", name, age);

// if-else 一致
if (age >= 18) {
    System.out.println("成年");
} else {
    System.out.println("未成年");
}

// for 循環(huán)一致
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

// 增強 for（類似 JS 的 for...of）
int[] arr = {1, 2, 3};
for (int item : arr) {
    System.out.println(item);
}

// switch（Java 14+ 新寫法很好用）
String result = switch (age) {
    case 18 -> "成年了";
    case 1, 2, 3 -> "小孩";
    default -> "其他";
};

// JS：函數(shù)是一等公民，可以獨立存在
function add(a, b) {
    return a + b;
}
const add2 = (a, b) => a + b;

// Java：方法必須寫在類里，且要聲明返回類型和參數(shù)類型
public int add(int a, int b) {
    return a + b;
}

// 無返回值用 void
public void printName(String name) {
    System.out.println(name);
}

// 修飾符說明：
// public  = 訪問權(quán)限（公開）
// int     = 返回值類型
// add     = 方法名

// JS
class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    sayHi() {
        return `我是 ${this.name}`;
    }
}
const p = new Person("張三", 18);

// Java
public class Person {
    // 1. 成員變量（字段）需要聲明類型
    private String name;
    private int age;

    // 2. 構(gòu)造方法（方法名 = 類名，無返回值）
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 3. getter / setter（Java 習(xí)慣用私有字段 + 公開方法訪問）
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    // 4. 普通方法
    public String sayHi() {
        return "我是 " + name;
    }
}

// 使用
Person p = new Person("張三", 18);
System.out.println(p.sayHi());

// extends 關(guān)鍵字（和 JS 一樣）
public class Student extends Person {
    private String school;

    public Student(String name, int age, String school) {
        super(name, age);   // 調(diào)用父類構(gòu)造，類似 JS 的 super()
        this.school = school;
    }

    // @Override 注解表示重寫父類方法
    @Override
    public String sayHi() {
        return "我是學(xué)生 " + getName();
    }
}

// 定義接口
public interface Animal {
    void eat();            // 抽象方法，沒有方法體
    void sleep();
}

// 實現(xiàn)接口用 implements
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨頭");
    }
    @Override
    public void sleep() {
        System.out.println("狗睡覺");
    }
}

// 抽象類：介于普通類和接口之間，可以有實現(xiàn)也可以有抽象方法
public abstract class Shape {
    abstract double area();        // 抽象方法，子類必須實現(xiàn)

    public void print() {          // 普通方法，可直接繼承使用
        System.out.println("面積是：" + area());
    }
}

// JS
let arr = [1, 2, 3];
let map = { name: "張三" };
let set = new Set([1, 2, 3]);

import java.util.*;

// List：有序可重復(fù)，類似 JS 數(shù)組
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
String first = list.get(0);
int size = list.size();

// Map：鍵值對，類似 JS 對象/Map
Map<String, Integer> map = new HashMap<>();
map.put("張三", 18);
Integer age = map.get("張三");

// Set：不重復(fù)集合
Set<String> set = new HashSet<>();
set.add("a");
set.add("a");  // 重復(fù)無效

// 遍歷 Map
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ":" + entry.getValue());
}

// TypeScript
function identity<T>(arg: T): T {
    return arg;
}
let list: Array<string> = [];

// Java 泛型
// 1. 泛型方法
public <T> T identity(T arg) {
    return arg;
}

// 2. 泛型在集合中（最常見）
List<String> names = new ArrayList<>();   // 只能放 String

// 3. 自定義泛型類
public class Box<T> {
    private T content;

    public void set(T content) {
        this.content = content;
    }
    public T get() {
        return content;
    }
}

// 使用
Box<String> box = new Box<>();
box.set("hello");
String s = box.get();

// JS
let nums = [1, 2, 3, 4, 5];
let result = nums
    .filter(n => n > 2)
    .map(n => n * 2)
    .reduce((a, b) => a + b, 0);

// Java Stream（鏈?zhǔn)秸{(diào)用，幾乎一一對應(yīng)）
List<Integer> nums = List.of(1, 2, 3, 4, 5);
int result = nums.stream()
    .filter(n -> n > 2)          // 過濾
    .map(n -> n * 2)             // 映射
    .reduce(0, Integer::sum);    // 歸約

// 收集成 List
List<Integer> doubled = nums.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList());

// forEach
nums.forEach(n -> System.out.println(n));

// JS
try {
    throw new Error("出錯了");
} catch (e) {
    console.log(e.message);
} finally {
    console.log("結(jié)束");
}

// Java：異常是分類型的
try {
    int result = 10 / 0;
} catch (ArithmeticException e) {       // 捕獲特定異常
    System.out.println("除零錯誤：" + e.getMessage());
} catch (Exception e) {                 // 兜底
    System.out.println("其他錯誤");
} finally {
    System.out.println("結(jié)束");
}

// 主動拋異常
throw new RuntimeException("自定義錯誤");

<project>
    <groupId>com.example</groupId>      <!-- 組織名 -->
    <artifactId>demo</artifactId>       <!-- 項目名 -->
    <version>1.0.0</version>

    <!-- 依賴，類似 dependencies -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

// 傳統(tǒng)方式：自己 new 對象
class UserService {
    constructor() {
        this.userDao = new UserDao();  // 自己創(chuàng)建依賴
    }
}

// Spring：由容器創(chuàng)建和注入對象，你只管"要"
@Service
public class UserService {
    @Autowired               // 自動注入，不用自己 new
    private UserDao userDao;
}

src/main/java/com/example/demo/
├── DemoApplication.java      # 啟動入口（類似 main.js）
├── controller/               # 接口層（類似路由）
├── service/                  # 業(yè)務(wù)邏輯層
├── mapper/                   # 數(shù)據(jù)庫操作層
└── entity/                   # 數(shù)據(jù)模型（類似 model）

src/main/resources/
└── application.yml           # 配置文件（類似 .env + config）

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

// Express
app.get('/user/:id', (req, res) => {
    res.json({ id: req.params.id, name: "張三" });
});

// Spring MVC
@RestController                          // 聲明這是接口控制器
@RequestMapping("/user")                 // 路由前綴
public class UserController {

    @GetMapping("/{id}")                 // GET /user/{id}
    public User getUser(@PathVariable Long id) {
        User user = new User();
        user.setId(id);
        user.setName("張三");
        return user;                     // 自動轉(zhuǎn)成 JSON
    }

    @PostMapping                         // POST /user
    public String create(@RequestBody User user) {  // 接收 JSON body
        return "創(chuàng)建成功：" + user.getName();
    }

    // 接收查詢參數(shù) ?name=xxx
    @GetMapping("/search")
    public String search(@RequestParam String name) {
        return "搜索：" + name;
    }
}

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

// 1. 實體類，對應(yīng)數(shù)據(jù)庫表
@Data                              // Lombok 注解，自動生成 getter/setter
@TableName("user")
public class User {
    @TableId
    private Long id;
    private String name;
    private Integer age;
}

// 2. Mapper 接口，繼承后自動擁有增刪改查
public interface UserMapper extends BaseMapper<User> {
    // 基礎(chǔ) CRUD 都內(nèi)置了，復(fù)雜查詢才需要自己寫
}

// 3. 在 Service 中使用
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User getById(Long id) {
        return userMapper.selectById(id);     // 內(nèi)置方法，直接查
    }

    public void add(User user) {
        userMapper.insert(user);              // 內(nèi)置插入
    }

    public List<User> list() {
        return userMapper.selectList(null);   // 查全部
    }
}

HTTP 請求
    ↓
Controller（接收參數(shù)）
    ↓
Service（業(yè)務(wù)邏輯）
    ↓
Mapper（數(shù)據(jù)庫操作）
    ↓
MySQL

// 用泛型封裝統(tǒng)一返回格式
@Data
public class Result<T> {
    private int code;
    private String message;
    private T data;

    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.code = 200;
        result.message = "成功";
        result.data = data;
        return result;
    }
}

// 使用
@GetMapping("/{id}")
public Result<User> getUser(@PathVariable Long id) {
    User user = userService.getById(id);
    return Result.success(user);
}

1. 先把語法部分敲一遍（1周）—— 重點：類、接口、集合、泛型、Stream
2. 搭一個 Spring Boot 項目跑通 Hello World
3. 寫第一個 GET 接口，用 Postman 調(diào)通
4. 接數(shù)據(jù)庫，實現(xiàn)完整 CRUD
5. 完善：分頁、異常處理、參數(shù)校驗
6. 進階：Redis 緩存、登錄鑒權(quán)(JWT)、文件上傳