Java 开发工程师面试必会问题 + 标准答案（完整版，分初级 / 中级 / 高级，全覆盖高频考点，面试直接套用）

Ne0inhk

24 Mar 2026 — 30 min read

✅ 说明：本文分「基础必问（应届生 / 初级岗 100% 考）」、「核心进阶（1-3 年中级岗必考）」、「高级深度（3 年 + 资深 / 架构岗高频）」、「项目 + 场景题（所有级别必问）」、「HR 综合题」五大模块，所有问题均为一线互联网 / 外包 / 国企 / 大厂高频原题，答案是面试标准答案，简洁专业、直击得分点，背会即可通关，无冗余内容，Java 面试核心考点全覆盖。✅ 加分提示：回答面试题的核心原则 → 结论 + 原理 + 补充细节 / 优缺点 / 使用场景，不要只说结论，面试官最喜欢听「有逻辑、有深度、有延伸」的回答。

一、Java 基础核心必问（初级 / 应届生重中之重，占面试分 40%，100% 问到）

1. Java 的三大特性是什么？分别解释一下

答：Java 的三大特性是封装、继承、多态，是 Java 面向对象的核心；

封装：把对象的属性和行为封装起来，对外只暴露公开的访问方法（get/set），隐藏内部实现细节，保证数据安全性，核心是private私有修饰 + 对外提供接口；
继承：子类继承父类的属性和方法，实现代码复用，Java 中单继承、多实现，子类用extends关键字，接口用implements，子类可以重写父类的非 final 方法；
多态：同一个行为，针对不同对象有不同的表现形式，编译时看父类，运行时看子类。实现方式有两种：① 方法重写（子类重写父类方法）② 方法重载（同一个类中方法名相同、参数列表不同）。

2. int 和 Integer 的区别？缓存池了解吗？

答：这是高频基础题，核心区别有 3 点：

类型不同：int是 Java基本数据类型，占 4 字节，直接存数值；Integer是int的包装类（引用类型），存的是对象地址；
取值不同：int的默认值是0；Integer的默认值是null；
存储位置：int变量存于栈中；Integer对象，new 出来的存在堆中，直接赋值的常量存在常量池。补充：Integer 有缓存池（-128 ~ 127），这个范围内的 Integer 值，直接赋值时复用常量池对象，地址相等；超出范围则新建对象，地址不等。例：Integer a=127, b=127 → a==b为 true；Integer a=128, b=128 → a==b为 false。

3. String、StringBuffer、StringBuilder 的区别？

答：核心区别是 是否可变 + 是否线程安全 + 执行效率，三者都是字符串相关类，面试必问，标准答案如下：

String：字符串不可变，底层是final char[]数组，每次拼接 / 修改都会新建对象，性能最差；线程安全（因为不可变）；
StringBuffer：字符串可变，底层是可变 char 数组，修改是在原数组操作，不会新建对象；线程安全，所有方法都加了synchronized同步锁；执行效率中等；
StringBuilder：字符串可变，和 StringBuffer 底层实现一致；线程不安全，方法无同步锁；执行效率最高。使用场景：① 少量字符串拼接用 String；② 多线程环境下的字符串拼接用 StringBuffer；③ 单线程环境下大量拼接（循环拼接）用 StringBuilder。

4. equals () 和 == 的区别？

答：记住一句话核心结论，再补充细节即可满分：

==：是运算符，分两种情况：① 比较基本数据类型：比较的是「数值是否相等」；② 比较引用数据类型：比较的是「堆内存中的对象地址是否相等」（是否是同一个对象）。
equals()：是Object 类的方法，默认实现就是==（比较地址）；常用类（String、Integer、Date）都重写了 equals ()，重写后比较的是「对象的内容 / 属性是否相等」。举例：String a = new String("java"); String b = new String("java"); → a==b是 false（地址不同），a.equals(b)是 true（内容相同）。

5. Java 中的值传递和引用传递？Java 是值传递还是引用传递？

答：标准答案：Java 中只有【值传递】，没有引用传递，这是面试高频坑题，一定要答准！

