当前位置：首页 > news >正文

Java基础八股文 - 面试者心理历程与标准答案

news 2025/6/23 7:21:16

Java基础八股文 - 面试者心理历程与标准答案

前言：如何应对Java基础面试问题

面试Java基础时，很多候选人会因为紧张而忘记平时熟悉的知识点。本文将从面试者的心理历程出发，教你如何在面试中用自己的思路组织答案，然后给出标准回答供参考。

一、面向对象三大特性

问题：请说说Java面向对象的三大特性

🧠 面试者内心OS：
“这个问题很基础，但是要说得有条理。我知道是封装、继承、多态，但怎么说得更有深度呢？要结合实际例子，不能只是背概念。”

💡 回答思路指导：

先说出三大特性的名称
每个特性都要解释概念+举例+优势
最好能结合实际项目场景
体现出你对OOP思想的理解

✅ 标准回答：

Java面向对象有三大特性：封装、继承、多态。

封装（Encapsulation）：

概念：将数据和操作数据的方法绑定在一起，对外隐藏内部实现细节
实现：通过private关键字隐藏属性，通过public方法提供访问接口
举例：在我们的User类中，将用户ID设为private，通过getId()和setId()方法访问
优势：提高代码安全性，降低耦合度，便于维护

继承（Inheritance）：

概念：子类可以继承父类的属性和方法，实现代码复用
实现：通过extends关键字实现继承
举例：Animal父类定义了eat()方法，Dog子类继承后可以直接使用，也可以重写
优势：代码复用，建立类之间的层次关系

多态（Polymorphism）：

概念：同一个接口，不同的实现类有不同的行为
实现：通过方法重写(Override)和接口实现
举例：Shape接口的draw()方法，Circle和Rectangle实现不同的绘制逻辑
优势：提高代码的灵活性和可扩展性

这三个特性让Java具有了良好的代码组织结构和可维护性。

二、基本数据类型与引用类型

问题：Java有哪些基本数据类型？基本类型和引用类型的区别是什么？

🧠 面试者内心OS：
“8种基本数据类型我要记对，别搞错了字节数。引用类型的区别主要是内存分配和赋值方式不同，要说清楚栈和堆的概念。”

💡 回答思路指导：

先列出8种基本数据类型和字节数
说明存储位置的不同
举例说明赋值行为的差异
提到包装类和自动装箱拆箱

✅ 标准回答：

Java有8种基本数据类型：

整型：byte(1字节)、short(2字节)、int(4字节)、long(8字节)
浮点型：float(4字节)、double(8字节)
字符型：char(2字节)
布尔型：boolean(1字节)

基本类型vs引用类型的区别：

存储位置不同：
- 基本类型：直接存储在栈内存中
- 引用类型：对象存储在堆内存中，栈中存储对象的引用地址

赋值行为不同：

// 基本类型：值拷贝
int a = 10;
int b = a;  // b得到a的值的副本
a = 20;     // a改变，b不变，b仍为10// 引用类型：引用拷贝
List<String> list1 = new ArrayList<>();
List<String> list2 = list1;  // list2指向同一个对象
list1.add("hello");          // list2也能看到这个元素

默认值不同：
- 基本类型有默认值（如int默认0，boolean默认false）
- 引用类型默认值为null
比较方式不同：
- 基本类型用==比较值
- 引用类型用==比较引用地址，用equals()比较内容

另外，Java为每种基本类型提供了对应的包装类，支持自动装箱拆箱。

三、String类详解

问题：String为什么设计成不可变的？String、StringBuilder、StringBuffer的区别？

🧠 面试者内心OS：
“String的不可变性是个经典问题，要从内存安全、线程安全、hashCode缓存等角度来说。StringBuilder和StringBuffer的区别主要是线程安全性，还要提到性能问题。”

💡 回答思路指导：

先解释String不可变的设计原因
从源码角度说明不可变性的实现
对比三者的使用场景和性能
提到字符串常量池的概念

