探索 Java 中的行为型设计糋，共筑靈活、可複用代碼

后端

2023-09-12 23:36:29

航行于代码海洋的指明灯：行为型设计模式

作为一名 Java 开发人员，我们不断努力构建坚固耐用的软件系统，在浩瀚的代码海洋中航行。在这个过程中，设计模式犹如航海中的航标，指引着我们穿越波涛汹涌的代码，搭建起稳固的系统架构。

在设计模式的殿堂中，行为型设计模式扮演着重要的角色。它们专注于对象之间的交互和关系，提供灵活、可复用的解决方案，帮助我们应对复杂系统中的挑战。

策略模式：灵活演算法的指挥家

想象一下一个交响乐团，指挥家协调着不同的乐器，演绎出美妙的旋律。策略模式就像这个指挥家，它协调着不同的算法，实现相似的任务，提供更灵活的解决方案。其灵活性在于，算法的变更与客户端程序无关，只需变更相应的策略，即可轻松实现算法的切换。

策略模式的主要优点：

灵活性： 策略模式提供灵活的算法切换，使系统能够适应不同的需求和环境。
可复用性： 策略模式可将通用算法提取出来，以方便重用，避免重复程序代码的开发。
解耦合： 策略模式将算法与客户端程序解耦合，使两**者可以独立变更，降低变更带来的影响。

一个典型的策略模式应用场景是购物网站中的付款选项。系统可提供多种付款选项，如在线银行、电子钱包等，用户可依个人偏好选择相应的策略进行付款。

interface PaymentStrategy {
    void pay(double amount);
}

class OnlineBankingStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // Implement online banking payment logic
    }
}

class WalletStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // Implement wallet payment logic
    }
}

class ShoppingCart {
    private List<Item> items;
    private PaymentStrategy paymentStrategy;

    public ShoppingCart() {
        this.items = new ArrayList<>();
    }

    public void addItem(Item item) {
        items.add(item);
    }

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout() {
        double totalAmount = 0;
        for (Item item : items) {
            totalAmount += item.getPrice();
        }
        paymentStrategy.pay(totalAmount);
    }
}

观察者模式：新闻社的订阅系统

观察者模式犹如新闻社的订阅系统，使多个对象能够同时监听某一对象的变更。一旦对象的属性或行为发生变更，系统便会通知这些观察者，并让它们做出相应的动作。

观察者模式的主要优点：

松散耦合： 观察者与可观察对象之间保持松散耦合，降低变更带来的影响。
通知多个对象： 观察者模式允许多个对象同时监听某一对象的变更，并在变更时通知它们。
扩展性强： 观察者模式易于扩展，只需新增观察者对象即可，而无需变更可观察对象的接口。

观察者模式的经典应用场景之一，即桌面上显示温度的程序。程序中包含温度传感器对象和显示温度界面对象，当温度传感器对象检测到温度的变更时，便会通知显示温度界面对象进行相应的变更。

interface TemperatureObservable {
    void registerObserver(TemperatureObserver observer);
    void removeObserver(TemperatureObserver observer);
    void notifyObservers();
}

class TemperatureSensor implements TemperatureObservable {

    private List<TemperatureObserver> observers = new ArrayList<>();
    private double temperature;

    public void setTemperature(double temperature) {
        this.temperature = temperature;
        notifyObservers();
    }

    @Override
    public void registerObserver(TemperatureObserver observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(TemperatureObserver observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (TemperatureObserver observer : observers) {
            observer.update(temperature);
        }
    }
}

interface TemperatureObserver {
    void update(double temperature);
}

class TemperatureDisplay implements TemperatureObserver {

    @Override
    public void update(double temperature) {
        // Display the temperature on the screen
    }
}

迭代器模式：探索集合的向导

迭代器模式宛若探险队中的向导，引领客户端程序逐一遍历集合中的对象，而无需将整个集合载入内存中。此模式提供一种统一的方法来访问集合中的对象，并使客户端程序能够方便地遍历整个集合。

迭代器模式的主要优点：

统一访问： 迭代器模式提供统一的方法来访问集合中的对象，使客户端程序能够以一致的方式处理不同的集合类型。
延迟载入： 迭代器模式仅在需要时才载入集合中的对象，而非将整个集合载入内存中，从而节省内存空间并提高效率。
解耦合： 迭代器模式将集合与客户端程序解耦合，使两**者可以独立变更，降低变更带来的影响。

迭代器模式的经典应用场景之一，即搜索算法。算法可遍历集合中的对象，并寻找满足特定条件的对象。

interface Iterator<T> {
    boolean hasNext();
    T next();
}

class ArrayListIterator<T> implements Iterator<T> {

    private ArrayList<T> list;
    private int index;

    public ArrayListIterator(ArrayList<T> list) {
        this.list = list;
        this.index = 0;
    }

    @Override
    public boolean hasNext() {
        return index < list.size();
    }

    @Override
    public T next() {
        return list.get(index++);
    }
}

class ArrayList<T> {

    private List<T> elements;

    public ArrayList() {
        elements = new ArrayList<>();
    }

    public void add(T element) {
        elements.add(element);
    }

    public Iterator<T> iterator() {
        return new ArrayListIterator<>(this);
    }
}