一、Java基础：语言特性的深度考察

1.1 面向对象编程三大特性

封装、继承、多态是Java面试的高频考点。以多态为例，需理解方法重写（Override）与方法重载（Overload）的本质区别：

class Animal {
    public void sound() { System.out.println("Animal sound"); }
}
class Dog extends Animal {
    @Override
    public void sound() { System.out.println("Bark"); } // 方法重写
    public void sound(String type) { // 方法重载
        System.out.println(type + " sound");
    }
}

面试官常通过代码片段考察对@Override注解的理解，以及运行时多态的实现机制（虚方法表）。

1.2 集合框架底层原理

ArrayList与LinkedList的对比需从时间复杂度、内存占用、线程安全三个维度展开：

• ArrayList：基于动态数组，随机访问O(1)，插入删除O(n)
• LinkedList：双向链表结构，随机访问O(n)，头尾插入O(1)

HashMap的1.8版本优化是必考题，需掌握：

• 链表转红黑树的阈值（8）
• 扩容时头插法改为尾插法的改进
• 容量计算公式：capacity = 2^n

二、JVM核心：内存与执行机制

2.1 内存模型与垃圾回收

JVM内存模型分为五大部分：

• 方法区：存储类元数据（1.8后移至元空间）
• 堆：对象实例分配区（新生代/老年代）
• 栈：线程私有，存储局部变量表
• 程序计数器：线程私有，记录执行字节码行号
• 本地方法栈：Native方法执行区

垃圾回收算法对比：
| 算法 | 原理 | 适用场景 |
|——————|—————————————|————————————|
| 标记-清除 | 标记无用对象后清除 | 早期JVM |
| 复制算法 | 将存活对象复制到新区域 | 新生代Survivor区 |
| 标记-整理 | 压缩存活对象减少碎片 | 老年代 |

2.2 类加载机制双亲委派模型

类加载过程分为加载、验证、准备、解析、初始化五个阶段。双亲委派模型通过ClassLoader.loadClass()方法实现：

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            try {
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父类加载失败时尝试自身加载
            }
            if (c == null) {
                c = findClass(name);
            }
        }
        return c;
    }
}

该模型防止核心类被篡改，但可通过线程上下文类加载器突破限制。

三、并发编程：多线程实战技巧

3.1 线程安全实现方式

• 同步机制：synchronized关键字（对象锁/类锁）
• 显式锁：ReentrantLock的公平锁与非公平锁
• 原子类：AtomicInteger的CAS操作

  // 原子类实现线程安全计数器
  AtomicInteger counter = new AtomicInteger(0);
  public void increment() {
    counter.incrementAndGet(); // CAS保证原子性
  }

3.2 线程池参数配置

ThreadPoolExecutor核心参数：

int corePoolSize = 5;    // 核心线程数
int maxPoolSize = 10;     // 最大线程数
long keepAliveTime = 60;  // 空闲线程存活时间
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(100);
ExecutorService executor = new ThreadPoolExecutor(
    corePoolSize, maxPoolSize, keepAliveTime, 
    TimeUnit.SECONDS, workQueue, new ThreadPoolExecutor.AbortPolicy()
);

拒绝策略包含AbortPolicy（抛异常）、CallerRunsPolicy（调用者执行）等四种实现。

四、框架与架构：Spring生态解析

4.1 Spring IOC容器原理

依赖注入的三种方式：

• 构造器注入：@Autowired + 构造方法
• Setter注入：@Autowired + setter方法
• 字段注入：@Autowired直接修饰字段（不推荐）

Bean生命周期包含实例化、属性填充、初始化、销毁等阶段，可通过InitializingBean接口或@PostConstruct注解实现初始化逻辑。

4.2 Spring AOP实现机制

AOP基于动态代理实现，分为JDK动态代理（接口代理）和CGLIB代理（类代理）：

// JDK动态代理示例
public class LoggingProxy implements InvocationHandler {
    private Object target;
    public Object bind(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this
        );
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        return method.invoke(target, args);
    }
}

五、系统设计：高并发场景解决方案

5.1 分布式锁实现

Redis分布式锁的核心实现：

// 使用SETNX实现分布式锁
public boolean tryLock(String key, String value, long expire) {
    String result = redisTemplate.opsForValue().setIfAbsent(key, value, expire, TimeUnit.SECONDS);
    return Boolean.TRUE.equals(result);
}
// 解锁时需验证持有者
public void unlock(String key, String value) {
    String current = redisTemplate.opsForValue().get(key);
    if (value.equals(current)) {
        redisTemplate.delete(key);
    }
}

需注意锁续期、误删等边界问题。

5.2 限流算法对比

算法	原理	实现复杂度	内存占用
计数器	固定时间窗口计数	低	低
滑动窗口	动态时间窗口计数	中	中
令牌桶	固定速率生成令牌	高	中
漏桶算法	固定速率处理请求	高	低

Guava RateLimiter基于令牌桶算法实现平滑限流。

六、面试策略：高效备考方法论

1. 知识图谱构建：使用XMind梳理Java知识体系，标注高频考点
2. 真题实战训练：每日完成3-5道LeetCode中等难度算法题
3. 项目经验提炼：准备3个核心项目，重点说明技术选型与优化点
4. 模拟面试演练：通过CodePen等平台进行代码实时编写测试
5. 软技能提升：掌握STAR法则描述项目经历，训练清晰表达能力

建议采用”3-3-1”时间分配法：30%基础巩固，30%算法训练，10%框架原理，30%系统设计。通过持续迭代知识体系，构建面试时的技术自信。