✅ 标准回答：

String不可变的设计原因：

安全性：String经常用作参数，如果可变可能导致安全问题
线程安全：不可变对象天然线程安全，无需同步
HashCode缓存：String的hashCode只需计算一次，提高HashMap等性能
字符串常量池：相同内容的字符串可以共享内存空间

实现方式：

String内部用final char[]数组存储字符
没有提供修改内部状态的方法
所有"修改"操作都返回新的String对象

三者对比：

特性	String	StringBuffer	StringBuilder
可变性	不可变	可变	可变
线程安全	安全	安全(synchronized)	不安全
性能	拼接时创建新对象，性能差	中等	最好
使用场景	字符串不经常变化	多线程环境下频繁修改	单线程环境下频繁修改

使用建议：

字符串不变或少量改变：使用String
单线程下大量字符串操作：使用StringBuilder
多线程下大量字符串操作：使用StringBuffer
循环中拼接字符串：绝对不要用String的+操作

四、equals()和hashCode()方法

问题：为什么重写equals()时必须重写hashCode()？

🧠 面试者内心OS：
“这个问题涉及到HashMap的实现原理，我要从hash表的角度来解释。重点是equals相等的对象hashCode也必须相等，否则在HashMap中会出现问题。”

💡 回答思路指导：

先说明equals和hashCode的关系契约
从HashMap的工作原理解释为什么要同时重写
举例说明不重写hashCode的后果
提到重写的最佳实践

✅ 标准回答：

核心原因：Java的equals-hashCode契约

Object类定义了equals和hashCode的契约：

如果两个对象equals相等，那么hashCode必须相等
如果两个对象equals不相等，hashCode可以相等也可以不相等
如果两个对象hashCode不相等，那么equals一定不相等

为什么必须同时重写：

这个契约是为了支持基于hash的集合类（HashMap、HashSet等）。这些集合的工作原理：

先通过hashCode()计算对象应该存储在哪个桶(bucket)
如果桶中已有对象，才用equals()逐一比较

不重写hashCode的后果：

public class Person {private String name;private int age;// 只重写了equals，没重写hashCode@Overridepublic boolean equals(Object obj) {if (this == obj) return true;if (obj == null || getClass() != obj.getClass()) return false;Person person = (Person) obj;return age == person.age && Objects.equals(name, person.name);}
}// 问题演示
Person p1 = new Person("张三", 25);
Person p2 = new Person("张三", 25);System.out.println(p1.equals(p2));  // true
System.out.println(p1.hashCode() == p2.hashCode());  // false！// 在HashMap中的问题
Map<Person, String> map = new HashMap<>();
map.put(p1, "第一个张三");
System.out.println(map.get(p2));  // null！应该返回"第一个张三"

正确的重写方式：

@Override
public int hashCode() {return Objects.hash(name, age);
}

重写最佳实践：

使用Objects.hash()方法生成hashCode
参与equals比较的字段都应该参与hashCode计算
考虑使用IDE或lombok自动生成
确保hashCode的计算相对高效

五、异常处理机制

问题：Java异常处理机制是怎样的？Checked异常和Unchecked异常的区别？

🧠 面试者内心OS：
“异常处理要从Exception的继承体系开始说，Error和Exception的区别，还有编译时异常和运行时异常。要提到try-catch-finally的执行顺序，还有try-with-resources。”

💡 回答思路指导：

先画出异常的继承体系
区分Error、Checked Exception、Unchecked Exception
解释异常处理的关键字和机制
提到异常处理的最佳实践

✅ 标准回答：

Java异常体系结构：

Throwable
├── Error (系统级错误，不建议捕获)
│   ├── OutOfMemoryError
│   ├── StackOverflowError
│   └── VirtualMachineError
└── Exception├── Checked Exception (编译时异常，必须处理)│   ├── IOException│   ├── SQLException│   └── ClassNotFoundException└── RuntimeException (运行时异常，可选处理)├── NullPointerException├── ArrayIndexOutOfBoundsException└── IllegalArgumentException

