【设计模式】设计模式初窥

最新推荐文章于 2025-12-18 09:34:13 发布

原创最新推荐文章于 2025-12-18 09:34:13 发布 · 710 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #java

设计模式专栏收录该内容

1 篇文章

订阅专栏

设计模式是软件开发中经过验证的解决方案，用于解决常见的设计问题。Java 中常用的设计模式可以分为三大类：创建型模式、结构型模式 和 行为型模式。以下是常见的设计模式及其在 Java 中的应用：

一、创建型模式

用于处理对象创建的模式，隐藏对象创建的细节。

1. 单例模式（Singleton）

用途：确保一个类只有一个实例，并提供全局访问点。

实现：

public class Singleton {
    private static Singleton instance;

    private Singleton() {} // 私有构造方法

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

应用场景：数据库连接池、配置文件管理。

2. 工厂模式（Factory）

用途：定义一个创建对象的接口，由子类决定实例化哪个类。

实现：

interface Product {
    void use();
}

class ConcreteProduct implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProduct");
    }
}

class Factory {
    public Product createProduct() {
        return new ConcreteProduct();
    }
}

应用场景：日志记录器、数据库连接工厂。

3. 抽象工厂模式（Abstract Factory）

用途：提供一个创建一系列相关或依赖对象的接口。

实现：

interface Button {
    void render();
}

interface Checkbox {
    void render();
}

class WindowsButton implements Button {
    @Override
    public void render() {
        System.out.println("Render Windows Button");
    }
}

class WindowsCheckbox implements Checkbox {
    @Override
    public void render() {
        System.out.println("Render Windows Checkbox");
    }
}

interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

应用场景：跨平台 UI 组件库。

4. 建造者模式（Builder）

用途：将一个复杂对象的构建与其表示分离。

实现：

class Product {
    private String part1;
    private String part2;

    public void setPart1(String part1) { this.part1 = part1; }
    public void setPart2(String part2) { this.part2 = part2; }
}

interface Builder {
    void buildPart1();
    void buildPart2();
    Product getResult();
}

class ConcreteBuilder implements Builder {
    private Product product = new Product();

    @Override
    public void buildPart1() {
        product.setPart1("Part1");
    }

    @Override
    public void buildPart2() {
        product.setPart2("Part2");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

应用场景：构建复杂对象，如 XML 解析器。

5. 原型模式（Prototype）

用途：通过复制现有对象来创建新对象。

实现：

class Prototype implements Cloneable {
    private String name;

    public Prototype(String name) {
        this.name = name;
    }

    @Override
    protected Prototype clone() throws CloneNotSupportedException {
        return (Prototype) super.clone();
    }
}

应用场景：对象创建成本较高的场景。

二、结构型模式

用于处理类或对象的组合。

1. 适配器模式（Adapter）

用途：将一个类的接口转换成客户端期望的另一个接口。

实现：

interface Target {
    void request();
}

class Adaptee {
    public void specificRequest() {
        System.out.println("Specific Request");
    }
}

class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

应用场景：兼容旧系统。

2. 装饰器模式（Decorator）

用途：动态地为对象添加功能。

实现：

interface Component {
    void operation();
}

class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent Operation");
    }
}

class Decorator implements Component {
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

应用场景：Java I/O 流（如 BufferedReader）。

3. 代理模式（Proxy）

用途：为其他对象提供一个代理以控制对这个对象的访问。

实现：

interface Subject {
    void request();
}

class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject Request");
    }
}

class Proxy implements Subject {
    private RealSubject realSubject;

    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();
    }
}

应用场景：延迟加载、权限控制。

三、行为型模式

用于处理对象之间的职责分配和通信。

1. 观察者模式（Observer）

用途：定义对象间的一对多依赖关系，当一个对象改变状态时，所有依赖者都会收到通知。

实现：

interface Observer {
    void update();
}

class ConcreteObserver implements Observer {
    @Override
    public void update() {
        System.out.println("Observer Updated");
    }
}

class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

应用场景：事件处理系统。

2. 策略模式（Strategy）

用途：定义一系列算法，将每个算法封装起来并使它们可以互换。

实现：

interface Strategy {
    void execute();
}

class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Strategy A");
    }
}

class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}