值传递：方法传参时，传递的是「实际参数的副本」，方法内修改副本的值，不会影响原参数的值；（基本数据类型都是值传递）
引用传递：方法传参时，传递的是「实际参数的地址」，方法内修改参数，会影响原参数；（Java 不存在）补充：Java 的引用类型（对象、数组）传参，看似是传地址，其实本质还是值传递：传递的是「地址值的副本」。方法内可以通过这个地址修改对象的属性值（会影响原对象），但如果把副本地址指向新对象，原对象的地址不会变。

6. Object 类有哪些常用方法？

答：Object 是 Java 所有类的父类，所有类都直接 / 间接继承 Object，必问，答出以下 8 个核心方法即可，按重要性排序：equals()、hashCode()、toString()、getClass()、clone()、notify()、notifyAll()、wait()、finalize()；高频补充：① equals()和hashCode()的约定：相等的对象，hashCode 一定相等；hashCode 相等的对象，equals 不一定相等；② wait()和notify()是线程通信的方法，必须在synchronized同步块中使用。

7. 重载 (Overload) 和重写 (Override) 的区别？

答：两个都是实现多态的方式，核心区别记牢3 点即可：

定义不同：重载是同一个类中，多个方法「方法名相同、参数列表不同（个数 / 类型 / 顺序）」，与返回值、修饰符无关；重写是子类对父类的同名方法，参数列表、返回值完全一致，修饰符不能更严格；
发生位置：重载发生在同一个类；重写发生在父子类 / 接口实现类；
多态类型：重载是编译时多态（编译期确定调用哪个方法）；重写是运行时多态（运行期才确定调用子类的方法）。

8. final 关键字的作用？

答：final 可以修饰 类、方法、变量，三大作用，面试标准答案：

修饰类：该类不能被继承，没有子类（比如 String 类就是 final 类）；
修饰方法：该方法不能被子类重写，可以保证方法的逻辑不变；
修饰变量：① 修饰基本类型变量：值不可修改（常量）；② 修饰引用类型变量：地址不可修改，但对象的属性值可以修改。

二、集合框架核心必问（所有级别必考，占面试分 25%，重中之重）

集合是 Java 开发的核心工具，面试必考，ArrayList、HashMap 是绝对高频，必须背会标准答案，无例外！

1. Java 集合框架分为哪两大类？各自的特点？

答：Java 集合框架顶层是Collection和Map两大根接口，所有集合都属于这两类，区别鲜明：

Collection 接口：存储的是单个元素，是单列集合；子接口有 List（有序可重复）、Set（无序不可重复）、Queue（队列）；
- List：ArrayList、LinkedList、Vector；
- Set：HashSet、LinkedHashSet、TreeSet；
Map 接口：存储的是键值对（key-value），是双列集合；key 唯一，value 可重复；核心实现类：HashMap、HashTable、TreeMap、LinkedHashMap。

2. ArrayList 和 LinkedList 的区别？使用场景？

答：高频中的高频，必背，核心区别围绕 底层实现、查询 / 增删效率、内存占用、线程安全 展开：

底层实现：ArrayList 基于动态数组实现；LinkedList 基于双向链表实现，同时实现了 Deque 队列接口；
访问效率：ArrayList 支持随机访问（通过下标get(index)），查询效率 O(1)，极快；LinkedList 查询需要从头 / 尾遍历，效率 O(n)，很慢；
增删效率：ArrayList 增删元素时，需要移动数组元素（尤其是中间位置），效率低；LinkedList 增删元素只需修改链表节点的指针，无需移动元素，效率极高；
内存占用：ArrayList 内存连续，占用内存小；LinkedList 每个节点都要存储前驱 / 后继节点地址，内存开销大；
线程安全：两者都线程不安全；ArrayList 的线程安全替代类是CopyOnWriteArrayList。使用场景：查多改少用 ArrayList，改多查少用 LinkedList。

3. HashMap 的底层实现？JDK1.7 和 JDK1.8 的区别？

答：Java 面试天花板高频题，初级岗问基础实现，中高级岗问 1.7/1.8 区别 + 扩容机制，标准答案分两段答，逻辑清晰，面试官绝对满意：