异常类型区别：

Error：
- 系统级严重错误，如内存溢出
- 程序无法恢复，不建议捕获处理
- 通常由JVM抛出
Checked Exception：
- 编译时异常，必须显式处理（try-catch或throws）
- 预期可能发生的异常，如文件不存在
- 强制开发者考虑异常处理
Unchecked Exception：
- 运行时异常，可以不显式处理
- 通常是编程错误导致，如空指针
- 继承自RuntimeException

异常处理机制：

抛出异常：使用throw关键字主动抛出
声明异常：使用throws关键字在方法签名中声明
捕获异常：使用try-catch语句捕获处理
finally块：无论是否发生异常都会执行

执行顺序：

try {// 可能抛出异常的代码return "try";
} catch (Exception e) {// 异常处理return "catch";
} finally {// 无论如何都会执行// 注意：finally中的return会覆盖try/catch中的return
}

最佳实践：

具体异常处理：捕获具体的异常类型，而不是Exception
记录异常信息：使用日志记录异常堆栈
不要忽略异常：空的catch块是很危险的做法
使用try-with-resources：自动关闭资源
自定义异常：业务相关的异常应该自定义

try-with-resources示例：

try (FileInputStream fis = new FileInputStream("file.txt")) {// 使用资源
} catch (IOException e) {// 处理异常
}
// 资源自动关闭，即使发生异常

六、Java集合框架

问题：说说Java集合框架的整体架构，ArrayList和LinkedList的区别？

🧠 面试者内心OS：
“集合框架是重点，要从Collection和Map两大接口说起。ArrayList和LinkedList的区别主要是底层数据结构，我要从时间复杂度、内存占用、适用场景等方面来对比。”

💡 回答思路指导：

先说集合框架的整体架构
详细对比ArrayList和LinkedList
从源码角度解释底层实现
总结使用场景

✅ 标准回答：

Java集合框架架构：

Collection接口
├── List (有序，可重复)
│   ├── ArrayList (动态数组)
│   ├── LinkedList (双向链表)
│   └── Vector (线程安全的动态数组)
├── Set (无序，不可重复)
│   ├── HashSet (基于HashMap)
│   ├── LinkedHashSet (保持插入顺序)
│   └── TreeSet (排序集合)
└── Queue (队列)├── ArrayDeque (数组双端队列)└── PriorityQueue (优先级队列)Map接口 (键值对)
├── HashMap (哈希表)
├── LinkedHashMap (保持插入顺序)
├── TreeMap (红黑树，排序)
└── ConcurrentHashMap (线程安全)

ArrayList vs LinkedList 详细对比：

特性	ArrayList	LinkedList
底层结构	动态数组(Object[])	双向链表(Node)
随机访问	O(1) - 直接索引访问	O(n) - 需要遍历
插入删除(中间)	O(n) - 需要移动元素	O(1) - 改变指针
插入删除(末尾)	O(1) - 通常情况	O(1) - 直接操作
内存占用	较少 - 只存储元素	较多 - 额外存储指针
缓存局部性	好 - 数组连续存储	差 - 链表分散存储

底层实现关键点：

ArrayList：

默认初始容量10
扩容机制：新容量 = 旧容量 * 1.5
使用System.arraycopy()进行元素移动
支持快速随机访问

LinkedList：

双向链表结构，每个节点包含data、prev、next
同时实现了List和Deque接口
插入删除只需要改变节点的指针指向
不支持随机访问，需要遍历

源码核心：

// ArrayList 扩容
private void grow(int minCapacity) {int oldCapacity = elementData.length;int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5倍扩容if (newCapacity - minCapacity < 0)newCapacity = minCapacity;elementData = Arrays.copyOf(elementData, newCapacity);
}// LinkedList 节点结构
private static class Node<E> {E item;Node<E> next;Node<E> prev;Node(Node<E> prev, E element, Node<E> next) {this.item = element;this.next = next;this.prev = prev;}
}

