Android开发中的11种行为型设计模式深度解析

在Android应用开发中，设计模式是解决特定问题的可重用方案，其中行为型设计模式尤其重要，它们专注于对象之间的通信和职责分配。本文将深入解析Android开发中最常用的11种行为型设计模式，每个模式都配有详细的介绍和实际应用示例，帮助开发者构建更灵活、可维护的应用架构。

1. 观察者模式(Observer Pattern)

模式定义：定义对象间一对多的依赖关系，当一个对象状态改变时，所有依赖它的对象都会自动收到通知并更新9。

Android典型应用：

LiveData的生命周期感知数据观察
RxJava的响应式编程模型
视图控件的点击事件监听(View.setOnClickListener())
RecyclerView.Adapter的数据更新机制

实现示例：

// 被观察者
public class NewsPublisher {private List<Subscriber> subscribers = new ArrayList<>();public void addSubscriber(Subscriber s) {subscribers.add(s);}public void notifySubscribers(String news) {for (Subscriber s : subscribers) {s.update(news);}}
}// 观察者接口
public interface Subscriber {void update(String news);
}// 具体观察者
public class NewsReader implements Subscriber {@Overridepublic void update(String news) {System.out.println("收到新闻更新: " + news);}
}// 使用
NewsPublisher publisher = new NewsPublisher();
publisher.addSubscriber(new NewsReader());
publisher.notifySubscribers("Android 14新特性发布");

优点：解耦观察者和被观察者，支持动态添加和移除观察者，实现广播通信机制9。

注意事项：在Activity/Fragment中使用时需注意内存泄漏问题，避免持有已销毁的UI引用。

2. 策略模式(Strategy Pattern)

模式定义：定义一系列算法，封装每个算法，并使它们可以互相替换15。

Android典型应用：

RecyclerView的不同布局管理器(LinearLayoutManager/GridLayoutManager)
动画插值器(Interpolator)的各种实现
图片加载库的不同缓存策略
支付模块的不同支付方式实现

实现示例：