✅ 第一段：HashMap 的核心底层实现（通用）

HashMap 是基于 数组 + 链表 + 红黑树（JDK1.8 新增）实现的键值对集合，key 唯一，允许 null 键和 null 值，线程不安全，查询和增删的平均效率都是 O(1)；核心原理：通过哈希算法计算 key 的 hashCode，得到数组下标，把键值对存到数组对应位置；如果出现哈希冲突（不同 key 算出相同下标），则在该下标位置形成链表；当链表长度超过阈值（默认 8）且数组容量≥64 时，链表转为红黑树，提升查询效率。

✅ 第二段：JDK1.7 和 JDK1.8 HashMap 核心区别（5 个核心，必背）

底层结构：1.7 是 数组 + 链表；1.8 是 数组 + 链表 + 红黑树；
哈希算法：1.7 是 hashCode() 多次扰动；1.8 是 hashCode() ^ (hashCode() >>> 16)，减少哈希冲突，计算更高效；
链表插入方式：1.7 是头插法，扩容时会导致链表反转，并发下产生死循环；1.8 是尾插法，解决死循环问题；
扩容机制：1.7 扩容时重新计算所有元素的哈希值；1.8 扩容时，元素要么留在原下标，要么移到 原下标+旧容量，无需重新哈希，效率提升；
阈值触发：1.8 新增「链表转红黑树」阈值（链表长度≥8，数组容量≥64），树转链表阈值是 6。

4. HashMap 和 HashTable 的区别？

答：4 个核心区别，答全即满分：

线程安全：HashMap 线程不安全，无同步锁，效率高；HashTable 线程安全，所有方法都加了synchronized，效率低；
取值支持：HashMap 允许 null 键和 null 值；HashTable 不允许，否则抛出空指针异常；
底层实现：HashMap 是数组 + 链表 + 红黑树（1.8）；HashTable 是数组 + 链表；
初始容量和扩容：HashMap 初始容量 16，扩容是 2 倍；HashTable 初始容量 11，扩容是 2n+1；补充：HashMap 的线程安全替代方案是 ConcurrentHashMap（比 HashTable 效率高，分段锁 / 红黑树锁），而非 HashTable。

5. ConcurrentHashMap 如何保证线程安全？JDK1.7 和 1.8 的区别？

答：中级岗必问，ConcurrentHashMap 是 HashMap 的线程安全版，效率远高于 HashTable，核心区别如下：

JDK1.7：采用 分段锁（Segment 数组） 实现，底层是Segment + HashEntry数组 + 链表；每个 Segment 是一个独立的锁，多个线程操作不同 Segment 时互不阻塞，并发度是 Segment 的数量（默认 16），解决了 HashTable 全表锁的低效问题；
JDK1.8：摒弃了分段锁，采用 CAS + synchronized + 红黑树 实现；底层是Node数组 + 链表 + 红黑树；对数组的单个节点加 synchronized 锁，锁粒度更细，并发效率更高；CAS 保证无锁操作的原子性，synchronized 保证并发修改的安全性。

三、JVM 虚拟机核心必问（中高级岗必考，占面试分 20%，拉开差距的核心考点）

JVM 是 Java 面试的分水岭，初级岗可能只问基础，中高级岗必问深度考点，背会以下问题，碾压 80% 的面试者，都是高频原题！

1. JVM 的内存结构（运行时数据区）分为哪几块？各自的作用？

答：标准答案（JDK1.8 版本，最新版，必背）：JVM 运行时数据区划分为 5 大区域，其中 堆、方法区是线程共享，虚拟机栈、本地方法栈、程序计数器是线程私有，核心作用如下：