使用场景选择：

选择ArrayList：

频繁随机访问元素（通过索引）
遍历操作较多
内存敏感的场景
元素数量相对固定

选择LinkedList：

频繁在中间插入删除元素
不需要随机访问
实现队列或栈的功能
元素数量变化较大

性能测试建议：
在实际项目中，由于CPU缓存的影响，ArrayList在大多数情况下性能都优于LinkedList，即使是插入删除操作。只有在非常频繁的头部插入删除场景下，LinkedList才可能有优势。

七、HashMap深度解析

问题：HashMap的底层实现原理是什么？JDK1.7和1.8有什么区别？

🧠 面试者内心OS：
“HashMap是必考题，要从hash函数、数组+链表结构、扩容机制等方面来说。JDK1.8的红黑树优化是重点，还要提到线程安全问题。”

💡 回答思路指导：

先说明HashMap的基本原理
详细解释put和get的过程
对比JDK1.7和1.8的区别
讨论线程安全和性能优化

✅ 标准回答：

HashMap基本原理：

HashMap基于哈希表实现，采用"数组+链表+红黑树"的数据结构。

核心组成：

Node数组：存储键值对的桶(bucket)
链表：解决hash冲突
红黑树：JDK1.8优化，链表长度≥8时转换

关键参数：

默认初始容量：16
负载因子：0.75
树化阈值：8
反树化阈值：6

put操作流程：

计算key的hash值：hash(key)
根据hash值计算在数组中的索引：(n-1) & hash
如果桶为空，直接插入
如果桶不为空：
- 如果key相同，替换value
- 如果是树节点，按红黑树方式插入
- 如果是链表，遍历链表插入（尾插法）
插入后检查是否需要扩容

get操作流程：

计算key的hash值
根据hash值定位到桶
在桶中查找：
- 如果是树节点，按红黑树查找
- 如果是链表，遍历链表查找

JDK1.7 vs JDK1.8 重要区别：

特性	JDK1.7	JDK1.8
数据结构	数组+链表	数组+链表+红黑树
插入方式	头插法	尾插法
hash算法	4次位运算+5次异或	1次位运算+1次异或
扩容优化	重新计算hash	高位bit决定位置
线程安全	头插法可能死循环	尾插法避免死循环

红黑树优化（JDK1.8）：

当链表长度≥8且数组长度≥64时，链表转红黑树
当红黑树节点≤6时，红黑树退化为链表
查找时间复杂度从O(n)优化到O(log n)

扩容机制：

// JDK1.8 扩容优化
final Node<K,V>[] resize() {Node<K,V>[] oldTab = table;int oldCap = (oldTab == null) ? 0 : oldTab.length;int newCap = oldCap << 1; // 容量翻倍// 重新分配节点if ((e.hash & oldCap) == 0) {// 保持原位置} else {// 移动到 原位置+oldCap}
}

hash函数优化：

// JDK1.8 hash函数
static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

高16位与低16位异或，减少hash冲突。

线程安全问题：

HashMap非线程安全
并发put可能导致数据丢失
JDK1.7扩容时头插法可能造成死循环
解决方案：
- 使用ConcurrentHashMap
- 使用Collections.synchronizedMap()
- 外部加锁

性能优化建议：

合理设置初始容量，避免频繁扩容
选择合适的负载因子
重写equals和hashCode保证分布均匀
避免在多线程环境使用HashMap

八、反射机制

问题：什么是Java反射？反射的应用场景和性能问题？

🧠 面试者内心OS：
“反射是Java的重要特性，要从概念、使用方式、应用场景来说。性能问题也要提到，还有安全性问题。最好能结合框架的使用来举例。”

💡 回答思路指导：

解释反射的概念和原理
展示反射的基本使用方法
分析反射的优缺点
结合实际应用场景说明

✅ 标准回答：

反射的概念：

