1.概要
2.内容
以下是23种设计模式中的11种行为模式，结合坦克场景的应用举例：
1. 策略模式（Strategy）
- 场景：坦克移动策略选择。
- 应用：
- 定义算法族：定义直线移动、曲线机动、规避障碍三种移动策略。
- 上下文类：坦克根据战场环境（如开阔地、城市废墟）动态切换策略。
- 优点：新增策略无需修改坦克类，符合开闭原则。
- 代码示例：
interface MoveStrategy { void move(Tank tank); } class StraightMove implements MoveStrategy { public void move(Tank tank) { /* 直线移动逻辑 */ } } class Tank { private MoveStrategy strategy; public void setStrategy(MoveStrategy strategy) { this.strategy = strategy; } public void executeMove() { strategy.move(this); } }
2. 模板方法模式（Template Method）
- 场景：坦克攻击流程标准化。
- 应用：
- 抽象类：定义攻击流程（瞄准→装弹→射击）。
- 具体子类：实现不同攻击方式（如穿甲弹、高爆弹）。
- 钩子方法：允许子类决定是否启用自动瞄准。
- 代码示例：
abstract class TankAttack { public final void attack() { aim(); loadAmmo(); fire(); } protected abstract void aim(); protected void loadAmmo() { /* 默认装弹逻辑 */ } protected abstract void fire(); } class APShellAttack extends TankAttack { protected void aim() { /* 穿甲弹专用瞄准 */ } protected void fire() { /* 穿甲弹发射逻辑 */ } }
3. 观察者模式（Observer）
- 场景：坦克状态实时监控。
- 应用：
- 主题（Subject）：坦克作为被观察对象，维护观察者列表。
- 观察者（Observer）：战场监控界面、指挥官终端等订阅坦克状态（血量、燃料、弹药）。
- 通知机制：坦克状态变化时自动推送更新。
- 代码示例：
class Tank extends Observable { private int health; public void setHealth(int health) { this.health = health; setChanged(); notifyObservers(health); } } class CommanderTerminal implements Observer { public void update(Observable o, Object arg) { int health = (int) arg; System.out.println("当前坦克血量: " + health); } }
4. 迭代器模式（Iterator）
- 场景：遍历坦克部件进行维护。
- 应用：
- 聚合类：坦克包含多个部件（装甲、炮塔、发动机）。
- 迭代器：提供统一接口遍历部件，隐藏内部结构。
- 代码示例：
interface TankComponentIterator { boolean hasNext(); Component next(); } class Tank { private List<Component> components; public TankComponentIterator createIterator() { return new TankComponentIteratorImpl(components); } } class TankComponentIteratorImpl implements TankComponentIterator { private List<Component> components; private int currentIndex = 0; public boolean hasNext() { return currentIndex < components.size(); } public Component next() { return components.get(currentIndex++); } }
5. 责任链模式（Chain of Responsibility）
- 场景：坦克命令处理优先级。
- 应用：
- 处理者链：移动指令→攻击指令→防御指令，按优先级传递。
- 动态调整：战场态势变化时可插入新处理节点（如紧急维修指令）。
- 代码示例：
abstract class CommandHandler { private CommandHandler next; public void setNext(CommandHandler next) { this.next = next; } public final void handle(Command cmd) { if (canHandle(cmd)) { execute(cmd); } else if (next != null) { next.handle(cmd); } } protected abstract boolean canHandle(Command cmd); protected abstract void execute(Command cmd); } class MoveCommandHandler extends CommandHandler { protected boolean canHandle(Command cmd) { return cmd instanceof MoveCommand; } protected void execute(Command cmd) { /* 执行移动指令 */ } }
6. 命令模式（Command）
- 场景：坦克行为指令封装。
- 应用：
- 具体命令：前进、开火、停止等指令封装为对象。
- 调用者：玩家或AI通过按钮触发命令。
- 接收者：坦克执行具体动作。
- 代码示例：
interface Command { void execute(); } class FireCommand implements Command { private Tank tank; public FireCommand(Tank tank) { this.tank = tank; } public void execute() { tank.fire(); } } class Player { private List<Command> commands; public void trigger(Command cmd) { commands.add(cmd); } public void executeAll() { for (Command cmd : commands) { cmd.execute(); } commands.clear(); } }
7. 备忘录模式（Memento）
- 场景：坦克状态回溯（如撤销移动）。
- 应用：
- 发起人：坦克保存自身状态（位置、方向、血量）。
- 备忘录：存储状态快照。
- 管理者：记录操作历史，支持回滚。
- 代码示例：
class TankMemento { private int x, y; private Direction dir; private int health; // 构造方法、getter/setter省略 } class Tank { public TankMemento saveState() { return new TankMemento(x, y, dir, health); } public void restoreState(TankMemento memento) { this.x = memento.getX(); this.y = memento.getY(); this.dir = memento.getDir(); this.health = memento.getHealth(); } } class HistoryManager { private Stack<TankMemento> history = new Stack<>(); public void save(Tank tank) { history.push(tank.saveState()); } public void undo(Tank tank) { if (!history.isEmpty()) { TankMemento memento = history.pop(); tank.restoreState(memento); } } }
8. 状态模式（State）
- 场景：坦克行为状态切换。
- 应用：
- 状态类：待机、移动、战斗中。
- 上下文类：坦克根据状态执行不同行为（如战斗中禁止移动指令）。
- 代码示例：
interface TankState { void handleMove(Tank tank); void handleFire(Tank tank); } class IdleState implements TankState { public void handleMove(Tank tank) { tank.setState(new MovingState()); } public void handleFire(Tank tank) { /* 待机时无法开火 */ } } class MovingState implements TankState { public void handleMove(Tank tank) { /* 移动中调整路径 */ } public void handleFire(Tank tank) { /* 移动中开火精度下降 */ } } class Tank { private TankState state; public void setState(TankState state) { this.state = state; } public void move() { state.handleMove(this); } public void fire() { state.handleFire(this); } }
9. 访问者模式（Visitor）
- 场景：坦克属性统计（如攻击力、防御力）。
- 应用：
- 访问者：统计模块访问坦克及其部件。
- 元素：坦克、炮塔、装甲等接受访问。
- 代码示例：
interface TankElement { void accept(TankVisitor visitor); } interface TankVisitor { void visitTank(Tank tank); void visitTurret(Turret turret); void visitArmor(Armor armor); } class AttributeCalculator implements TankVisitor { private int totalAttack = 0; private int totalDefense = 0; public void visitTank(Tank tank) { /* 汇总部件属性 */ } public void visitTurret(Turret turret) { totalAttack += turret.getAttack(); } public void visitArmor(Armor armor) { totalDefense += armor.getDefense(); } public int getTotalAttack() { return totalAttack; } public int getTotalDefense() { return totalDefense; } }
10. 中介者模式（Mediator）
- 场景：坦克编队协同作战。
- 应用：
- 中介者：编队控制中心协调多辆坦克。
- 同事类：坦克通过中介者通信（如请求火力支援）。
- 代码示例：
class TankTeamMediator { private List<Tank> tanks = new ArrayList<>(); public void addTank(Tank tank) { tanks.add(tank); } public void requestSupport(Tank requester, Coordinates target) { for (Tank tank : tanks) { if (tank != requester && tank.canSupport(target)) { tank.moveTo(target); tank.fireAt(target); } } } } class Tank { private TankTeamMediator mediator; public void setMediator(TankTeamMediator mediator) { this.mediator = mediator; } public void requestFireSupport(Coordinates target) { mediator.requestSupport(this, target); } }
11. 解释器模式（Interpreter）
- 场景：坦克指令解析（如玩家输入的文本命令）。
- 应用：
- 文法规则：定义指令格式（如“move x y”表示移动到坐标(x,y)）。
- 解释器：解析指令并生成可执行命令。
- 代码示例：
interface CommandExpression { Command interpret(); } class MoveCommandExpression implements CommandExpression { private int x, y; public MoveCommandExpression(int x, int y) { this.x = x; this.y = y; } public Command interpret() { return new MoveCommand(x, y); } } class CommandParser { public Command parse(String input) { // 解析输入字符串，生成CommandExpression return expression.interpret(); } }
总结
行为模式通过封装变化、解耦对象、定义协作规则，使坦克系统具备高扩展性和灵活性。例如：
- 策略模式允许坦克动态切换移动算法，适应不同地形。
- 观察者模式实现状态实时监控，便于战场决策。
- 责任链模式确保指令按顺序处理，避免冲突。
- 状态模式使坦克行为随战场态势自动调整。
3.关联链接
4.关联知识
1.中介者模式、外观模式、代理模式的共性和个性
中介者模式、外观模式和代理模式的共性与区别
一、共性分析
- 结构型模式：三者均属于结构型设计模式，核心目标是优化对象间的交互关系，降低系统耦合度。
- 间接访问：通过引入中间层（中介者、外观、代理）隔离客户端与后端组件，避免直接依赖。
- 简化复杂性：均用于简化系统交互逻辑，提升代码可维护性和扩展性。
二、核心区别
| 维度 | 中介者模式 | 外观模式 | 代理模式 |
|---|---|---|---|
| 核心目标 | 管理多对象间的动态交互 | 为复杂子系统提供统一入口 | 控制对目标对象的访问 |
| 通信方向 | 双向（对象间可通过中介互访） | 单向（客户端→子系统） | 单向（客户端→代理→目标） |
| 职责分布 | 中介者协调交互逻辑 | 外观仅委托请求，不处理业务 | 代理可附加额外功能（如缓存） |
| 典型场景 | GUI组件通信、智能家居中枢 | 游戏引擎、支付系统集成 | 懒加载、权限控制、远程代理 |
| 结构角色 | 中介者、同事类 | 外观类、子系统类 | 代理类、真实主题类 |
三、深度对比与类比
- 中介者模式
- 类比：智能家居中枢。所有设备（如灯光、空调）通过中枢通信，避免直接依赖。
- 特点：
- 对象间解耦，交互由中介者协调。
- 支持多对多关系，但中介者可能成为性能瓶颈。
- 场景：聊天室消息转发、机场航班调度系统。
- 外观模式
- 类比：酒店前台。客户通过前台统一请求服务（如订房、餐饮），无需了解后台部门协作。
- 特点：
- 隐藏子系统细节，提供高层接口。
- 不处理业务逻辑，仅委托请求。
- 场景：第三方支付集成、微服务网关。
- 代理模式
- 类比：房产中介。代理控制房东与租客的沟通，可附加合同审核等步骤。
- 特点：
- 控制访问权限或时机（如懒加载）。
- 代理与真实对象接口一致。
- 场景：图片懒加载、远程方法调用（RPC）。
四、优缺点总结
| 模式 | 优点 | 缺点 |
|---|---|---|
| 中介者模式 | 解耦对象、集中管理交互 | 中介者可能过度复杂 |
| 外观模式 | 简化接口、降低耦合 | 可能引入额外层次 |
| 代理模式 | 增强控制、延迟加载 | 代理层增加调用开销 |
五、总结
- 共性：三者均通过中间层优化交互，但职责不同。
- 区别：
- 中介者：协调多对象交互，适合复杂网状关系。
- 外观：统一子系统接口，适合简化复杂系统。
- 代理：控制访问，适合增强功能或延迟加载。
通过合理选择模式，可显著提升系统灵活性和可维护性。
2.策略模式、职责链模式、状态模式有什么共性和个性
策略模式、职责链模式、状态模式的共性与个性
一、共性分析
- 行为型模式：三者均属于行为型设计模式，核心目标是优化对象间的行为协作，提升系统灵活性。
- 职责分离：通过抽象和封装，将不同职责或行为分配到独立单元中，避免单一类职责过重。
- 扩展性提升：支持通过新增策略、处理者或状态类来扩展系统功能，符合开闭原则。
二、核心区别
| 维度 | 策略模式 | 职责链模式 | 状态模式 |
|---|---|---|---|
| 核心目标 | 算法可替换性：客户端动态选择算法。 | 请求处理解耦：请求沿链自动传递。 | 状态驱动行为：行为随状态变化。 |
| 交互机制 | 客户端主动选择策略。 | 请求依次传递，处理者决定是否处理。 | 状态自动切换，触发行为变化。 |
| 职责分布 | 算法独立，客户端决策。 | 处理者依次尝试处理请求。 | 状态类封装行为，上下文切换状态。 |
| 典型场景 | 支付计算、排序算法选择。 | 审批流程、事件处理。 | 订单状态管理、游戏角色状态。 |
| 结构角色 | 抽象策略、具体策略、上下文。 | 抽象处理者、具体处理者、客户端。 | 抽象状态、具体状态、上下文。 |
三、深度对比与类比
- 策略模式
- 类比：电商平台支付方式（支付宝、微信支付）。用户根据需求选择不同支付策略。
- 特点：
- 算法独立于客户端，支持运行时替换。
- 客户端需了解所有策略，并主动选择。
- 场景：游戏角色移动算法（步行、奔跑）、排序算法选择。
- 职责链模式
- 类比：请假审批流程。申请单依次经过组长→经理→HR审批。
- 特点：
- 请求沿链自动传递，处理者决定是否处理。
- 解耦请求发送者与接收者，动态扩展处理链。
- 场景：日志处理（过滤敏感信息→存储数据库）、事件冒泡机制。
- 状态模式
- 类比：交通信号灯。不同状态（红、黄、绿）对应不同行为（停、减速、行）。
- 特点：
- 行为随状态变化，状态封装为独立类。
- 状态自动切换，上下文控制状态流转。
- 场景：订单状态管理（未付款→已发货）、游戏角色状态切换。
四、优缺点总结
| 模式 | 优点 | 缺点 |
|---|---|---|
| 策略模式 | 算法灵活替换、扩展性强 | 客户端需了解所有策略 |
| 职责链模式 | 解耦请求与处理、动态扩展 | 链过长可能导致性能问题 |
| 状态模式 | 状态转换清晰、符合开闭原则 | 状态类增多可能增加系统复杂度 |
五、总结
- 共性：三者均通过行为抽象和职责分离提升系统灵活性。
- 个性：
- 策略模式：强调算法可替换性，适用于需要动态选择算法的场景。
- 职责链模式：强调请求处理解耦，适用于多对象协作处理请求的场景。
- 状态模式：强调状态驱动行为，适用于对象行为随状态变化的场景。
通过合理选择模式，可以显著提升系统的可扩展性和可维护性。
3.职责链和状态模式接口流转对比
概述：职责链模式和状态模式都会发生一个接口的调用，在不同的对象流转，而又有不同，职责链的流转是线性的，而状态的模式对相同接口调用形成的调用关系视乎比职责链更复杂
职责链模式与状态模式接口调用流转的深入分析
一、核心机制对比
| 维度 | 职责链模式 | 状态模式 |
|---|---|---|
| 流转结构 | 线性链式：请求依次传递，处理者决定传递或终止。 | 状态驱动：流转由状态切换触发，可能形成复杂调用网络。 |
| 控制主体 | 客户端动态组装链，运行时调整顺序。 | 状态类自行定义下一状态，编译时确定逻辑。 |
| 职责分布 | 处理者兼具处理请求和传递请求双重职责。 | 状态类仅负责当前状态的行为，流转由上下文控制。 |
| 扩展性 | 通过新增处理者或调整链顺序扩展。 | 通过新增状态类或修改状态转换逻辑扩展。 |
二、流转过程图解
- 职责链模式
- 线性传递：请求从链头开始，依次经过每个处理者，直到被处理或到达链尾。
- 示例：请假审批流程（组长→经理→HR）。
graph TD A[客户端] --> B[处理者1:组长] B --> C[处理者2:经理] C --> D[处理者3:HR] D --> E[请求终止]
- 状态模式
- 状态驱动：对象状态变化触发行为切换，可能形成循环或分支调用。
- 示例：订单状态流转（未付款→已发货→已签收）。
stateDiagram [*] --> 未付款 未付款 --> 已付款: 支付成功 已付款 --> 已发货: 仓库处理 已发货 --> 已签收: 用户确认 已签收 --> [*]
三、关键差异分析
- 流转确定性
- 职责链：流转路径由客户端显式定义（如
h1.setSuccessor(h2)），路径固定但可动态调整。 - 状态模式：流转由状态类隐式定义（如
context.TransitionTo(newState)），路径依赖状态转换逻辑。
- 职责链：流转路径由客户端显式定义（如
- 调用复杂度
- 职责链：接口调用呈线性增长（
O(n)），链越长性能影响越显著。 - 状态模式：接口调用可能因状态循环或分支呈非线性增长（如
O(2^n)），需谨慎设计状态转换。
- 职责链：接口调用呈线性增长（
- 调试难度
- 职责链：可通过日志或断点追踪链式调用，但长链易导致调试困难。
- 状态模式：状态转换逻辑分散在多个状态类中，需结合上下文和状态图分析。
四、场景适配性
| 模式 | 适用场景 | 不适用场景 |
|---|---|---|
| 职责链模式 | 多级审批、事件处理管道 | 状态依赖行为（如订单状态） |
| 状态模式 | 对象行为随状态变化的场景 | 简单线性处理流程 |
五、设计建议
- 职责链模式
- 控制链长度：避免超长链导致性能问题。
- 提供默认处理：为未处理请求定义兜底逻辑。
- 状态模式
- 明确状态边界：避免状态类职责重叠。
- 简化转换逻辑：使用状态表或工具类管理复杂转换。
六、总结
- 线性性 vs 动态性：职责链的线性流转适合明确处理顺序的场景，状态模式的动态流转适合行为依赖状态的场景。
- 控制反转：职责链将控制交给客户端，状态模式将控制分散到状态类中。
- 选择依据：优先用职责链处理流程性任务，用状态模式处理状态驱动型任务。
4.行为模式的对比
概述：对行为型模式，感觉策略是基础，其他的模式都是在这个基础上的展开，尤其是职责链和状态感觉就是对策略的加强，并且这三种模式的本质就是对多态的运用。而模版模式和他们三个相比是多接口的多态。观察和与其相比是双向多态，即观察车本身因为本观察者的不同有一层多态，而被观察者因观察的对象不同又有不同的变化，我把这个叫做双向的多态；而其他的模式，观察者模式，迭代器模式，命令模式，备忘录模式，中介者模式，解释器模式 更像是独具特点的一些模式，甚至有点像一种更具体的通用需求。
对行为型模式的深度解析：策略模式的基础性与多态的多元运用
一、策略模式的核心地位
策略模式（Strategy Pattern）在行为型模式中具有基础性作用，其核心理念在于算法封装与动态替换。它通过定义一系列可互换的算法族，将行为抽象为独立对象，使得客户端能够在运行时灵活选择或切换算法。这种设计遵循开闭原则，新增算法时无需修改现有代码，只需扩展新的策略类。
关键特性：
- 算法封装：每个策略类封装一个具体算法，独立于客户端。
- 动态替换：客户端通过组合或聚合关联策略对象，实现行为切换。
- 开闭原则：新增策略类不影响现有代码，系统扩展性强。
二、职责链模式与状态模式：策略模式的扩展
- 职责链模式（Chain of Responsibility）
- 核心思想：将请求沿处理链传递，直到被处理。每个处理者（Handler）决定是否处理请求或传递给下一个节点。
- 对策略模式的扩展：
- 线性协作：多个策略类通过链式协作完成复杂任务，客户端无需关心具体处理者。
- 动态解耦：请求发送者与接收者解耦，链结构可动态调整。
- 典型场景：多级审批流程、事件处理管道。
- 状态模式（State Pattern）
- 核心思想：对象行为随内部状态变化而变化，状态封装为独立类。
- 对策略模式的扩展：
- 状态驱动：行为切换由状态转换触发，而非客户端主动选择。
- 行为局部化：每个状态类封装特定行为，符合单一职责原则。
- 典型场景：订单状态流转、游戏角色状态切换。
三、多态的多元运用
- 策略模式的多态
- 对象间行为分配：通过组合或聚合关联策略对象，实现算法的动态替换。
- 示例：支付计算中，客户端根据需求选择支付宝或微信支付策略。
- 职责链模式的多态
- 链式协作多态：请求沿链传递，每个处理者根据类型决定行为。
- 示例：日志处理中，请求依次经过敏感信息过滤、存储等处理者。
- 状态模式的多态
- 状态驱动多态：对象行为由当前状态决定，状态转换触发行为切换。
- 示例：交通信号灯状态切换（红→绿→黄）对应不同行为。
- 模板方法模式的多接口多态
- 算法框架定义：父类定义算法框架，子类实现具体步骤。
- 示例：报表生成中，父类定义生成流程，子类实现数据获取和格式化。
- 观察者模式的双向多态
- 观察者与被观察者的双向依赖：
- 观察者多态：不同观察者响应同一事件的方式不同。
- 被观察者多态：被观察者状态变化触发不同观察者的更新。
- 示例：股票价格变动时，不同投资者（观察者）执行不同操作。
- 观察者与被观察者的双向依赖：
四、其他行为型模式的特点与分类
| 模式 | 核心思想 | 特点 | 典型场景 |
|---|---|---|---|
| 迭代器模式 | 遍历集合不暴露底层结构 | 提供统一遍历接口，简化集合访问 | 遍历数组、列表、树等集合 |
| 命令模式 | 将请求封装为对象 | 支持撤销/重做，解耦请求与接收者 | 撤销操作、宏命令 |
| 备忘录模式 | 捕获和恢复对象内部状态 | 实现撤销/重做，保护对象封装性 | 文本编辑器撤销操作 |
| 中介者模式 | 封装对象间交互 | 解耦多对象交互，集中控制通信 | 聊天室消息转发 |
| 解释器模式 | 定义语言文法并建立解释器 | 支持语法扩展，简化复杂规则实现 | 编译器、规则引擎 |
五、总结：行为型模式的共性与个性
- 共性：
- 行为抽象：均关注对象间的行为协作。
- 多态运用：通过继承、组合或接口实现行为分配。
- 扩展性：支持系统灵活扩展，符合开闭原则。
- 个性：
- 策略模式：算法封装与动态替换。
- 职责链模式：请求链式传递与动态解耦。
- 状态模式：状态驱动的行为切换。
- 观察者模式：双向依赖与事件通知。
- 其他模式：针对特定场景（如遍历、撤销、通信）提供解决方案。
通过理解这些模式的共性与个性，可以更精准地选择合适的设计模式，构建灵活、可维护的系统架构。
扫一扫
4385
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