程序计数器：线程私有，存储当前线程执行的字节码行号，线程切换时恢复执行位置，无内存溢出（OOM）；
虚拟机栈：线程私有，存储方法的栈帧（局部变量表、操作数栈、返回地址），方法调用入栈，执行完出栈；栈深度过大抛StackOverflowError，栈内存不足抛OOM；
本地方法栈：线程私有，作用和虚拟机栈一致，只是为native 本地方法服务；
堆（Heap）：线程共享，JVM 中最大的内存区域，存储所有对象实例和数组，是 GC 垃圾回收的核心区域；堆内存不足时抛OOM；堆又分为：新生代（Eden 区 + 两个 Survivor 区）、老年代；
方法区（元空间）：线程共享，存储类的元信息、常量、静态变量、编译后的字节码；JDK1.7 及以前叫永久代，JDK1.8 移除永久代，改用元空间（直接使用本地内存），解决永久代 OOM 问题。

2. 什么是 GC？垃圾回收的判断算法有哪些？

答：先答定义，再答算法，逻辑清晰：

GC：垃圾回收（Garbage Collection），是 JVM 的自动内存管理机制，无需程序员手动释放内存；GC 的核心是：识别内存中的「垃圾对象（不再被引用的对象）」，并回收其内存空间，避免内存溢出。
垃圾对象的判断算法（2 种核心）：① 引用计数法：给每个对象加引用计数器，被引用 + 1，引用释放 - 1，计数器为 0 则是垃圾；缺点：无法解决循环引用问题（比如 A 引用 B，B 引用 A，计数器都不为 0，永远不会被回收），Java 不使用该算法；② 可达性分析算法：Java 的官方核心算法；以「GC Roots」为根节点，向下遍历引用链，没有被根节点引用到的对象，就是垃圾对象；GC Roots 包括：虚拟机栈中的局部变量、静态变量、常量、native 方法中的引用等。

3. 常见的垃圾回收器有哪些？CMS 和 G1 的区别？

答：初级岗答常用的回收器，中高级岗答 CMS 和 G1 的区别即可，标准答案：

✅ 常用垃圾回收器（按新生代 / 老年代划分）

新生代回收器：SerialGC（串行）、ParNew（并行）、ParallelGC（并行回收）；新生代的回收算法是复制算法，效率高，内存利用率 50%；
老年代回收器：SerialOld（串行）、CMS（并发标记清除）、ParallelOld（并行）、G1（垃圾优先）；老年代的回收算法是标记清除 / 标记整理算法，内存利用率 100%。

✅ CMS 和 G1 的核心区别（必背，中高级岗高频）

CMS：并发标记清除，老年代专用，追求最短停顿时间，适合响应时间优先的场景（比如电商、接口服务）；优点：并发回收，停顿短；缺点：会产生内存碎片，并发阶段占用 CPU 资源，可能出现「Concurrent Mode Failure」；
G1：垃圾优先回收器，JDK1.9 的默认回收器，新生代 + 老年代通用，追求可控的停顿时间，适合大内存场景（8G 以上）；优点：把堆划分为多个 Region，优先回收垃圾多的 Region，无内存碎片，停顿时间可控；缺点：内存占用和 CPU 开销略高。

4. 内存溢出 (OOM) 和内存泄漏 (Memory Leak) 的区别？常见的 OOM 场景有哪些？

答：面试高频题，必考，答准定义 + 场景即可：

内存泄漏：对象已经不再被使用，但因为引用未释放，导致 GC 无法回收该对象，内存一直被占用；内存泄漏是 OOM 的前兆，长期泄漏会导致内存耗尽，触发 OOM；常见场景：静态集合持有对象引用、连接未关闭（数据库连接、IO 流）、匿名内部类持有外部类引用。
内存溢出 (OOM)：JVM 的内存空间被耗尽，无法为新对象分配内存，抛出OutOfMemoryError异常；内存泄漏会导致 OOM，但 OOM 不一定是内存泄漏（比如内存分配过小、大对象直接占满内存）。
常见的 OOM 场景：堆内存溢出（java.lang.OutOfMemoryError: Java heap space）、栈溢出（StackOverflowError）、元空间溢出（Metaspace）、直接内存溢出。

5. JVM 的调优参数有哪些常用的？

答：答出以下最常用的核心调优参数即可，不用背太多，面试官只看你是否实际用过：