反射(Reflection)是Java在运行时检查和操作类、接口、字段、方法的能力。通过反射，程序可以在运行时获取类的信息，创建对象，调用方法，访问字段，而不需要在编译时确定这些操作。

反射的核心类：

Class：代表类或接口
Constructor：代表构造方法
Method：代表方法
Field：代表字段
Parameter：代表方法参数

反射的基本使用：

// 1. 获取Class对象的三种方式
Class<?> clazz1 = Person.class;                    // 类字面量
Class<?> clazz2 = Class.forName("com.example.Person"); // 全限定名
Class<?> clazz3 = person.getClass();               // 对象获取// 2. 创建对象
Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
Object obj = constructor.newInstance("张三", 25);// 3. 调用方法
Method method = clazz.getMethod("getName");
Object result = method.invoke(obj);// 4. 访问字段
Field field = clazz.getDeclaredField("name");
field.setAccessible(true); // 访问私有字段
field.set(obj, "李四");

反射的应用场景：

框架开发：
- Spring的依赖注入：通过反射创建Bean实例
- MyBatis的结果映射：通过反射设置对象属性
- Hibernate的ORM映射：通过反射操作实体对象
序列化/反序列化：
- JSON库(Jackson、Gson)通过反射转换对象
- 自定义序列化逻辑
注解处理：
- 运行时读取注解信息
- 实现AOP切面编程
动态代理：
- JDK动态代理基于反射机制
- 实现接口的运行时代理
测试框架：
- JUnit通过反射执行测试方法
- 访问私有方法进行单元测试
配置文件解析：
- 根据配置动态创建对象
- 属性文件到对象的映射

反射的优缺点：

优点：

提高程序的灵活性和通用性
实现动态编程，运行时决定行为
框架开发的基础技术
支持通用的对象处理逻辑

缺点：

性能开销：
- 反射操作比直接调用慢10-100倍
- 涉及动态解析和安全检查
安全性问题：
- 可以访问私有成员，破坏封装性
- 可能绕过类型检查
代码可读性差：
- 编译时无法检查错误
- 调试困难
维护性问题：
- 重构时容易遗漏反射相关代码
- IDE支持不够好

性能优化建议：

缓存反射对象：

// 缓存Class、Method、Field对象
private static final Map<String, Method> methodCache = new ConcurrentHashMap<>();public static Method getMethod(Class<?> clazz, String methodName) {String key = clazz.getName() + "#" + methodName;return methodCache.computeIfAbsent(key, k -> {try {return clazz.getMethod(methodName);} catch (NoSuchMethodException e) {throw new RuntimeException(e);}});
}

避免频繁的反射调用：
- 在循环外获取Method对象
- 使用MethodHandle(JDK7+)替代反射
关闭安全检查：

method.setAccessible(true); // 关闭访问检查，提高性能

反射在项目中的实际应用：

在我们的BigPrime项目中，反射主要用于：

数据库结果集到实体对象的映射
注解驱动的参数校验
动态数据源的创建和配置
插件系统的动态加载

反射是Java的强大特性，但要谨慎使用，在性能敏感的场景下要考虑替代方案。

九、泛型机制

问题：Java泛型是什么？泛型擦除是怎么回事？

🧠 面试者内心OS：
“泛型是类型安全的重要机制，要说清楚泛型的作用、通配符的使用，还有泛型擦除的概念。PECS原则也要提到。”

💡 回答思路指导：

解释泛型的概念和作用
介绍泛型的使用方式
重点解释泛型擦除机制
讨论泛型的限制和最佳实践

✅ 标准回答：

泛型的概念和作用：

泛型(Generics)是JDK5引入的特性，允许在定义类、接口、方法时使用类型参数，在使用时指定具体的类型。

泛型的主要作用：

类型安全：编译时检查类型，避免ClassCastException
消除强制转换：不需要显式类型转换
实现通用算法：编写适用于多种类型的代码

对比：

