Java 学习笔记

📖 基础语法入门 ▶

Hello World

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello Java!");
    }
}

变量与数据类型

Java 是强类型语言，所有变量必须先声明后使用。

// 基本类型
int age = 25;
double salary = 15000.50;
boolean isActive = true;
char grade = 'A';

// 引用类型
String name = "Java";
Integer count = 100;  // 自动装箱

控制流程

// if-else
if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

// for 循环
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

// switch 表达式 (Java 14+)
String result = switch (day) {
    case 1, 2, 3, 4, 5 -> "工作日";
    case 6, 7 -> "周末";
    default -> "无效";
};

🔷 面向对象 (OOP) 核心 ▶

类与对象

public class Student {
    private String name;
    private int age;

    // 构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter / Setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

三大特性

封装 — 通过 private 隐藏内部状态，暴露公共方法。
继承 — extends 关键字实现代码复用。
多态 — 父类引用指向子类对象，运行时动态绑定。

接口与抽象类

// 接口 (完全抽象)
public interface Drawable {
    void draw();  // 默认 public abstract
}

// 抽象类 (部分实现)
public abstract class Shape {
    protected String color;
    public abstract double area();
}

📦 集合框架高频 ▶

Collection 体系

// List — 有序可重复
List<String> list = new ArrayList<>();
list.add("Java"); list.add("Python");

// Set — 无序不可重复
Set<Integer> set = new HashSet<>();
set.add(1); set.add(2); set.add(1);  // {1, 2}

// Map — 键值对
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 90);
map.put("Bob", 85);

Stream API（Java 8+）

List<String> result = list.stream()
    .filter(s -> s.startsWith("J"))         // 过滤
    .map(String::toUpperCase)                     // 映射
    .sorted()                                     // 排序
    .collect(Collectors.toList());                // 收集

⚠️ 异常处理 ▶

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.err.println("除数不能为零: " + e.getMessage());
} finally {
    System.out.println("一定会执行");  // 关闭资源
}

Checked 编译时检查，必须处理 Unchecked 运行时异常，可不处理

🧵 多线程 & 并发进阶 ▶

创建线程

// 方式1: 继承 Thread
class MyThread extends Thread {
    public void run() { System.out.println("线程运行中"); }
}

// 方式2: 实现 Runnable（推荐）
Runnable task = () -> System.out.println("Lambda 线程");
new Thread(task).start();

// 方式3: Callable + FutureTask（有返回值）
FutureTask<Integer> future = new FutureTask<>(() -> 42);
new Thread(future).start();
Integer result = future.get();  // 阻塞获取结果

synchronized & Lock

// synchronized 关键字
public synchronized void increment() { count++; }

// Lock 接口（更灵活）
Lock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区
} finally {
    lock.unlock();
}

线程池

ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> System.out.println("任务执行"));
pool.shutdown();  // 不再接收新任务

⚙️ JVM 内存模型面试 ▶

区域	说明
堆 (Heap)	所有对象实例、数组
栈 (Stack)	局部变量、方法调用帧
方法区 (Metaspace)	类信息、常量、静态变量
程序计数器	当前线程执行字节码行号
本地方法栈	native 方法调用

GC 垃圾回收

常用收集器：Serial、Parallel、CMS、G1（默认 JDK 9+）、ZGC（低延迟）

# JVM 调优常用参数
-Xms512m -Xmx2g                      # 堆大小
-XX:+UseG1GC                          # 使用 G1
-XX:MaxGCPauseMillis=200              # 最大 GC 停顿
-Xlog:gc*                             # GC 日志 (JDK 9+)

🍃 Spring Boot 快速入门框架 ▶

Application

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

Controller

@RestController
@RequestMapping("/api")
public class HelloController {

    @GetMapping("/hello")
    public String hello(@RequestParam String name) {
        return "Hello " + name;
    }
}

📦 Maven 常用命令 ▶

mvn clean              # 清理 target
mvn compile            # 编译源码
mvn test               # 运行测试
mvn package            # 打包 jar/war
mvn install            # 安装到本地仓库
mvn clean package -DskipTests  # 跳过测试打包

🎯 常见面试题 ▶

String、StringBuilder、StringBuffer 区别

String 不可变，线程安全；StringBuilder 可变，非线程安全（性能最好）；StringBuffer 可变，线程安全（加锁）。

HashMap 原理

数组 + 链表/红黑树，key 的 hashCode 定位桶，冲突用链表/红黑树存储。默认容量 16，负载因子 0.75，扩容 2 倍。

== 与 equals

== 比较引用地址（基本类型比值）；equals 默认同 ==，通常重写为内容比较。

final 关键字

修饰类 → 不可继承；修饰方法 → 不可重写；修饰变量 → 不可变（基本类型值不变，引用类型指向不变）。

🛠️ 开发工具推荐 ▶

IDE：IntelliJ IDEA（最推荐）、Eclipse、VS Code

构建工具：Maven、Gradle

调试工具：jps / jstack / jmap / jstat / jconsole / VisualVM

常用框架：Spring Boot、Spring Cloud、MyBatis、Hibernate

☕ Java 学习笔记