java编程 教程 基础
首页|语法|OOP|集合|并发|JVM|工具|面试

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为强类型语言,所有变量必须显式声明类型。数据类型分为两大类:

类别类型占用字节默认值示例
基本类型byte10byte b = 127;
基本类型short20short s = 32767;
基本类型int40int i = 2147483647;
基本类型long80Llong l = 9223372036854775807L;
基本类型float40.0ffloat f = 3.14159f;
基本类型double80.0ddouble d = 3.141592653589793;
基本类型char2\u0000char c = 'A';
基本类型boolean1位falseboolean flag = true;
引用类型类引用大小nullString s = "Hello";
引用类型接口引用大小nullRunnable r = () -> {};
引用类型数组引用大小nullint[] 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万次操作):

操作ArrayListLinkedList
尾部插入O(1) amortizedO(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):

  • 若需读取数据 → 使用
  • 若需写入数据 → 使用
  • 若同时读写 → 不使用通配符

示例:集合拷贝

public static  void copy(List src, List 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 线程创建与生命周期

创建线程三种方式:

  1. 继承Thread类(单继承限制)
  2. 实现Runnable接口(推荐,避免单继承限制)
  3. 实现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+替代永久代)

对象创建过程:

  1. 类加载检查(是否已加载)
  2. 分配内存(指针碰撞/空闲列表)

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:+HeapDumpOnOutOfMemoryErrorOOM时生成堆转储-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区别?

特性synchronizedReentrantLock
锁类型内置锁显式锁
释放方式自动释放需手动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调优思路?

  1. 收集监控数据(GC日志、JVM参数)
  2. 确定目标(低延迟/高吞吐)
  3. 选择收集器(G1/ZGC)
  4. 调整堆大小与代比例
  5. 验证调优效果

7.6 实战项目:电商库存系统

需求描述:

  • 实现高并发库存扣减(秒杀场景)
  • 防止超卖(库存不足)
  • 保证数据一致性

技术方案:

  1. 数据库层:乐观锁(version字段)
  2. 缓存层:Redis预减库存(原子操作)
  3. 消息队列:异步扣减库存(解耦)
  4. 限流降级: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"));

压测结果:

指标单机TomcatRedis+MQ方案
TPS1208500
平均响应时间2800ms45ms
超卖率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的竞争力分析?