// 没有泛型的时代（JDK5之前）
List list = new ArrayList();
list.add("hello");
list.add(123); // 编译通过，但类型不安全
String str = (String) list.get(0); // 需要强制转换
String str2 = (String) list.get(1); // 运行时ClassCastException// 使用泛型（JDK5之后）
List<String> list = new ArrayList<String>();
list.add("hello");
// list.add(123); // 编译错误，类型安全
String str = list.get(0); // 无需强制转换

泛型的使用方式：

泛型类：

public class Box<T> {private T content;public void set(T content) {this.content = content;}public T get() {return content;}
}

泛型接口：

public interface Comparable<T> {int compareTo(T o);
}

泛型方法：

public static <T> void swap(T[] array, int i, int j) {T temp = array[i];array[i] = array[j];array[j] = temp;
}

泛型通配符：

无界通配符 ?：

List<?> list = new ArrayList<String>();
// 可以赋值任何泛型List，但不能添加元素（除了null）

上界通配符 ? extends T：

List<? extends Number> numbers = new ArrayList<Integer>();
// 只能读取，不能添加（除了null）
Number num = numbers.get(0); // 安全的读取
// numbers.add(123); // 编译错误

下界通配符 ? super T：

List<? super Integer> numbers = new ArrayList<Number>();
// 可以添加Integer及其子类型，读取时返回Object
numbers.add(123); // 安全的添加
Object obj = numbers.get(0); // 只能用Object接收

PECS原则：

Producer Extends：如果你需要从集合中读取元素，使用? extends T
Consumer Super：如果你需要向集合中添加元素，使用? super T

泛型擦除(Type Erasure)：

泛型擦除是Java泛型实现的核心机制，在编译时进行类型检查，在运行时擦除类型信息。

擦除的过程：

编译时：进行类型检查，确保类型安全
字节码生成：将泛型信息擦除，替换为原始类型(Raw Type)
运行时：JVM看到的是擦除后的代码

擦除规则：

无界类型参数替换为Object
有界类型参数替换为第一个边界类型
插入必要的类型转换代码

示例：

// 源代码
public class GenericClass<T extends Number> {private T value;public T getValue() {return value;}public void setValue(T value) {this.value = value;}
}// 擦除后等价于
public class GenericClass {private Number value; // T extends Number -> Numberpublic Number getValue() {return value;}public void setValue(Number value) {this.value = value;}
}

泛型擦除的影响：

运行时类型信息丢失：

List<String> stringList = new ArrayList<>();
List<Integer> intList = new ArrayList<>();
System.out.println(stringList.getClass() == intList.getClass()); // true

不能创建泛型数组：

// List<String>[] array = new List<String>[10]; // 编译错误
List<String>[] array = new List[10]; // 需要这样写

不能在静态上下文中引用泛型参数：

public class GenericClass<T> {// private static T staticField; // 编译错误// public static T getStaticValue() { return null; } // 编译错误
}

不能进行instanceof检查：

// if (obj instanceof List<String>) { } // 编译错误
if (obj instanceof List) { } // 正确

泛型的限制：

不能实例化泛型参数：

// T obj = new T(); // 编译错误

不能创建泛型数组：

// T[] array = new T[10]; // 编译错误

不能捕获泛型异常：

// try { } catch (T e) { } // 编译错误

最佳实践：

优先使用泛型：提供更好的类型安全
合理使用通配符：遵循PECS原则
避免原始类型：使用List<Object>而不是List
泛型方法优于泛型类：当只有少数方法需要泛型时
使用@SuppressWarnings(“unchecked”)：谨慎使用，确保类型安全

泛型是Java类型系统的重要组成部分，虽然有擦除机制的限制，但显著提高了代码的类型安全性和可读性。

十、序列化机制

问题：Java序列化是什么？如何实现自定义序列化？

🧠 面试者内心OS：
“序列化涉及到对象的持久化和网络传输，要说清楚Serializable接口、serialVersionUID的作用，还有transient关键字。自定义序列化要提到writeObject和readObject方法。”

