Java 开发工程师面试高频问题与参考答案

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

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

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

8. final 关键字的作用？

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

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

二、集合框架核心必问

集合是 Java 开发的核心工具，必须掌握标准答案。

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

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

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

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

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

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

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

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

4. HashMap 和 HashTable 的区别？

答：4 个核心区别：

1. 线程安全：HashMap 线程不安全，无同步锁，效率高；HashTable 线程安全，所有方法都加了 synchronized，效率低；
2. 取值支持：HashMap 允许 null 键和 null 值；HashTable 不允许，否则抛出空指针异常；
3. 底层实现：HashMap 是数组 + 链表 + 红黑树（1.8）；HashTable 是数组 + 链表；
4. 初始容量和扩容：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 虚拟机核心必问

JVM 是 Java 面试的关键部分，中高级岗必问深度考点。

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

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

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

1. CMS：并发标记清除，老年代专用，追求最短停顿时间，适合响应时间优先的场景（比如电商、接口服务）；优点：并发回收，停顿短；缺点：会产生内存碎片，并发阶段占用 CPU 资源，可能出现「Concurrent Mode Failure」；
2. 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 的调优参数有哪些常用的？

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

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

四、多线程 + 并发编程核心必问

多线程是 Java 面试的重点和难点，初级岗问基础，中高级岗问深度。

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

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

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

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

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

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

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

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

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

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

4. synchronized 和 Lock 的区别？

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

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

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

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

✅ 什么是线程池？

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

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

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

✅ ThreadPoolExecutor 的七大核心参数

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

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

五、数据库 + Spring 全家桶

这部分是 Java 开发的实战核心，所有岗位都必考。

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

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

✅ Spring+SpringBoot+MyBatis 高频必问

1. Spring 的核心是什么？IOC 和 DI 的理解？ 答：Spring 的核心是 IOC（控制反转）和 AOP（面向切面编程）；
   • IOC（控制反转）：把对象的创建、管理、依赖关系的维护，从程序员手中交给 Spring 容器管理；程序员不用手动 new 对象，由容器自动创建，降低代码耦合度；
   • DI（依赖注入）：是实现 IOC 的核心方式；容器在创建对象时，自动将依赖的对象注入到当前对象中，比如 @Autowired 注解就是依赖注入；核心总结：IOC 是思想，DI 是实现方式。
2. Spring 的 Bean 的作用域有哪些？默认是什么？ 答：5 种作用域，必背：
   • singleton：单例，默认作用域；容器中只有一个 Bean 实例，全局共享；
   • prototype：多例；每次获取 Bean 时，都创建一个新的实例；
   • request：每次 HTTP 请求创建一个实例，仅在 Web 环境生效；
   • session：每个会话创建一个实例，仅在 Web 环境生效；
   • application：整个应用共享一个实例，仅在 Web 环境生效。
3. SpringBoot 的核心优点？自动配置的原理？ 答：SpringBoot 是对 Spring 的封装，核心是简化配置、快速开发；
   • 核心优点：① 自动配置（无需手动写 xml 配置）；② 起步依赖（maven 一键引入相关依赖）；③ 内嵌 Tomcat，无需部署；④ 简化监控、日志等配置；
   • 自动配置原理：核心是 @SpringBootApplication 注解，该注解是组合注解，包含 @EnableAutoConfiguration；通过 Spring 的 SPI 机制，扫描 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件中的自动配置类，根据 pom 中的依赖，自动加载对应的配置。
4. 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 综合题

重点提醒：技术面通过后，这部分决定最终是否录用和薪资定级，比技术题更重要！

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

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

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

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

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

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

最后总结

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