Java 面向对象核心概念全解析：抽象、封装、继承、多态与关联关系实战

什么是面向对象编程 (OOP)？

Object-Oriented Programming (OOP) 是一种以对象为核心的程序设计范式，建立在四大支柱之上：抽象、封装、继承、多态。它将现实世界实体建模为对象，对象封装状态 (属性/字段)与行为 (方法)，通过消息传递 (方法调用) 协作。目标是构建可复用、可维护、可扩展的软件系统，降低认知复杂度。

Java OOP 九大核心概念与代码实战

1. 类 — 对象的蓝图

类定义了一类对象共享的属性与行为。例如 Car 类：

public class Car {
    // 属性 (状态)
    private String make;
    private String model;
    private int speed;

    // 构造器
    public Car(String make, String model) {
        this.make = make;
        this.model = model;
        this.speed = 0;
    }

    // 行为 (方法)
    public void drive() { speed += 10; System.out.println("Driving at " + speed + " km/h"); }
    public void brake() { speed = Math.max(0, speed - 10); System.out.println("Braking, speed: " + speed); }
    public void reverse() { speed = -5; System.out.println("Reversing"); }

    // 访问器
    public String getMake() { return make; }
    public String getModel() { return model; }
    public int getSpeed() { return speed; }
}

2. 对象 — 类的实例

对象是类的具体化，拥有独立身份、状态和行为：

Car mercedes = new Car("Mercedes", "E-Class");
Car bmw = new Car("BMW", "3 Series");
mercedes.drive();  // Driving at 10 km/h
bmw.drive();       // Driving at 10 km/h (独立状态)

3. 继承 — 复用与层级建模

子类继承父类非私有成员，建立 is-a 关系：

public class Sedan extends Car {
    private int trunkCapacity;  // 升

    public Sedan(String make, String model, int trunkCapacity) {
        super(make, model);     // 调用父类构造器
        this.trunkCapacity = trunkCapacity;
    }

    @Override
    public void drive() {
        super.drive();
        System.out.println("Sedan specific driving logic");
    }

    public void openTrunk() { System.out.println("Trunk opened, capacity: " + trunkCapacity + "L"); }
}

4. 多态 — 同一接口，多种形态

核心机制：方法重写 + 向上转型 (父类引用指向子类对象)：

Vehicle vehicle = new Car("Toyota", "Camry");  // 向上转型
vehicle.move();  // 调用 Car 的 move()

List fleet = List.of(new Car(...), new Truck(...), new Motorcycle(...));
fleet.forEach(Vehicle::move);  // 统一接口，各自实现

编译时多态：方法重载 (同名不同参数)；运行时多态：方法重写 (动态分派)。

5. 抽象 — 隐藏复杂，暴露本质

通过抽象类与接口定义契约，隐藏实现细节：

// 抽象类：可包含字段、构造器、具体方法、抽象方法
public abstract class Vehicle {
    protected String licensePlate;
    public abstract void move();  // 抽象方法，子类必须实现
    public void honk() { System.out.println("Beep beep!"); }  // 具体方法
}

// 接口：纯契约 (Java 8+ 可含 default/static/private 方法)
public interface Drivable {
    void drive();
    default void park() { System.out.println("Parking..."); }  // 默认实现
}

6. 封装 — 保护内部不变量

将字段 private，通过 public getter/setter 控制访问，可加验证逻辑：

public class Account {
    private double balance;  // 不变量：余额 >= 0

    public double getBalance() { return balance; }

    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
        balance += amount;
    }

    public boolean withdraw(double amount) {
        if (amount <= 0 || amount > balance) return false;
        balance -= amount;
        return true;
    }
}

7. 关联 — 对象间松耦合关系

双向感知但生命周期独立：

class Student { List teachers = new ArrayList<>(); }
class Teacher { List students = new ArrayList<>(); }
// Student 与 Teacher 可独立创建/销毁

8. 聚合 — 弱 "has-a" 关系

整体包含部分，但部分可独立存在：

class Department {
    private List teachers = new ArrayList<>();  // 教师离开系统仍存在
    public void addTeacher(Teacher t) { teachers.add(t); }
}

9. 组合 — 强 "has-a" 关系

部分生命周期绑定整体，整体销毁 → 部分销毁：

class House {
    private List rooms = new ArrayList<>();  // Room 无独立意义
    public House() { rooms.add(new Room("Bedroom")); rooms.add(new Room("Kitchen")); }
    // House 销毁时 rooms 自动随之销毁 (无外部引用)
}

OOP 在 Java 中的核心优势

• 模块化：类作为独立单元，低耦合高内聚
• 复用性：继承/组合复用现有代码，减少重复
• 可维护性：封装隐藏实现细节，局部修改不波及外部
• 可扩展性：多态 + 接口实现开闭原则 (OCP)
• 团队协作：契约先行 (接口/抽象类)，并行开发、模拟测试
• 领域建模：代码结构贴近业务领域，降低认知负荷

范式对比：以银行账户为例

非结构化 (面条代码)

int accNo = 20; int bal = 100;
bal += 100;  // 存款
printf("Acc=%d, Bal=%d", accNo, bal);
bal -= 50;   // 取款
printf("Acc=%d, Bal=%d", accNo, bal);
// 重复代码、全局状态、难维护

结构化 (过程式)

int accNo = 20; int bal = 100;
void deposit(int amt) { bal += amt; }
void withdraw(int amt) { bal -= amt; }
void show() { printf("Acc=%d, Bal=%d", accNo, bal); }
// 函数复用，但数据与操作分离，全局变量耦合

面向对象 (Java)

public class Account {
    private int accountNumber;
    private int balance;

    public Account(int number, int balance) {
        this.accountNumber = number; this.balance = balance;
    }
    public void deposit(int amount) { balance += amount; }
    public void withdraw(int amount) { balance -= amount; }
    public void showBalance() {
        System.out.println("Account: " + accountNumber + ", Balance: " + balance);
    }
}

// 使用
Account acc = new Account(20, 100);
acc.deposit(100); acc.showBalance();
acc.withdraw(50); acc.showBalance();

OOP 带来：数据行为封装、抽象接口、继承扩展 (如 SavingsAccount)、多态统一处理 (List)、封装保护不变量。

SOLID 原则在 Java 中的落地

• SRP 单一职责：一个类只因一个理由变化 (如 Account 只管账务，日志交给 Logger)
• OCP 开闭原则：对扩展开放、修改关闭 (策略模式、模板方法、接口隔离)
• LSP 里氏替换：子类能替换父类不破坏行为 (正方形非长方形子类反例)
• ISP 接口隔离：细粒度接口优于臃肿大接口 (Printable/Scannable 而非 OfficeMachine)
• DIP 依赖倒置：高层依赖抽象 (接口)，低层实现抽象 (Spring IoC 核心)

常见面试陷阱

总结

Java OOP 以类/对象为核心，抽象/封装/继承/多态四大支柱支撑，关联/聚合/组合描绘对象协作网络。配合 SOLID 原则、设计模式、现代语法 (Record、Sealed、Pattern Matching)，能构建经得起时间考验的企业级系统。深度理解各概念语义边界与组合方式，是从“会写 Java”进阶为“架构 Java 系统”的关键分水岭。