💡 回答思路指导：

解释序列化的概念和应用场景
介绍Java序列化的实现方式
详细说明自定义序列化
讨论序列化的注意事项和最佳实践

✅ 标准回答：

序列化的概念：

序列化(Serialization)是将对象的状态转换为字节流的过程，反序列化(Deserialization)是将字节流重新构造成对象的过程。

序列化的应用场景：

对象持久化：将对象保存到文件或数据库
网络传输：在网络间传输对象
进程间通信：不同JVM进程间的对象传递
缓存机制：将对象存储到缓存系统
深拷贝：通过序列化实现对象的深拷贝

Java序列化的实现：

实现Serializable接口：

public class Person implements Serializable {private static final long serialVersionUID = 1L;private String name;private int age;private transient String password; // 不会被序列化// 构造方法、getter、setter...
}

基本序列化操作：

// 序列化
Person person = new Person("张三", 25);
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {oos.writeObject(person);
}// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {Person person = (Person) ois.readObject();
}

关键要素详解：

serialVersionUID：
- 序列化版本号，用于版本控制
- 如果不显式声明，JVM会自动生成
- 类结构改变时，自动生成的ID会变化，导致反序列化失败
- 建议显式声明一个固定值

// 版本兼容性示例
public class Person implements Serializable {private static final long serialVersionUID = 1L; // 显式声明private String name;private int age;// 后续添加新字段，只要serialVersionUID不变，仍可兼容private String email; // 新增字段
}

transient关键字：
- 标记不参与序列化的字段
- 反序列化时这些字段会被赋予默认值
- 常用于敏感信息或计算得出的字段

自定义序列化：

当默认序列化不满足需求时，可以通过以下方法自定义：

实现writeObject和readObject方法：

public class CustomPerson implements Serializable {private static final long serialVersionUID = 1L;private String name;private int age;private transient String password;// 自定义序列化方法private void writeObject(ObjectOutputStream out) throws IOException {// 先执行默认序列化out.defaultWriteObject();// 自定义序列化逻辑out.writeObject(encrypt(password)); // 加密后序列化}// 自定义反序列化方法private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {// 先执行默认反序列化in.defaultReadObject();// 自定义反序列化逻辑this.password = decrypt((String) in.readObject()); // 解密}private String encrypt(String text) {// 加密逻辑return Base64.getEncoder().encodeToString(text.getBytes());}private String decrypt(String encryptedText) {// 解密逻辑return new String(Base64.getDecoder().decode(encryptedText));}
}

实现Externalizable接口：

public class ExternalizablePerson implements Externalizable {private String name;private int age;// 必须有无参构造方法public ExternalizablePerson() {}public ExternalizablePerson(String name, int age) {this.name = name;this.age = age;}@Overridepublic void writeExternal(ObjectOutput out) throws IOException {// 完全自定义序列化逻辑out.writeUTF(name);out.writeInt(age);}@Overridepublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {// 完全自定义反序列化逻辑this.name = in.readUTF();this.age = in.readInt();}
}

序列化的注意事项：

版本兼容性：
- 显式声明serialVersionUID
- 新增字段向后兼容
- 删除字段可能导致问题
继承关系：
- 子类实现Serializable，父类也会被序列化
- 父类没有实现Serializable，需要有无参构造方法
静态字段：
- 静态字段不会被序列化
- 反序列化时使用当前类的静态字段值
安全性问题：
- 序列化可能暴露敏感信息
- 反序列化可能导致安全漏洞
- 考虑使用transient或自定义序列化

性能优化：

避免深层次对象图：
- 序列化会遍历整个对象图
- 深层次引用影响性能
使用writeReplace/readResolve：

// 序列化时替换对象
private Object writeReplace() throws ObjectStreamException {return new SerializationProxy(this);
}// 反序列化时解析对象
private Object readResolve() throws ObjectStreamException {// 确保单例等特殊要求return INSTANCE;
}