OOP的四大支柱是什么?

Question

OOP的四大支柱是什么?

Accepted Answer

面向对象编程基于四个核心原则——**封装、继承、多态和抽象**。Java正是围绕这些原则构建的，理解这些原则是设计Java程序的基础。

## 1. 封装 — 打包数据 + 隐藏内部

```java
public class Account {
    private double balance;          // hidden — can't be accessed directly outside

public void deposit(double amount) {   // controlled access via methods
        if (amount > 0) balance += amount;  // can enforce rules
    }
    public double getBalance() { return balance; }
}
```

封装隐藏内部状态（`private`）并公开受控访问（public方法/getter/setter）。这保护了不变量——你不能直接设置负余额——并让你改变内部实现而不会破坏调用者。

## 2. 继承 — 通过"is-a"关系实现重用

```java
class Animal {
    void eat() { System.out.println("eating"); }
}
class Dog extends Animal {   // Dog IS-A Animal — inherits eat()
    void bark() { System.out.println("woof"); }
}
```

继承让子类重用和扩展超类的行为，建模"is-a"关系并避免代码重复。

## 3. 多态 — 一个接口，多种形式

```java
Animal a = new Dog();     // a Dog treated as an Animal
a.makeSound();            // calls Dog's overridden version at RUNTIME (dynamic dispatch)

// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
```

多态让你通过一个公共类型统一地对待不同的子类，在运行时调用**实际**对象的重写方法——实现灵活的、可扩展的代码。

## 4. 抽象 — 公开内容，隐藏方式

```java
interface PaymentProcessor {
    void pay(double amount);   // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
    public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
```

抽象（通过接口/抽象类）公开一个简化的契约，同时隐藏复杂的实现——让你交换实现并降低耦合。

## 为什么这很重要

四大支柱是面向对象设计和Java本身的基础。

封装保护数据完整性并支持安全的改进；继承促进重用；多态提供灵活性和可扩展性（统一处理多种类型，行为在运行时确定）；抽象降低耦合和复杂性。

理解它们不仅仅是术语——它们指导你如何结构化类、设计API，以及构建可维护的、可扩展的系统。

它们也是最常见的面试话题之一，因为它们揭示了开发者是否以适当的OOP术语思考，这对于在Java的类为中心的生态系统中高效工作至关重要。