// 策略接口
public interface ImageCacheStrategy {void loadImage(Context context, String url, ImageView imageView);
}// 具体策略：内存缓存
public class MemoryCacheStrategy implements ImageCacheStrategy {@Overridepublic void loadImage(Context context, String url, ImageView imageView) {// 内存缓存实现Log.d("Cache", "Loading from memory cache");}
}// 具体策略：磁盘缓存
public class DiskCacheStrategy implements ImageCacheStrategy {@Overridepublic void loadImage(Context context, String url, ImageView imageView) {// 磁盘缓存实现Log.d("Cache", "Loading from disk cache");}
}// 上下文
public class ImageLoader {private ImageCacheStrategy strategy;public void setStrategy(ImageCacheStrategy strategy) {this.strategy = strategy;}public void displayImage(Context context, String url, ImageView imageView) {strategy.loadImage(context, url, imageView);}
}// 使用
ImageLoader loader = new ImageLoader();
loader.setStrategy(new MemoryCacheStrategy());
loader.displayImage(context, "http://example.com/image.jpg", imageView);

最佳实践：结合依赖注入(如Dagger)来管理策略对象，使代码更清晰5。

3. 模板方法模式(Template Method Pattern)

模式定义：定义一个操作中的算法骨架，将某些步骤延迟到子类中实现247。

Android典型应用：

Activity和Fragment的生命周期方法
AsyncTask的任务执行流程
自定义View的绘制流程
基类Activity/Fragment的通用逻辑封装

实现示例：

public abstract class BaseActivity extends AppCompatActivity {@Overrideprotected final void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(getLayoutId());initViews();initData();setupListeners();}protected abstract int getLayoutId();protected abstract void initViews();protected abstract void initData();protected abstract void setupListeners();// 钩子方法，可选实现protected void onCustomEvent() {// 默认空实现}
}// 具体实现
public class MainActivity extends BaseActivity {@Overrideprotected int getLayoutId() {return R.layout.activity_main;}@Overrideprotected void initViews() {// 初始化视图}@Overrideprotected void initData() {// 初始化数据}@Overrideprotected void setupListeners() {// 设置监听器}@Overrideprotected void onCustomEvent() {// 自定义实现}
}

核心思想：将不变的部分(算法骨架)放在父类，可变部分(具体实现)放在子类7。

4. 命令模式(Command Pattern)

模式定义：将一个请求封装为对象，从而允许用户使用不同的请求参数化其他对象6。

Android典型应用：

事件处理系统
撤销/重做功能实现
异步任务调度
广播接收器

实现示例：

// 命令接口
public interface Command {void execute();
}// 具体命令
public class LightOnCommand implements Command {private Light light;public LightOnCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.turnOn();}
}// 接收者
public class Light {public void turnOn() {Log.d("Command", "Light is on");}
}// 调用者
public class RemoteControl {private Command command;public void setCommand(Command command) {this.command = command;}public void pressButton() {command.execute();}
}// 使用
Light light = new Light();
Command lightOn = new LightOnCommand(light);
RemoteControl remote = new RemoteControl();
remote.setCommand(lightOn);
remote.pressButton();

优势：将请求发送者与接收者解耦，支持命令队列和日志记录6。

5. 状态模式(State Pattern)

模式定义：允许对象在内部状态改变时改变其行为，看起来像是改变了其类8。

Android典型应用：

播放器状态管理(播放/暂停/停止)
用户登录状态管理
订单状态流转
网络连接状态处理

实现示例：

// 状态接口
public interface PlayerState {void play(MediaPlayer player);void pause(MediaPlayer player);
}// 具体状态：播放状态
public class PlayingState implements PlayerState {@Overridepublic void play(MediaPlayer player) {// 已经是播放状态，不做操作}@Overridepublic void pause(MediaPlayer player) {player.pause();player.setState(new PausedState());}
}// 具体状态：暂停状态
public class PausedState implements PlayerState {@Overridepublic void play(MediaPlayer player) {player.start();player.setState(new PlayingState());}@Overridepublic void pause(MediaPlayer player) {// 已经是暂停状态，不做操作}
}// 上下文
public class MediaPlayer {private PlayerState state;public MediaPlayer() {this.state = new PausedState();}public void setState(PlayerState state) {this.state = state;}public void play() {state.play(this);}public void pause() {state.pause(this);}// 其他方法...
}// 使用
MediaPlayer player = new MediaPlayer();
player.play();  // 从暂停切换到播放
player.pause(); // 从播放切换到暂停

优点：消除大量条件语句，使状态转换显式化8。

6. 责任链模式(Chain of Responsibility Pattern)

模式定义：将请求的发送者和接收者解耦，使多个对象都有机会处理请求10。

Android典型应用：

Android事件分发机制
网络请求拦截器链(如OkHttp)
权限检查流程
异常处理链

实现示例：

// 处理器接口
public interface Handler {void setNext(Handler handler);void handle(Request request);
}// 抽象处理器
public abstract class AbstractHandler implements Handler {private Handler next;@Overridepublic void setNext(Handler handler) {this.next = handler;}@Overridepublic void handle(Request request) {if (canHandle(request)) {process(request);} else if (next != null) {next.handle(request);} else {Log.d("Chain", "No handler found for request");}}protected abstract boolean canHandle(Request request);protected abstract void process(Request request);
}// 具体处理器：登录检查
public class AuthHandler extends AbstractHandler {@Overrideprotected boolean canHandle(Request request) {return request.needsAuth();}@Overrideprotected void process(Request request) {Log.d("Chain", "Handling authentication");// 实际认证逻辑}
}// 具体处理器：缓存检查
public class CacheHandler extends AbstractHandler {@Overrideprotected boolean canHandle(Request request) {return request.isCacheable();}@Overrideprotected void process(Request request) {Log.d("Chain", "Checking cache");// 实际缓存逻辑}
}// 使用
Handler chain = new AuthHandler();
chain.setNext(new CacheHandler());Request request = new Request(true, false); // 需要认证，不可缓存
chain.handle(request);

特点：动态构建处理链，灵活添加或修改处理逻辑10。

7. 迭代器模式(Iterator Pattern)

模式定义：提供一种方法顺序访问聚合对象中的各个元素，而又不暴露其内部表示4。

Android典型应用：

数据库查询结果遍历(Cursor)
集合类遍历
自定义数据结构遍历
RecyclerView数据访问

实现示例：

// 迭代器接口
public interface Iterator<T> {boolean hasNext();T next();
}// 聚合接口
public interface Aggregate<T> {Iterator<T> createIterator();
}// 具体聚合：用户集合
public class UserCollection implements Aggregate<User> {private List<User> users = new ArrayList<>();public void addUser(User user) {users.add(user);}@Overridepublic Iterator<User> createIterator() {return new UserIterator(users);}
}// 具体迭代器
public class UserIterator implements Iterator<User> {private List<User> users;private int position = 0;public UserIterator(List<User> users) {this.users = users;}@Overridepublic boolean hasNext() {return position < users.size();}@Overridepublic User next() {User user = users.get(position);position++;return user;}
}// 使用
UserCollection collection = new UserCollection();
collection.addUser(new User("Alice"));
collection.addUser(new User("Bob"));Iterator<User> iterator = collection.createIterator();
while (iterator.hasNext()) {User user = iterator.next();Log.d("Iterator", "User: " + user.getName());
}

优势：统一遍历接口，支持多种遍历方式而不暴露集合内部结构。

8. 中介者模式(Mediator Pattern)

模式定义：定义一个中介对象来封装一系列对象之间的交互9。

Android典型应用：

MVP架构中的Presenter
聊天室实现
组件间通信
事件总线(EventBus)

实现示例：

// 中介者接口
public interface ChatMediator {void sendMessage(String msg, User user);void addUser(User user);
}// 具体中介者：聊天室
public class ChatRoom implements ChatMediator {private List<User> users = new ArrayList<>();@Overridepublic void sendMessage(String msg, User user) {for (User u : users) {if (u != user) {u.receive(msg);}}}@Overridepublic void addUser(User user) {users.add(user);}
}// 同事类
public abstract class User {protected ChatMediator mediator;protected String name;public User(ChatMediator mediator, String name) {this.mediator = mediator;this.name = name;}public abstract void send(String msg);public abstract void receive(String msg);
}// 具体同事类
public class ChatUser extends User {public ChatUser(ChatMediator mediator, String name) {super(mediator, name);}@Overridepublic void send(String msg) {Log.d("Mediator", name + " sends: " + msg);mediator.sendMessage(msg, this);}@Overridepublic void receive(String msg) {Log.d("Mediator", name + " receives: " + msg);}
}// 使用
ChatMediator mediator = new ChatRoom();
User alice = new ChatUser(mediator, "Alice");
User bob = new ChatUser(mediator, "Bob");mediator.addUser(alice);
mediator.addUser(bob);alice.send("Hi there!");
bob.send("Hello Alice!");

优点：减少对象间直接依赖，集中控制交互逻辑。

9. 备忘录模式(Memento Pattern)

模式定义：在不破坏封装性的前提下，捕获并外部化对象的内部状态，以便以后可以恢复4。

Android典型应用：

Activity状态保存(onSaveInstanceState)
游戏存档/读档
撤销操作实现
表单数据临时保存

实现示例：

// 备忘录：保存编辑器状态
public class EditorMemento {private final String content;public EditorMemento(String content) {this.content = content;}public String getContent() {return content;}
}// 原发器：文本编辑器
public class TextEditor {private String content;public void type(String words) {content = words;}public String getContent() {return content;}public EditorMemento save() {return new EditorMemento(content);}public void restore(EditorMemento memento) {content = memento.getContent();}
}// 管理者：负责保存备忘录
public class History {private Stack<EditorMemento> states = new Stack<>();public void push(EditorMemento memento) {states.push(memento);}public EditorMemento pop() {return states.pop();}
}// 使用
TextEditor editor = new TextEditor();
History history = new History();editor.type("First version");
history.push(editor.save());editor.type("Second version");
history.push(editor.save());editor.type("Third version");
System.out.println("Current content: " + editor.getContent());// 撤销到上一个版本
editor.restore(history.pop());
System.out.println("After undo: " + editor.getContent());

特点：实现状态保存与恢复，不暴露对象内部细节。

10. 访问者模式(Visitor Pattern)

模式定义：表示一个作用于某对象结构中的各元素的操作，可以在不改变各元素类的前提下定义作用于这些元素的新操作4。

Android典型应用：

编译器语法树分析
复杂对象结构操作
APT(Annotation Processing Tool)
报表生成

实现示例：

// 元素接口
public interface ReportElement {void accept(ReportVisitor visitor);
}// 具体元素：固定支出
public class FixedCost implements ReportElement {private double amount;public FixedCost(double amount) {this.amount = amount;}public double getAmount() {return amount;}@Overridepublic void accept(ReportVisitor visitor) {visitor.visit(this);}
}// 具体元素：可变支出
public class VariableCost implements ReportElement {private double[] amounts;public VariableCost(double[] amounts) {this.amounts = amounts;}public double[] getAmounts() {return amounts;}@Overridepublic void accept(ReportVisitor visitor) {visitor.visit(this);}
}// 访问者接口
public interface ReportVisitor {void visit(FixedCost fixedCost);void visit(VariableCost variableCost);
}// 具体访问者：成本计算
public class CostCalculator implements ReportVisitor {private double total;@Overridepublic void visit(FixedCost fixedCost) {total += fixedCost.getAmount();}@Overridepublic void visit(VariableCost variableCost) {for (double amount : variableCost.getAmounts()) {total += amount;}}public double getTotal() {return total;}
}// 使用
List<ReportElement> elements = new ArrayList<>();
elements.add(new FixedCost(1000));
elements.add(new VariableCost(new double[]{200, 300, 400}));CostCalculator calculator = new CostCalculator();
for (ReportElement element : elements) {element.accept(calculator);
}System.out.println("Total cost: " + calculator.getTotal());

优势：将算法与对象结构分离，便于添加新操作而不修改元素类。

11. 解释器模式(Interpreter Pattern)

模式定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子4。

Android典型应用：

正则表达式处理
SQL解析
数学公式计算
领域特定语言(DSL)

实现示例：

// 抽象表达式
public interface Expression {boolean interpret(String context);
}// 终结符表达式
public class TerminalExpression implements Expression {private String data;public TerminalExpression(String data) {this.data = data;}@Overridepublic boolean interpret(String context) {return context.contains(data);}
}// 或表达式
public class OrExpression implements Expression {private Expression expr1;private Expression expr2;public OrExpression(Expression expr1, Expression expr2) {this.expr1 = expr1;this.expr2 = expr2;}@Overridepublic boolean interpret(String context) {return expr1.interpret(context) || expr2.interpret(context);}
}// 与表达式
public class AndExpression implements Expression {private Expression expr1;private Expression expr2;public AndExpression(Expression expr1, Expression expr2) {this.expr1 = expr1;this.expr2 = expr2;}@Overridepublic boolean interpret(String context) {return expr1.interpret(context) && expr2.interpret(context);}
}// 使用
Expression robert = new TerminalExpression("Robert");
Expression john = new TerminalExpression("John");
Expression or = new OrExpression(robert, john);Expression married = new TerminalExpression("Married");
Expression julie = new TerminalExpression("Julie");
Expression and = new AndExpression(julie, married);System.out.println("John is male? " + or.interpret("John"));
System.out.println("Julie is a married woman? " + and.interpret("Married Julie"));

适用场景：需要解释执行特定语言的场合，特别是简单语法的情况。