1. Java面向对象基础概述
Java作为一门纯粹的面向对象编程语言，其核心思想是将现实世界的事物抽象为程序中的对象。面向对象编程（OOP）不是简单的语法堆砌，而是一种思维方式，它让我们能够用更接近人类认知的方式构建软件系统。在实际开发中，我见过太多开发者虽然能熟练使用Java语法，却未能真正理解面向对象的精髓，导致代码难以维护和扩展。
面向对象三大特性（封装、继承、多态）不是孤立存在的，它们相互配合形成了强大的代码组织能力。比如在Spring框架中，我们随处可见这三大特性的经典应用：通过封装隐藏复杂实现，通过继承实现模板方法模式，通过多态实现依赖注入。
2. 封装：构建安全的对象边界
2.1 封装的本质与实践
封装不仅仅是简单的private加上getter/setter，它的核心价值在于"信息隐藏"。我在金融项目中最深刻的体会是：良好的封装能有效防止业务逻辑被意外破坏。比如账户余额这个属性：
java复制public class BankAccount {
private BigDecimal balance;
// 专业做法：限制直接修改余额
public void deposit(BigDecimal amount) {
if (amount.compareTo(BigDecimal.ZERO) <= 0) {
throw new IllegalArgumentException("存款金额必须大于零");
}
this.balance = this.balance.add(amount);
}
// 而不是简单的setter
@Deprecated
public void setBalance(BigDecimal balance) {
// 警告：这将破坏业务规则
this.balance = balance;
}
}
2.2 封装的最佳实践
- 防御性编程：所有public方法都应进行参数校验
- 不变性设计：对于核心属性，考虑使用final修饰
- 访问控制：
- private：仅类内部可见
- protected：子类和同包可见
- default：同包可见
- public：全局可见
经验法则：从private开始，仅在必要时扩大访问范围。我在代码审查中最常提出的问题就是过度暴露内部状态。
3. 继承：构建层次化对象体系
3.1 继承的合理使用
继承最容易滥用的OOP特性。在电商系统中，我曾见过深度达到8层的继承体系，维护起来简直是噩梦。遵循LSP（里氏替换原则）是关键：
java复制// 好的继承示例
class Payment {
public void validate() { /* 通用验证逻辑 */ }
}
class CreditCardPayment extends Payment {
@Override
public void validate() {
super.validate();
// 信用卡特有验证
}
}
// 反模式：违反LSP
class Square extends Rectangle {
// 改变父类行为会导致数学上的不一致
}
3.2 组合优于继承
在JDK源码中，我们可以看到大量组合优于继承的实践：
java复制// ArrayList源码摘录
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 使用数组存储而非继承数组
transient Object[] elementData;
}
实际项目中，我会优先考虑：
- 使用接口组合
- 使用委托模式
- 只有在确实是"is-a"关系时才用继承
4. 多态：灵活的行为扩展
4.1 编译时与运行时多态
java复制// 方法重载（编译时多态）
class Logger {
void log(String message) { /*...*/ }
void log(Exception e) { /*...*/ } // 重载
}
// 方法重写（运行时多态）
class FileLogger extends Logger {
@Override
void log(String message) { /* 文件记录实现 */ }
}
4.2 多态在框架中的应用
Spring框架的依赖注入正是多态的完美体现：
java复制@Service
public class OrderService {
@Autowired // 注入实现类，但声明为接口
private PaymentProcessor paymentProcessor;
}
interface PaymentProcessor {
void process(Payment payment);
}
@Component
class AlipayProcessor implements PaymentProcessor { /*...*/ }
@Component
class WechatProcessor implements PaymentProcessor { /*...*/ }
5. 面向对象设计原则
5.1 SOLID原则实践
- 单一职责：一个类只做一件事
- 反例：Order类既处理订单又发送邮件
- 开闭原则：对扩展开放，对修改关闭
java复制// 使用策略模式实现 interface DiscountStrategy { BigDecimal apply(BigDecimal amount); } - 里氏替换：子类必须能替换父类
- 接口隔离：避免臃肿接口
- 依赖倒置：依赖抽象而非实现
5.2 设计模式应用示例
java复制// 工厂方法模式
public interface ParserFactory {
Parser createParser();
}
// 根据不同配置返回不同解析器
public class XmlParserFactory implements ParserFactory {
@Override
public Parser createParser() {
return new XmlParser();
}
}
6. UML类关系深度解析
6.1 六大关系对比
| 关系类型 | 表示法 | 示例 | 生命周期依赖 |
|---|---|---|---|
| 继承 | ◁─── | 动物←猫 | 强 |
| 实现 | ⬦─── | List←ArrayList | 无 |
| 组合 | ◆─── | 公司←部门 | 强 |
| 聚合 | ◇─── | 电脑←显示器 | 弱 |
| 关联 | ─── | 学生→课程 | 无 |
| 依赖 | ╌╌> | 控制器→服务 | 临时 |
6.2 关系选择指南
- 组合：整体与部分不可分割（订单-订单项）
- 聚合：整体与部分可独立存在（车队-汽车）
- 关联：长期持有的引用（用户-收货地址）
- 依赖：临时性使用（报表生成器-数据源）
7. 面向对象实战技巧
7.1 不可变对象设计
java复制public final class ImmutablePoint {
private final int x;
private final int y;
public ImmutablePoint(int x, int y) {
this.x = x;
this.y = y;
}
// 只有getter，没有setter
public int getX() { return x; }
// 返回新对象而非修改状态
public ImmutablePoint move(int dx, int dy) {
return new ImmutablePoint(x + dx, y + dy);
}
}
7.2 优雅的null处理
java复制// 使用Optional避免NPE
public Optional<String> findUserEmail(long userId) {
// 可能返回null的方法包装
return Optional.ofNullable(userRepository.findById(userId))
.map(User::getEmail);
}
// 调用方处理
findUserEmail(123).ifPresent(email -> sendEmail(email));
8. 常见问题与解决方案
8.1 继承滥用问题
问题场景：
java复制// 错误的多层继承
class A { void foo() {} }
class B extends A { void bar() {} }
class C extends B { void baz() {} }
解决方案：
- 使用组合替代继承
- 提取接口
- 应用装饰器模式
8.2 多态陷阱
问题代码：
java复制class Shape {
void draw() { /* 默认实现 */ }
}
class Circle extends Shape {
@Override
void draw() { /* 画圆 */ }
void drawCircle() { /* 特有方法 */ }
}
// 使用时
Shape shape = new Circle();
shape.drawCircle(); // 编译错误！
正确做法：
- 使用instanceof进行类型判断（谨慎使用）
- 更好的设计：通过抽象方法确保所有子类都有完整实现
9. 面试高频问题剖析
9.1 封装相关
问题：如何设计一个线程安全的计数器？
优质答案：
java复制public class SafeCounter {
private final AtomicLong count = new AtomicLong(0);
// 封装原子操作
public long increment() {
return count.incrementAndGet();
}
// 防止直接访问内部状态
public long getCount() {
return count.get();
}
}
9.2 多态相关
问题：解释Java动态绑定的实现机制？
技术要点：
- JVM方法表（vtable）概念
- invokevirtual字节码指令作用
- 实际类型与声明类型的区别
- 通过javap -c查看字节码验证
10. 性能优化建议
- 虚方法调用开销：对于高频调用的final方法，使用final修饰
- 对象创建成本：对于简单值对象，考虑使用record（Java14+）
- 内存占用：
- 避免过度封装导致的对象膨胀
- 对于内部状态，使用基本类型而非包装类
java复制// Java14 record示例
public record Point(int x, int y) {
// 自动生成equals, hashCode等方法
}
在多年开发经验中，我发现很多性能问题其实源于不当的面向对象设计。比如过度抽象导致的调用层次过深，或者不合理的继承关系引起的内存浪费。良好的OOP实践不仅能提升代码质量，还能带来可观的性能收益。