-Xms：堆的初始内存，比如-Xms2g，建议和 - Xmx 设置相同，避免堆扩容的性能损耗；
-Xmx：堆的最大内存，比如-Xmx4g，这是最核心的调优参数；
-Xmn：新生代的内存大小，比如-Xmn1g，新生代占比越大，老年代越小；
-XX:SurvivorRatio：新生代中 Eden 区和 Survivor 区的比例，默认 8:1:1；
-XX:+UseG1GC：启用 G1 垃圾回收器；
-XX:+PrintGC：打印 GC 日志，排查内存问题必备。

四、多线程 + 并发编程核心必问（中高级岗必考，占面试分 20%，最难也最容易加分）

多线程是 Java 面试的重点和难点，初级岗问基础，中高级岗问深度，所有问题都是高频原题，答案都是精简版标准答案，背会就能答出高分！

1. 创建线程的四种方式？

答：标准答案，四种方式，按优先级排序，必背：

继承Thread类，重写run()方法，调用start()启动线程；缺点：Java 单继承，无法继承其他类；
实现Runnable接口，重写run()方法，把 Runnable 对象传入 Thread 构造器，调用start()启动；优点：可以实现多个接口，解耦线程和任务；
实现Callable接口，重写call()方法，配合FutureTask获取线程执行的返回值，支持抛出异常；这是唯一能获取返回值的方式；
使用线程池（ExecutorService）创建线程，比如Executors.newFixedThreadPool(5)；这是实际开发中最推荐的方式，优点：复用线程，避免频繁创建销毁线程的性能损耗，控制并发数，防止线程过多导致系统崩溃。

2. start () 和 run () 的区别？

答：高频基础题，一句话核心 + 补充细节，满分答案：

start()：是 Thread 类的方法，作用是启动一个新线程，线程进入就绪状态，等待 CPU 调度；不能重复调用，否则抛IllegalThreadStateException；
run()：是 Runnable 接口的方法，只是线程的任务逻辑，调用 run () 方法不会启动新线程，只是在当前线程中执行普通方法，可以重复调用；核心总结：调用 start () 才是真正创建线程，调用 run () 只是执行任务逻辑。

3. 线程的生命周期（状态）有哪些？

答：Java 线程的生命周期分为 6 种状态，定义在Thread.State枚举中，标准答案，按顺序答：

新建状态 (New)：创建 Thread 对象后，还未调用 start ()；
就绪状态 (Runnable)：调用 start () 后，线程等待 CPU 调度，具备执行条件；
运行状态 (Running)：CPU 调度线程，执行 run () 方法中的逻辑；
阻塞状态 (Blocked)：线程因竞争锁失败、IO 等待等原因，暂停执行，释放 CPU；
等待状态 (Waiting)：线程调用wait()、join()等方法，进入无时限等待，必须被其他线程唤醒才能继续；
超时等待 (Timed_Waiting)：线程调用sleep(long)、wait(long)等方法，进入有时限等待，超时自动唤醒；
终止状态 (Terminated)：线程执行完毕或异常退出，生命周期结束。

补充：线程的状态转换是面试加分点：就绪→运行→阻塞 / 等待→就绪→运行→终止。

4. synchronized 和 Lock 的区别？

答：并发编程最核心的面试题，必背，核心区别有 5 点，答全即满分：

归属不同：synchronized是 Java 的关键字，底层是 JVM 的原生锁机制；Lock是 Java 的接口（java.util.concurrent.locks），是手动实现的锁，有 ReentrantLock 等实现类；
锁的释放：synchronized是自动释放锁，线程执行完方法 / 代码块，或抛出异常时，自动释放锁，无需手动处理；Lock是手动释放锁，必须在finally块中调用unlock()，否则会造成死锁；
锁的获取：synchronized是阻塞式获取锁，线程获取不到锁就一直阻塞；Lock支持非阻塞式获取锁（tryLock()），还能设置超时时间，获取不到锁可以直接返回，避免死锁；
锁的类型：synchronized是可重入锁、非公平锁，无法手动设置公平性；Lock的实现类（ReentrantLock）是可重入锁，支持公平锁和非公平锁（构造器传入 true/false）；
性能：低并发场景下，两者性能差不多；高并发场景下，Lock 的性能远高于 synchronized。补充：实际开发中，优先用synchronized（简单、不易出错），高并发场景用 ReentrantLock。

