设计模式的魅力：行为型模式的精妙之处

2023-10-15 11:42:02

行为型模式：Android 源码中的协作与职责分离艺术

行为型模式的本质

行为型模式着重于对象之间的交互和职责分配，指导我们设计灵活且可重用的代码。在 Android 源码中，它们在事件处理、算法管理和行为参数化等方面得到了广泛应用。

观察者模式：订阅发布机制

观察者模式是一个发布-订阅机制，它允许对象（订阅者）订阅另一个对象（发布者）的事件通知。当发布者的状态发生变化时，它会通知所有已订阅的观察者。Android 源码中，观察者模式用于系统事件处理和广播通信，如 ContentProvider 和 BroadcastReceiver。

代码示例：

// 发布者类
class Publisher {
    private List<Observer> observers = new ArrayList<>();

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

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

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

// 订阅者类
class Observer {
    public void update() {
        // 更新逻辑
    }
}

策略模式：算法与决策的分离

策略模式将算法或决策与使用它们的类分离，允许在运行时动态切换算法，从而提供高度可定制的解决方案。Android 源码中，策略模式用于图像加载（ImageLoader）和线程调度（ThreadPolicy）。

代码示例：

// 策略接口
interface SortStrategy {
    int[] sort(int[] arr);
}

// 具体策略类
class BubbleSortStrategy implements SortStrategy {
    @Override
    public int[] sort(int[] arr) {
        // 冒泡排序算法
        return arr;
    }
}

class QuickSortStrategy implements SortStrategy {
    @Override
    public int[] sort(int[] arr) {
        // 快速排序算法
        return arr;
    }
}

// 使用策略的类
class SortManager {
    private SortStrategy strategy;

    public SortManager(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public int[] sort(int[] arr) {
        return strategy.sort(arr);
    }
}

命令模式：行为封装

命令模式将行为封装为独立的对象，从而实现行为的解耦和重用。它支持通过命令对象来调用和管理操作，实现命令的队列、撤销和重做等功能。Android 源码中，命令模式用于菜单和按钮事件处理。

代码示例：

// 命令接口
interface Command {
    void execute();
}

// 具体命令类
class OpenFileCommand implements Command {
    @Override
    public void execute() {
        // 打开文件逻辑
    }
}

class SaveFileCommand implements Command {
    @Override
    public void execute() {
        // 保存文件逻辑
    }
}

// 命令调用者
class CommandInvoker {
    private List<Command> commands = new ArrayList<>();

    public void addCommand(Command command) {
        commands.add(command);
    }

    public void executeCommands() {
        for (Command command : commands) {
            command.execute();
        }
    }
}

解释器模式：复杂表达式解析

解释器模式将一组表达式或规则解释为一个可执行的程序，它允许以一种可扩展和可重用的方式解析和执行复杂表达式。Android 源码中，解释器模式用于解析 XML 布局文件（LayoutInflator）和动画定义（AnimatorInflater）。

代码示例：

// 表达式接口
interface Expression {
    int interpret(Context context);
}

// 具体表达式类
class NumberExpression implements Expression {
    private int number;

    public NumberExpression(int number) {
        this.number = number;
    }

    @Override
    public int interpret(Context context) {
        return number;
    }
}

class AddExpression implements Expression {
    private Expression left;
    private Expression right;

    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        return left.interpret(context) + right.interpret(context);
    }
}

// 解释器
class Interpreter {
    public int interpret(String expression) {
        Expression expr = buildExpressionTree(expression);
        return expr.interpret(null);
    }

    private Expression buildExpressionTree(String expression) {
        // 根据语法规则构建表达式树
        return null;
    }
}

模板方法模式：骨架算法定义

模板方法模式定义了一个算法的骨架，而算法的具体步骤则被留给子类去实现。它提供了算法的一致性，同时允许子类自定义某些步骤。Android 源码中，模板方法模式用于 View 的测量和布局（View.onMeasure() 和 View.onLayout()）。

代码示例：

// 模板方法类
abstract class AbstractClass {
    public final void templateMethod() {
        step1();
        step2();
        hook();
        step3();
    }

    protected abstract void step1();

    protected abstract void step2();

    protected void hook() {}

    protected abstract void step3();
}

// 具体子类
class ConcreteClass1 extends AbstractClass {
    @Override
    protected void step1() {
        // 子类实现的步骤1逻辑
    }

    @Override
    protected void step2() {
        // 子类实现的步骤2逻辑
    }

    @Override
    protected void step3() {
        // 子类实现的步骤3逻辑
    }
}

class ConcreteClass2 extends AbstractClass {
    @Override
    protected void step1() {
        // 子类实现的步骤1逻辑
    }

    @Override
    protected void step2() {
        // 子类实现的步骤2逻辑
    }

    @Override
    protected void hook() {
        // 子类重写了hook方法
    }

    @Override
    protected void step3() {
        // 子类实现的步骤3逻辑
    }
}

责任链模式：分层请求处理

责任链模式将一系列处理程序链接成一个链，当一个请求出现时，它会从链的开始传递到结束，每个处理程序都有机会处理该请求。它提供了灵活且可扩展的请求处理机制。Android 源码中，责任链模式用于文件和权限请求处理（FileProvider 和 PermissionChecker）。

代码示例：

// 处理程序接口
interface Handler {
    boolean handle(Request request);
}

// 具体处理程序类
class Handler1 implements Handler {
    @Override
    public boolean handle(Request request) {
        // 处理请求1的逻辑
        return true;
    }
}

class Handler2 implements Handler {
    @Override
    public boolean handle(Request request) {
        // 处理请求2的逻辑
        return false;
    }
}

// 责任链
class ChainOfResponsibility {
    private List<Handler> handlers = new ArrayList<>();

    public void addHandler(Handler handler) {
        handlers.add(handler);
    }

    public boolean handle(Request request) {
        for (Handler handler : handlers) {
            if (handler.handle(request)) {
                return true;
            }
        }
        return false;
    }
}

状态模式：状态封装

状态模式将对象的状态和行为封装成独立的类，从而实现状态的解耦和变化的管理。它允许对象在不同的状态之间动态切换，并相应地改变其行为。Android 源码中，状态模式用于 Activity 和 View 的状态管理（Activity.onSaveInstanceState() 和 View.onRestoreInstanceState()）。

代码示例：

// 状态接口
interface State {
    void handle();
}

// 具体状态类
class State1 implements State {
    @Override
    public void handle() {
        // 状态1的行为逻辑
    }
}

class State2 implements State {
    @Override
    public void handle() {
        // 状态2的行为逻辑
    }
}

// 上下文类
class Context {
    private State state;

    public void setState(State state) {
        this.state = state;
    }

    public void handle() {
        state.handle();
    }
}