java编程 教程 基础|Java语言系统学习指南
Java作为全球最流行的编程语言之一,自1995年Sun公司发布以来,始终保持着旺盛的生命力。凭借其“一次编写,到处运行”的跨平台特性、强大的生态系统、成熟的社区支持以及企业级应用的广泛采用,Java已成为软件开发领域的基石语言。
本java编程 教程 基础内容系统覆盖Java语言核心知识体系,从环境搭建到高级特性,从语法基础到架构设计,帮助开发者构建完整的知识图谱。无论您是编程新手,还是希望系统提升的资深工程师,本指南均能提供切实可行的学习路径与实践参考。
当前Java生态已进入Java 21 LTS时代,引入了虚拟线程(Virtual Threads)、结构化并发(Structured Concurrency)、模式匹配(Pattern Matching)等革命性特性,极大提升了开发效率与程序性能。本指南将结合最新标准,深入剖析语言演进脉络与最佳实践。
学习本课程,您将掌握:
- ✅ JDK安装与环境配置:JDK、JRE、JVM关系解析;PATH与JAVA_HOME配置;多版本JDK管理
- ✅ 核心语法体系:数据类型、运算符、流程控制、数组与字符串处理
- ✅ 面向对象三大特性:封装、继承、多态的深度理解与实战应用
- ✅ 集合框架与泛型机制:List、Set、Map体系;集合线程安全方案;泛型原理与通配符使用
- ✅ 异常处理机制:异常分类体系;自定义异常设计;try-with-resources优化
- ✅ 多线程与并发编程:线程生命周期;同步机制;线程池原理;并发工具类;JUC详解
- ✅ JVM内存模型与性能调优:堆栈结构;GC机制;内存泄漏诊断;常用JVM参数调优
- ✅ 开发工具链:Eclipse与IntelliJ IDEA深度配置;Maven/Gradle构建;Git协作流程
- ✅ 常见面试题与实战项目:高频考点解析;Spring Boot项目实战;代码规范与重构技巧
一、java编程 教程 基础语法体系
Java语法体系以简洁、严谨著称,其设计融合了C/C++的高效性与面向对象的抽象能力。本节从基础数据类型到高级语法糖,系统梳理语法要点。
1.1 数据类型与变量
Java为强类型语言,所有变量必须显式声明类型。数据类型分为两大类:
| 类别 | 类型 | 占用字节 | 默认值 | 示例 |
|---|---|---|---|---|
| 基本类型 | byte | 1 | 0 | byte b = 127; |
| 基本类型 | short | 2 | 0 | short s = 32767; |
| 基本类型 | int | 4 | 0 | int i = 2147483647; |
| 基本类型 | long | 8 | 0L | long l = 9223372036854775807L; |
| 基本类型 | float | 4 | 0.0f | float f = 3.14159f; |
| 基本类型 | double | 8 | 0.0d | double d = 3.141592653589793; |
| 基本类型 | char | 2 | \u0000 | char c = 'A'; |
| 基本类型 | boolean | 1位 | false | boolean flag = true; |
| 引用类型 | 类 | 引用大小 | null | String s = "Hello"; |
| 引用类型 | 接口 | 引用大小 | null | Runnable r = () -> {}; |
| 引用类型 | 数组 | 引用大小 | null | int[] arr = {1,2,3}; |
变量命名需遵循:驼峰命名法(如userName)、首字母小写、不能以数字开头、不能使用关键字(如class、int)。建议使用有意义的名词,避免单字母(except循环计数器i/j/k)。
1.2 运算符与表达式
Java支持多种运算符类型:
- 算术运算符:+、-、*、/、%、++、--
- 关系运算符:==、!=、>、<、>=、<=
- 逻辑运算符:&&(短路与)、||(短路或)、!(非)
- 位运算符:&(与)、|(或)、^(异或)、~(取反)、<<(左移)、>>(右移)、>>>(无符号右移)
- 赋值运算符:=、+=、-=、*=、/=、%=
- 三元运算符:条件 ? 表达式1 : 表达式2
注意:短路求值是逻辑运算的关键特性。例如:if (obj != null && obj.getName() != null)中,若obj为null,则不会执行getName()调用,避免NullPointerException。
1.3 流程控制
流程控制语句包括:
- 选择结构:if-else、switch(支持int、String、enum、char;JDK 14起支持表达式形式)
- 循环结构:for、while、do-while
- 跳转语句:break(终止循环)、continue(跳过本次循环)、return(返回方法)
示例:switch表达式新特性(JDK 14+):
String result = switch (day) {
case "MONDAY", "TUESDAY" -> "工作日";
case "WEEKEND" -> "休息日";
default -> {
yield "未知日期";
}
};
1.4 数组与字符串
数组是固定长度的容器,声明方式:
int[] arr = new int[5];(推荐)int arr[] = new int[5];
字符串是不可变对象(String类),常用方法:
length():获取长度charAt(index):获取指定位置字符substring(start, end):截取子串equals(other):内容比较(注意:==比较引用)indexOf(str):查找子串首次出现位置split(regex):按正则分割
示例:字符串拼接性能优化
// ❌ 低效:每次+操作都创建新String对象
String result = "";
for (int i = 0; i < 1000; i++) {
result += i + ",";
}
// ✅ 高效:使用StringBuilder(线程不安全但高效)
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
sb.append(i).append(",");
}
String result = sb.toString();
// ⚠️ JDK 8+自动优化:编译器将+转换为StringBuilder
1.5 方法与重载
方法是功能封装的基本单位,定义格式:
修饰符 返回类型 方法名(参数列表) [throws 异常] {
方法体
[return 返回值];
}
方法重载(Overload)要求:方法名相同、参数列表不同(类型/数量/顺序)、返回类型不影响重载判断。
示例:
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }
注意:可变参数(varargs)本质是数组,且必须放在参数列表末尾:
int sum(int... nums) {
int total = 0;
for (int num : nums) total += num;
return total;
}
二、面向对象编程(OOP)核心原理
Java是纯面向对象语言,所有代码必须定义在类中。OOP三大支柱——封装、继承、多态,共同构建了灵活可维护的软件架构。
2.1 封装(Encapsulation)
封装通过访问控制符实现信息隐藏:
| 修饰符 | 本类 | 同包 | 子类 | 其他包 |
|---|---|---|---|---|
| private | ✓ | ✗ | ✗ | ✗ |
| 默认(无) | ✓ | ✓ | ✗ | ✗ |
| protected | ✓ | ✓ | ✓ | ✗ |
| public | ✓ | ✓ | ✓ | ✓ |
最佳实践:
- 成员变量统一声明为private
- 提供public的getter/setter方法(JDK 14+可使用record简化)
- 构造方法可控制对象创建逻辑
示例:使用record简化POJO(JDK 16+)
record User(String name, int age) {
public User {
if (age < 0) throw new IllegalArgumentException("年龄不能为负");
}
}
2.2 继承(Inheritance)
Java仅支持单继承(extends),通过接口实现多继承效果。继承原则:
- 子类继承父类非private成员
- 子类可重写父类方法(需@override注解)
- 构造方法不继承,但子类构造默认调用父类无参构造
注意:避免过度继承。组合优于继承是重要设计原则——优先使用has-a关系而非is-a关系。
2.3 多态(Polymorphism)
多态体现为:父类引用指向子类对象,运行时动态绑定具体方法。
示例:
abstract class Animal {
public abstract void sound();
}
class Dog extends Animal {
public void sound() { System.out.println("汪汪"); }
}
class Cat extends Animal {
public void sound() { System.out.println("喵喵"); }
}
// 多态应用
Animal[] animals = {new Dog(), new Cat()};
for (Animal a : animals) a.sound(); // 分别输出"汪汪"、"喵喵"
多态是设计模式(如策略模式、工厂模式)的基石,极大提升代码扩展性。
2.4 抽象类与接口
抽象类(abstract class):
- 不能实例化,可含抽象方法与具体方法
- 子类必须实现所有抽象方法(除非子类也是抽象类)
- 可有构造方法(供子类调用)
接口(interface):
- JDK 8前:仅含抽象方法、常量
- JDK 8+:支持default方法(有默认实现)、static方法
- JDK 9+:支持private方法(辅助default方法)
- 实现类必须实现所有抽象方法
接口 vs 抽象类对比:
| 特性 | 接口 | 抽象类 |
|---|---|---|
| 继承/实现 | 类可实现多个接口 | 类只能继承一个抽象类 |
| 成员变量 | 仅public static final常量 | 可有各种类型变量 |
| 构造方法 | 无 | 有(供子类调用) |
| 访问修饰符 | 方法默认public | 可有任意修饰符 |
示例:接口默认方法解决升级问题
interface Printable {
void print();
default void log(String msg) { // 新增默认方法,旧实现类无需修改
System.out.println("[LOG] " + msg);
}
}
三、集合框架与泛型机制
Java集合框架(JCF)提供统一的接口与高效实现,是开发中最常用的数据结构工具集。
3.1 集合体系结构
Collection(单列集合)
├── List(有序、可重复)
│ ├── ArrayList(数组实现,查询快,增删慢)
│ ├── LinkedList(链表实现,增删快,查询慢)
│ └── Vector(线程安全,已过时)
└── Set(无序、不可重复)
├── HashSet(哈希表实现,无序)
├── LinkedHashSet(哈希+链表,有序)
└── TreeSet(红黑树,自然排序/定制排序)
Map(双列集合)
├── HashMap(哈希表,允许null键值)
├── LinkedHashMap(哈希+链表,有序)
├── HashTable(线程安全,不允许null键值)
└── TreeMap(红黑树,键排序)
3.2 List实现类详解
ArrayList:
- 底层:动态数组(初始容量10,扩容1.5倍)
- 适用场景:频繁查询、尾部插入
- 线程安全:非线程安全,可通过
Collections.synchronizedList()包装
LinkedList:
- 底层:双向链表
- 适用场景:频繁插入/删除(尤其中间位置)
- 额外功能:实现Deque接口,可作队列/栈使用
性能对比(10万次操作):
| 操作 | ArrayList | LinkedList |
|---|---|---|
| 尾部插入 | O(1) amortized | O(1) |
| 中间插入 | O(n) | O(n) + O(1)定位 |
| 随机访问 | O(1) | O(n) |
| 内存开销 | 低(仅存储元素) | 高(节点含前后指针) |
3.3 Set实现类与去重原理
HashSet通过HashMap实现,元素作为key存储:
- 要求元素实现hashCode()与equals()(重写规则:相等对象hashCode必须相同)
- 哈希冲突:链表+红黑树(JDK 8+,链表>8转树)
示例:自定义对象去重
class Person {
String name;
int age;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person p = (Person) o;
return age == p.age && Objects.equals(name, p.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
3.4 Map核心操作
HashMap关键特性:
- 初始容量16,加载因子0.75
- JDK 8+:链表转红黑树阈值=8,树转链表阈值=6
- 线程安全:使用ConcurrentHashMap
常用方法:
- put(key, value)
- get(key)
- containsKey(key)
- keySet()/values()/entrySet()
- computeIfAbsent(key, mappingFunction)
示例:统计词频
Map freq = new HashMap<>();
String[] words = {"java","oop","java","collection"};
for (String word : words) {
freq.computeIfAbsent(word, k -> 0);
freq.put(word, freq.get(word) + 1);
}
// 结果:{java=2, oop=1, collection=1}
3.5 泛型机制与通配符
泛型(Generics)提供编译期类型安全检查,避免运行时ClassCastException。
类型通配符:
?:无界通配符(Object子类型)? extends T:上界通配符(T子类型)? super T:下界通配符(T父类型)
PECS原则(Producer Extends, Consumer Super):
- 若需读取数据 → 使用 extends T>
- 若需写入数据 → 使用 super T>
- 若同时读写 → 不使用通配符
示例:集合拷贝
public static void copy(List extends T> src, List super T> dest) {
for (T item : src) dest.add(item);
}
3.6 集合线程安全方案
| 方案 | 适用场景 | 缺点 |
|---|---|---|
| Collections.synchronizedList() | 低并发读写 | 全局锁,性能差 |
| Vector | 已过时,不推荐 | 方法级synchronized |
| CopyOnWriteArrayList | 读多写少(如监听器列表) | 写时复制,内存开销大 |
| ConcurrentHashMap | 高并发读写(推荐) | 部分操作非原子 |
示例:CopyOnWriteArrayList使用
CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
list.add("Java");
list.add("Python");
for (String s : list) {
if ("Java".equals(s)) list.remove(s); // 不会抛ConcurrentModificationException
}
四、多线程与并发编程
并发编程是Java高级特性核心,掌握线程管理与同步机制对构建高性能系统至关重要。
4.1 线程创建与生命周期
创建线程三种方式:
- 继承Thread类(单继承限制)
- 实现Runnable接口(推荐,避免单继承限制)
- 实现Callable接口(支持返回值与异常)
示例:Runnable + 线程池
ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> {
System.out.println(Thread.currentThread().getName() + "执行任务");
return "结果";
});
线程生命周期:
- NEW:创建后未启动
- RUNNABLE:运行中(含就绪+运行)
- BLOCKED:等待监视器锁(synchronized)
- WAITING:无限期等待(Object.wait/Thread.join)
- TIMED_WAITING:限时等待(Thread.sleep/timeWait)
- TERMINATED:执行完毕
4.2 同步机制
synchronized三大用法:
- 同步实例方法(锁当前对象this)
- 同步静态方法(锁Class对象)
- 同步代码块(锁指定对象)
示例:双重检查锁定单例
class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) { // 第一次检查
synchronized (Singleton.class) {
if (instance == null) { // 第二次检查
instance = new Singleton();
}
}
}
return instance;
}
}
volatile关键字作用:
- 保证可见性(线程修改立即写回主内存)
- 禁止指令重排序(通过内存屏障)
- 不保证原子性(需配合synchronized)
4.3 线程池原理
Executors工厂创建线程池(不推荐,需手动配置):
// ❌ 不推荐:FixedThreadPool无界队列,OOM风险
ExecutorService pool = Executors.newFixedThreadPool(4);
// ✅ 推荐:直接使用ThreadPoolExecutor
ThreadPoolExecutor pool = new ThreadPoolExecutor(
4, // corePoolSize
8, // maximumPoolSize
60L, // keepAliveTime
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100), // 有界队列
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);
拒绝策略:
- AbortPolicy:抛RejectedExecutionException(默认)
- CallerRunsPolicy:调用者线程执行
- DiscardPolicy:静默丢弃
- DiscardOldestPolicy:丢弃最旧任务
4.4 JUC并发工具类
java.util.concurrent(JUC)提供高级并发原语:
- CountDownLatch:倒计时器(等待多个线程完成)
- CyclicBarrier:循环栅栏(多线程同步点)
- Semaphore:信号量(控制并发访问数)
- ConcurrentHashMap:线程安全哈希表
- BlockingQueue:阻塞队列(生产者-消费者模式)
示例:CountDownLatch同步
CountDownLatch latch = new CountDownLatch(3);
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
pool.submit(() -> {
try {
System.out.println(Thread.currentThread().getName() + "执行中");
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
latch.countDown();
}
});
}
latch.await(); // 等待3个线程完成
System.out.println("所有任务完成!");
4.5 虚拟线程(JDK 21)
Project Loom引入的轻量级线程,解决传统线程高内存开销问题:
- 传统线程:1MB栈空间(OS线程)
- 虚拟线程:栈空间动态分配(用户态调度)
- 适用场景:高并发I/O密集型应用(如Web服务器)
示例:虚拟线程使用
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 10000; i++) {
final int id = i;
executor.submit(() -> {
Thread.sleep(Duration.ofSeconds(1));
return id;
});
}
}
性能对比(10000任务):
| 指标 | 传统线程 | 虚拟线程 |
|---|---|---|
| 创建时间 | 毫秒级 | 微秒级 |
| 内存占用 | ~1MB/线程 | ~256KB/线程(初始) |
| 上下文切换 | 内核态 | 用户态 |
| 最大并发数 | ~1000 | ~100000+ |
五、JVM内存模型与性能调优
深入理解JVM是成为Java专家的必经之路,本节详解内存管理与性能优化核心要点。
5.1 JVM内存区域
JDK 8+内存模型:
线程私有区域:
├── 程序计数器(线程私有)
├── 虚拟机栈(栈帧:局部变量表、操作数栈、动态链接、返回地址)
└── 本地方法栈(Native方法)
线程共享区域:
├── 堆(Heap):对象实例存储区
│ ├── 新生代(Eden + S0/S1)
│ └── 老年代
└── 元空间(Metaspace):类元数据(JDK 8+替代永久代)
对象创建过程:
- 类加载检查(是否已加载)
- 分配内存(指针碰撞/空闲列表)
5.2 垃圾回收机制
判断对象存活:
- 引用计数法:循环引用问题(Java未采用)
- 可达性分析:GC Roots根节点遍历(Java采用)
GC Roots对象:
- 虚拟机栈中引用的对象
- 静态属性引用的对象
- 常量引用的对象
- 本地方法栈中引用的对象
垃圾回收算法:
| 算法 | 原理 | 优缺点 |
|---|---|---|
| 标记-清除 | 标记后清除未标记对象 | 效率低、产生碎片 |
| 复制算法 | 内存分两块,存活对象复制到另一块 | 无碎片、浪费空间 |
| 标记-整理 | 标记后移动存活对象 | 无碎片、效率低 |
| 分代收集 | 新生代用复制,老年代用标记-整理 | 主流JVM采用 |
垃圾收集器:
- Serial:单线程,Client模式默认
- ParNew:多线程,Server模式默认(配合CMS)
- Parallel Scavenge:高吞吐量,服务端应用
- CMS:低停顿,老年代(JDK 9+废弃)
- G1:Region化,可预测停顿(JDK 9+默认)
- ZGC:亚毫秒级停顿,JDK 11+(JDK 15正式)
- Shenandoah:低停顿,Red Hat主导
5.3 常用JVM参数调优
| 参数 | 作用 | 示例 |
|---|---|---|
| -Xms/-Xmx | 堆初始/最大大小 | -Xms512m -Xmx2g |
| -Xmn | 新生代大小 | -Xmn256m |
| -XX:MetaspaceSize | 元空间初始大小 | -XX:MetaspaceSize=256m |
| -XX:+UseG1GC | 启用G1收集器 | -XX:+UseG1GC |
| -XX:+HeapDumpOnOutOfMemoryError | OOM时生成堆转储 | -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/logs |
| -Xlog:gc* | GC日志输出 | -Xlog:gc*:file=gc.log:time,uptime,level,tags |
5.4 性能诊断工具
JDK自带工具:
- jps:查看Java进程
- jstat:监控GC与内存
- jmap:生成堆转储(jmap -dump:format=b,file=heap.hprof PID)
- jstack:生成线程栈(jstack PID > thread.txt)
- jcmd:多功能诊断工具(jcmd PID GC.heap_dump /tmp/heap.hprof)
可视化工具:
- JVisualVM:集成监控/分析/profiling
- JMC(Java Mission Control):高级诊断
- Arthas:阿里开源在线诊断工具
示例:GC日志分析
[0.123s][info][gc] GC(0) Pause Young (Normal) (G1 Evacuation Pause) 6M->2M(8M) 1.234ms
- 0.123s:JVM启动后时间
- GC(0):GC序号
- Pause Young:GC类型与暂停阶段
- 6M->2M(8M):GC前->GC后(堆大小)
- 1.234ms:暂停时间
六、开发工具链与最佳实践
高效开发离不开强大工具支持,本节详解主流开发环境配置与协作流程。
6.1 JDK安装与管理
JDK版本选择:
- LTS版本:Java 8(2014)、11(2018)、17(2021)、21(2023)
- 生产环境:优先选择最新LTS(当前Java 21)
- 学习环境:可使用最新版体验新特性
多版本JDK管理:
- Windows:设置JAVA_HOME环境变量
- Linux/macOS:使用
export JAVA_HOME=/path/to/jdk - 推荐工具:SDKMAN!(跨平台)或
jenv(macOS)
示例:SDKMAN!安装
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk list java
sdk install java 21-tem
sdk use java 21-tem
6.2 IDE配置
IntelliJ IDEA(推荐):
- 插件推荐:
- Chinese(中文语言包)
- CodeGlance(代码缩略图)
- Rainbow Brackets(括号着色)
- Save Actions(保存时自动格式化)
- MyBatisX(MyBatis支持)
- 关键设置:
- File Encoding:UTF-8
- Compiler → Java Compiler:Override Compiler Per Module → Target Bytecode Version:17
- Editor → Code Style → Java:使用Google Java Format
Eclipse(传统企业):
- 安装插件:
- Spring Tool Suite(STS)
- FindBugs(静态分析)
- Eclipse Color Theme
- 快捷键优化:
- Ctrl+1:快速修复
- Ctrl+Shift+F:格式化代码
- Ctrl+O:快速大纲
6.3 构建工具
Maven核心配置:
- pom.xml:项目对象模型
- 依赖管理:
<dependency></dependency> - 生命周期:clean、validate、compile、test、package、verify、install、deploy
- 常用命令:
mvn clean install:清理+编译+测试+打包+安装本地仓库mvn dependency:tree:查看依赖树mvn dependency:analyze:分析依赖使用情况
Gradle优势:
- 基于Groovy/Kotlin DSL,更灵活
- 增量构建,速度快
- 支持任务依赖与条件执行
示例:Gradle依赖管理
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web:3.2.0'
testImplementation 'org.springframework.boot:spring-boot-starter-test:3.2.0'
}
6.4 版本控制与协作
Git工作流:
- 主干分支:main(生产环境)
- 开发分支:develop(集成测试)
- 功能分支:feature/*(新功能开发)
- 发布分支:release/*(发布前测试)
- 热修复分支:hotfix/*(紧急修复)
推荐分支命名规范:
- feature/USER-123-add-login
- bugfix/ISSUE-456-fix-crash
- release/v2.1.0
示例:Git流程
# 创建功能分支
git checkout -b feature/USER-123-add-login
# 开发完成后提交
git add .
git commit -m "feat: 添加登录功能"
# 合并回develop
git checkout develop
git merge --no-ff feature/USER-123-add-login
git push origin develop
6.5 代码规范与重构
阿里巴巴Java开发手册核心要点:
- 【强制】OOP规则:避免过长方法(≤50行)、合理命名、减少嵌套
- 【强制】集合处理:避免null值、初始化容量、使用工具类
- 【强制】并发处理:线程池参数合理配置、使用CompletableFuture
- 【推荐】日志规范:使用SLF4J、日志级别正确使用
重构技巧:
- Extract Method(提取方法)
- Replace Conditional with Polymorphism(用多态替换条件)
- Introduce Null Object(引入空对象)
- Remove Dead Code(移除死代码)
示例:重构前 vs 重构后
// ❌ 重构前:条件嵌套深、重复代码
if (user != null) {
if (user.isActive()) {
if (user.hasPermission("ADMIN")) {
return "Welcome, Admin!";
} else {
return "Welcome, User!";
}
} else {
return "User inactive";
}
} else {
return "User not found";
}
// ✅ 重构后:使用Optional与策略模式
return Optional.ofNullable(user)
.filter(User::isActive)
.map(u -> u.hasPermission("ADMIN") ? "Welcome, Admin!" : "Welcome, User!")
.orElseGet(() -> user == null ? "User not found" : "User inactive");
七、高频面试题与实战项目
本节精选企业级Java开发核心面试题,结合真实项目场景解析。
7.1 语法基础题
Q1:final、finally、finalize区别?
- final:修饰类(不可继承)、方法(不可重写)、变量(不可变)
- finally:异常处理块,确保代码执行(除非System.exit)
- finalize:Object方法,GC前调用(已废弃,JDK 9+标记为deprecated)
Q2:==与equals区别?
- ==:基本类型比较值,引用类型比较内存地址
- equals:默认行为同==,String/包装类重写后比较内容
Q3:int与Integer区别?
- int:基本类型,存储于栈,默认0
- Integer:包装类,对象存储于堆,默认null
- 自动装箱/拆箱:Integer a = 100;int b = a;
- 缓存机制:[-128,127]范围复用对象(Integer.valueOf)
7.2 OOP与设计模式
Q1:重载与重写区别?
| 维度 | 重载(Overload) | 重写(Override) |
|---|---|---|
| 范围 | 同一类 | 子类覆盖父类 |
| 参数列表 | 必须不同 | 必须相同 |
| 返回类型 | 可不同 | 不能更窄 |
| 访问修饰符 | 可更宽松 | 不能更严格 |
| 编译时 | 静态绑定 | 动态绑定 |
Q2:设计模式应用场景
- 单例:配置管理、线程池
- 工厂:Spring Bean创建
- 代理:Spring AOP、RPC调用
- 观察者:事件监听、消息订阅
- 策略:支付方式选择、排序算法
7.3 集合与泛型
Q1:HashMap线程不安全表现?
- 多线程put导致数据丢失
- 扩容时形成环形链表(JDK 7),CPU 100%
- 解决方案:ConcurrentHashMap / Collections.synchronizedMap
Q2:ArrayList与LinkedList选择?
- 查询多 → ArrayList
- 插入/删除多(尤其中间)→ LinkedList
- 内存敏感 → ArrayList
- 需要栈/队列操作 → LinkedList(Deque接口)
7.4 多线程与并发
Q1:synchronized与ReentrantLock区别?
| 特性 | synchronized | ReentrantLock |
|---|---|---|
| 锁类型 | 内置锁 | 显式锁 |
| 释放方式 | 自动释放 | 需手动unlock() |
| 可中断 | 否 | 是(lockInterruptibly) |
| 超时 | 否 | 是(tryLock) |
| 公平锁 | 非公平 | 可配置 |
| 性能 | JDK 6后优化,接近ReentrantLock | 高并发下更优 |
Q2:volatile原理?
- 内存屏障:禁止指令重排序
- 缓存一致性:MESI协议,修改后立即写回主内存
- 不保证原子性:需配合synchronized
7.5 JVM与性能调优
Q1:OOM常见原因?
- 堆溢出(java.lang.OutOfMemoryError: Java heap space)
- 元空间溢出(Metaspace)
- 线程栈溢出(StackOverflowError)
- 直接内存溢出(DirectByteBuffer)
Q2:GC调优思路?
- 收集监控数据(GC日志、JVM参数)
- 确定目标(低延迟/高吞吐)
- 选择收集器(G1/ZGC)
- 调整堆大小与代比例
- 验证调优效果
7.6 实战项目:电商库存系统
需求描述:
- 实现高并发库存扣减(秒杀场景)
- 防止超卖(库存不足)
- 保证数据一致性
技术方案:
- 数据库层:乐观锁(version字段)
- 缓存层:Redis预减库存(原子操作)
- 消息队列:异步扣减库存(解耦)
- 限流降级:Sentinel限流
核心代码片段:
// Redis预减库存(Lua脚本保证原子性)
String script = "local stock = redis.call('GET', KEYS[1]); " +
"if tonumber(stock) >= tonumber(ARGV[1]) then " +
"redis.call('DECRBY', KEYS[1], ARGV[1]); " +
"return 1; " +
"else " +
"return 0; " +
"end";
Long result = (Long)jedis.eval(script,
Collections.singletonList("stock:1001"),
Collections.singletonList("1"));
压测结果:
| 指标 | 单机Tomcat | Redis+MQ方案 |
|---|---|---|
| TPS | 120 | 8500 |
| 平均响应时间 | 2800ms | 45ms |
| 超卖率 | 3.2% | 0% |
7.7 面试技巧
STAR法则(Situation-Task-Action-Result)描述项目:
- Situation:项目背景与挑战
- Task:个人负责模块与目标
- Action:具体技术方案与实现
- Result:量化成果(性能提升、成本节约)
示例:
在XX电商秒杀项目中(Situation),需解决高并发库存超卖问题(Task)。我采用Redis预减库存+Lua脚本原子操作方案(Action),QPS从120提升至8500,超卖率降至0%,获公司技术创新奖(Result)。
网友们都还关心:
- 如何从零开始规划Java学习路径?
- Java工程师职业发展路线有哪些?
- 微服务架构中Java技术栈如何选型?
- 如何快速定位生产环境性能瓶颈?
- Java新特性在实际项目中的应用案例?
- 分布式系统中Java事务如何处理?
- 容器化部署(Docker/K8s)对Java应用的影响?
- 云原生时代Java的竞争力分析?