5. 什么是线程池？为什么要用线程池？核心参数有哪些？

答：实际开发必用，面试必考，标准答案分三段，逻辑清晰：

✅ 什么是线程池？

线程池是管理线程的容器，提前创建好一批核心线程，当有任务时，直接从池中取线程执行，任务完成后线程归池复用，无需频繁创建销毁线程。Java 的线程池核心接口是ExecutorService，常用实现类是ThreadPoolExecutor。

✅ 为什么要用线程池？（3 个核心优点，必背）

降低资源消耗：复用线程，避免频繁创建销毁线程的性能损耗；
提高响应速度：任务来了直接用核心线程，无需等待线程创建；
便于统一管理：可以控制线程的数量、优先级、任务队列，避免线程过多导致系统崩溃。

✅ ThreadPoolExecutor 的七大核心参数（必背，中高级岗必考）

java

运行

public ThreadPoolExecutor(int corePoolSize, // 核心线程数（常驻线程，永不销毁） int maximumPoolSize, // 最大线程数（核心+非核心） long keepAliveTime, // 非核心线程的空闲存活时间 TimeUnit unit, // 存活时间的单位 BlockingQueue<Runnable> workQueue, // 任务队列（核心线程满了，任务入队） ThreadFactory threadFactory, // 线程创建工厂 RejectedExecutionHandler handler) // 拒绝策略（队列满+最大线程满，处理方式）

补充：拒绝策略有 4 种：AbortPolicy（抛异常，默认）、CallerRunsPolicy（调用者执行）、DiscardPolicy（丢弃任务）、DiscardOldestPolicy（丢弃队列最老的任务）。

五、数据库 + Spring 全家桶（开发必备，面试必问，占分 30%）

这部分是Java 开发的实战核心，所有岗位都必考，无例外！内容都是高频原题，答案精简，直击考点。

✅ 数据库高频必问（MySQL 为主）

MySQL 的三大存储引擎？InnoDB 和 MyISAM 的区别？答：核心存储引擎：InnoDB、MyISAM、MEMORY；最常用的是 InnoDB（MySQL5.5 及以后默认），核心区别：
- 事务支持：InnoDB 支持事务、ACID 特性；MyISAM 不支持事务；
- 锁机制：InnoDB 支持行级锁 + 表级锁，并发性能高；MyISAM 只支持表级锁，并发性能差；
- 外键：InnoDB 支持外键；MyISAM 不支持；
- 崩溃恢复：InnoDB 支持崩溃恢复，数据安全性高；MyISAM 不支持，崩溃后易丢数据；
- 索引：InnoDB 是聚簇索引，MyISAM 是非聚簇索引；结论：实际开发中优先用 InnoDB，适合业务系统；MyISAM 适合只读的场景（比如日志、报表）。
什么是索引？索引的优缺点？为什么建了索引查询还是慢？答：索引是 MySQL 的查询优化器，是对表中一列 / 多列的值进行排序的结构，作用是提升查询效率；
- 优点：大幅提升查询速度（尤其是大数据量），加速排序、分组；
- 缺点：增删改的速度变慢（需要维护索引），占用额外的磁盘空间；
- 索引失效的常见原因（建索引查得慢的核心）：① like 模糊查询以 % 开头；② 索引列做了函数运算；③ 索引列用了！=、<>；④ 多索引列的查询条件不满足最左匹配原则；⑤ 数据量太小，索引开销大于全表扫描。
事务的四大特性 (ACID)？事务的隔离级别？MySQL 默认隔离级别？答：必背，无例外：
- 事务四大特性：原子性 (A)、一致性 (C)、隔离性 (I)、持久性 (D)；✔ 原子性：事务中的操作要么全执行，要么全回滚；✔ 一致性：事务执行前后，数据的完整性不变；✔ 隔离性：多个事务并发执行时，互不干扰；✔ 持久性：事务提交后，数据永久保存到数据库，不会丢失；
- 事务隔离级别（从低到高）：读未提交、读已提交、可重复读、串行化；✔ 读未提交：能读到其他事务未提交的数据（脏读）；✔ 读已提交：能读到其他事务已提交的数据（不可重复读）；✔ 可重复读：同一个事务中，多次查询结果一致（解决不可重复读），MySQL 的默认隔离级别；✔ 串行化：事务串行执行，无并发问题，效率最低；
- 并发问题：脏读、不可重复读、幻读。

✅ Spring+SpringBoot+MyBatis 高频必问

Spring 的核心是什么？IOC 和 DI 的理解？答：Spring 的核心是 IOC（控制反转）和 AOP（面向切面编程）；
- IOC（控制反转）：把对象的创建、管理、依赖关系的维护，从程序员手中交给 Spring 容器管理；程序员不用手动 new 对象，由容器自动创建，降低代码耦合度；
- DI（依赖注入）：是实现 IOC 的核心方式；容器在创建对象时，自动将依赖的对象注入到当前对象中，比如@Autowired注解就是依赖注入；核心总结：IOC 是思想，DI 是实现方式。
Spring 的 Bean 的作用域有哪些？默认是什么？答：5 种作用域，必背：
- singleton：单例，默认作用域；容器中只有一个 Bean 实例，全局共享；
- prototype：多例；每次获取 Bean 时，都创建一个新的实例；
- request：每次 HTTP 请求创建一个实例，仅在 Web 环境生效；
- session：每个会话创建一个实例，仅在 Web 环境生效；
- application：整个应用共享一个实例，仅在 Web 环境生效。
SpringBoot 的核心优点？自动配置的原理？答：SpringBoot 是对 Spring 的封装，核心是简化配置、快速开发；
- 核心优点：① 自动配置（无需手动写 xml 配置）；② 起步依赖（maven 一键引入相关依赖）；③ 内嵌 Tomcat，无需部署；④ 简化监控、日志等配置；
- 自动配置原理：核心是 @SpringBootApplication 注解，该注解是组合注解，包含@EnableAutoConfiguration；通过 Spring 的 SPI 机制，扫描META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中的自动配置类，根据 pom 中的依赖，自动加载对应的配置。
MyBatis 中 #{} 和 ${} 的区别？答：必问，开发中必用，核心是防 SQL 注入：
- #{}：是预编译占位符，会把参数值作为字符串拼接，自动加引号，能防止 SQL 注入，效率高，推荐使用；
- ${}：是字符串直接拼接，不会加引号，不能防止 SQL 注入，但可以用于动态拼接表名、列名等场景（比如排序字段）；举例：select * from user where id=#{id} → 编译为select * from user where id=?；select * from user where id=${id} → 编译为select * from user where id=1。

六、项目 + 场景题 + HR 综合题（所有级别必问，决定是否录用，分值占比极高）

✅ 重点提醒：技术面通过后，这部分决定最终是否录用和薪资定级，比技术题更重要！所有问题都有标准答案，背会即可。

✅ 项目高频必问（通用万能回答模板，适配所有项目）

说说你做的这个项目的整体架构？你负责了哪些模块？答：先讲整体架构（比如：采用 SpringBoot+SpringMVC+MyBatis+MySQL+Redis+RabbitMQ 的微服务架构，前端用 Vue，后端分层开发），再讲自己负责的模块（比如：用户模块、订单模块、支付模块、商品模块），最后讲自己在模块中做的核心功能（比如：用户登录注册、订单生成、支付回调、商品分页查询），一定要突出自己的核心贡献。
项目中遇到的最大问题是什么？你是怎么解决的？答：万能标准答案（选一个即可，真实可信，体现解决问题的能力）：
- 问题 1：查询大数据量的列表时，页面加载很慢，接口响应超时；解决：① 给查询字段加索引；② 用分页查询（limit）；③ 优化 SQL，避免联表查询过多；④ 引入 Redis 做缓存，把热点数据缓存起来，查询效率提升 80%。
- 问题 2：高并发场景下，订单重复提交，出现超卖；解决：① 前端加按钮禁用，防止重复点击；② 后端用 Redis 的分布式锁，保证同一用户同一订单只能提交一次；③ 数据库加唯一索引，防止重复插入。
- 问题 3：项目上线后出现 OOM 内存溢出；解决：① 查看 GC 日志，分析内存泄漏的原因；② 用 JProfiler 工具定位内存泄漏的对象；③ 优化代码，释放无用的对象引用，调整 JVM 的堆内存参数，最终解决问题。
项目中用到了哪些设计模式？说说你对单例模式的理解？答：实际开发中常用的设计模式：单例模式、工厂模式、装饰器模式、适配器模式、观察者模式；单例模式：保证一个类在整个应用中只有一个实例，核心是私有化构造器，提供静态方法获取实例；常见的实现方式：饿汉式（线程安全，加载快）、懒汉式（线程不安全，需加锁）、双重检查锁（DCL，线程安全，懒加载，推荐）、静态内部类（最优）。

✅ 场景题高频必问（通用标准答案）

如何解决分布式系统中的接口幂等性问题？答：幂等性：同一个请求，多次调用的结果一致，不会产生副作用；解决方式（按优先级排序）：① 前端：按钮禁用、防重复提交；② 后端：唯一订单号 / 请求号、Redis 分布式锁、数据库唯一索引、乐观锁（version 字段）、token 令牌机制。
如何解决分布式锁的问题？有哪些实现方式？答：分布式锁的核心是：保证分布式系统中多个服务对同一资源的互斥访问；实现方式：① Redis 分布式锁（setnx + 过期时间，推荐，性能高）；② Zookeeper 分布式锁（基于临时节点，可靠性高）；③ 数据库乐观锁 / 悲观锁（性能低，适合低并发）。

✅ HR 综合题（必问，标准答案，满分回答）

为什么离职？答：万能标准答案（绝对不要说上家公司的坏话，比如加班多、薪资低、领导不好）：① 想寻求更好的发展空间，提升自己的技术能力；② 贵公司的业务方向和我的技术栈匹配，想加入贵公司，为团队贡献价值；③ 希望在更大的平台上，接触更多的项目和技术，实现个人成长。
你的优点和缺点是什么？答：优点：① 学习能力强，能快速掌握新技术；② 责任心强，对待工作认真负责，能按时完成任务；③ 团队协作能力好，能和同事高效沟通，共同解决问题。缺点：① 经验方面，对于某些高端技术（比如微服务的链路追踪）还在学习中，但我会利用业余时间快速补齐；② 做事比较追求细节，有时候会在细节上花费较多时间，但我已经在调整，学会把握重点。
你的职业规划是什么？答：标准答案（分短期和长期，体现稳定性和上进心）：短期：入职后快速熟悉公司的业务和技术栈，做好本职工作，成为一名合格的 Java 开发工程师；长期：深耕 Java 后端开发，不断学习微服务、分布式、架构设计等技术，成为一名资深的 Java 开发工程师 / 架构师，为公司的发展贡献力量。
你期望的薪资是多少？答：根据自己的工作经验和当地的薪资水平，报一个合理的区间，比如：1-3 年经验，期望薪资 15-20k；3-5 年经验，期望薪资 20-30k；应届生，期望薪资 8-12k。同时补充：薪资不是唯一的考虑因素，更看重公司的发展平台和团队氛围。

最后总结（面试通关秘籍）

本文的所有问题都是 Java 开发工程师面试的高频原题，覆盖了从应届生到资深架构师的所有考点，背会这些问题和答案，面试通过率至少提升 90%；
回答面试题的核心技巧：结论先行，再讲原理，最后补充细节 / 优缺点 / 使用场景，不要只说结论，面试官更看重你的逻辑思维和技术深度；
技术面试的本质：考察你的基础是否扎实、是否有实战经验、是否有解决问题的能力，心态放平，自信回答即可。

一、Java 基础核心必问（初级 / 应届生 重中之重，占面试分 40%，100% 问到）