Java中出现了哪些常见的设计模式？

Question

Java中出现了哪些常见的设计模式？

Accepted Answer

**Design patterns** 是对重复出现的 software-design 问题的可重用解决方案。Java 的 OOP 特性和生态系统使得几种模式特别常见——了解它们可以帮助你识别、交流和应用已验证的结构。它们分为 creational、structural 和 behavioral 三个类别。

## Singleton (creational) — 一个共享实例

```java
public class Config {
    private static final Config INSTANCE = new Config();   // the single instance
    private Config() {}                                     // private constructor
    public static Config getInstance() { return INSTANCE; }
}
// (enum singletons are an even safer idiom). Used for shared config, connection pools.
```

## Factory (creational) — 封装对象创建

```java
public static Shape createShape(String type) {
    return switch (type) {                 // hides the concrete class from the caller
        case "circle" -> new Circle();
        case "square" -> new Square();
        default -> throw new IllegalArgumentException();
    };
}
// caller depends on Shape, not concrete classes — decoupling.
```

## Builder (creational) — 逐步构建复杂对象

```java
User user = new User.Builder()
    .name("Ann")
    .email("ann@x.com")
    .age(30)
    .build();    // readable construction; avoids huge telescoping constructors
```

## Strategy (behavioral) — 可互换的算法

```java
interface PaymentStrategy { void pay(double amount); }
class CreditCard implements PaymentStrategy { public void pay(double a) {...} }
class PayPal implements PaymentStrategy { public void pay(double a) {...} }

// swap behavior at runtime — lambdas make this trivial in modern Java
processor.setStrategy(new PayPal());
```

## Observer (behavioral) — 发布/订阅

```java
// subjects notify registered observers of changes (events, listeners)
button.addActionListener(e -> handleClick());   // GUI events use this everywhere
```

## Decorator (structural) — 包装以添加行为

```java
// Java's I/O streams ARE the decorator pattern:
BufferedReader r = new BufferedReader(new FileReader("f.txt"));
// BufferedReader wraps FileReader, adding buffering
```

## 在 Java 本身中出现的模式

```text
Singleton  → Runtime.getRuntime()
Factory    → Calendar.getInstance(), DriverManager
Builder    → StringBuilder, Stream.Builder
Observer   → event listeners, java.util.Observer
Decorator  → java.io streams (BufferedReader wrapping FileReader)
Iterator   → the Iterator interface / Collections
Strategy   → Comparator, functional interfaces
```

## 对过度使用的警告

```text
Patterns are tools, not goals. Applying them where they don't fit ADDS complexity.
Use them when they genuinely solve your problem — many can be simpler with lambdas now.
```

## 为什么这很重要

Design patterns 为常见的设计问题提供了共同的词汇表和已验证的解决方案，这对于交流（"在这里使用 Strategy"）、识别现有代码中的结构以及避免重新发明有缺陷的解决方案很有价值。

它们在 Java 的标准库中随处可见（I/O decorators、factory methods、builders、observer-based events），因此理解它们可以帮助你有效地使用和扩展标准库。

了解主要模式——Singleton、Factory、Builder、Strategy、Observer、Decorator——以及每个模式适用的场景，是经验丰富的开发者的标志，也是常见的面试话题。

同样重要的是判断力，要恰当地应用这些模式（解决真实问题），而不是强行使用它们，尤其是当像 lambdas 这样的现代特性简化了许多经典模式的时候。