设计模式(五)～行为模式(1)

最新推荐文章于 2021-06-01 20:54:35 发布
最新推荐文章于 2021-06-01 20:54:35 发布
阅读量181 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcmain/article/details/103469225
版权

文章目录

行为模式简介

行为模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法独立完成的任务，涉及算法与对象间职责的分配。

行为模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度更低，满足"合成复用原则"，所以对象行为模式比类行为模式具有更大的灵活性。

行为模式是GoF中最为庞大的一类，它包含模版方法模式、策略模式、命令模式、职责链模式、状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式、解释器模式具体使用见下文。

模版方法模式(定义算法骨架和流程，子类实现可变部分)

定义

模版方法模式：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的前提下重定义该算法的某些特定的步骤。它是一种类行为模式。

特点

优点

  • 封装不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
  • 它在父类中提取了公共的代码部分，便于代码的复用。
  • 部分方法由子类实现，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

缺点

  • 对每个不同的实现都需要定义一个子类，会导致类的个数增加，系统更加庞大，设计也更加抽象。
  • 父类中的抽象方法由子类实现，子类执行的结果会影响到父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。
结构

模版方法模式主要包含以下主要角色

  • 抽象类（Abstract Class）：负责定义算法的轮廓和骨架。它由一个模版方法和若干个基本方法构成，这些方法定义如下：

    模版方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。

    • 基本方法：整个算法中的一个步骤，包含以下几种：
      • 抽象方法：在抽象类中声明，由具体子类实现。
      • 具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
      • 钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。

  • 具体子类（Concreate Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。
    结构如下：
    在这里插入图片描述

实现

例如：我们一家人一天中包含：起床、吃饭、做事情、看电视、睡觉几个流程，其中起床、吃饭、看电视、睡觉对每个人都是一样的，但做事情因人不同而不同(爸爸上班、妈妈收拾家务、孩子上学)，因此我们采用模版方法模式来实现

  1. 先定义一个抽象类，包含了一个模版方法，该方法包含了起床、吃饭、做事情、睡觉几个基本方法，其中有些方法的处理由于各人都一样，所以在该抽象类中实现就可以了。

    /**
 *定义抽象类-家庭日常(包含一个模版方法+若干个基本方法)
 */
public abstract class AbsFamilyDaily {

    /**
     * 模版方法（内部按照顺序调用基本方法）
     */
    final public void templateMethod() {
        getUp();
        eatBreakfast();
        doSomething();
        watchingTV();
        sleep();
    }

    //具体方法-起床
    protected void getUp() {
        System.out.println("07:00 起床 ");
    }
    //具体方法-吃饭
    protected void eatBreakfast() {
        System.out.println("08:00 开始吃早餐 ");
    }

    //抽象方法-做事情，每个人不一样由具体子类实现
    protected abstract void doSomething();
    
    //具体方法-看电视
    protected  void watchingTV(){
        System.out.println("20:00 看电视  ");
    }
 
    //具体方法-睡觉
    protected void sleep() {
        System.out.println("21:00 睡觉 ");
    }
}

  2. 做事情每个人是不同的因此必须在具体子类中实现

    /**
 *具体子类-爸爸，继承抽象类，实现做事方法
 */
public class Father extends AbsFamilyDaily {
    @Override
    public void doSomething() {
        System.out.println("09:00 爸爸去上班了...");
    }
}

    /**
 *具体子类-妈妈，继承抽象类，实现做事方法
 */
public class Mather extends AbsFamilyDaily {
    @Override
    public void doSomething() {
        System.out.println("09:30 妈妈开始做家务...");
    }
}

    /**
 *具体子类-孩子,继承抽象类，实现做事方法
 */
public class Children extends AbsFamilyDaily {
    @Override
    public void doSomething() {
        System.out.println("09:10 宝宝去上学了...");
    }
}

  3. 测试

    AbsFamilyDaily father = new Father();
father.templateMethod();
System.out.println("---------------");

AbsFamilyDaily mather = new Mather();
mather.templateMethod();
System.out.println("---------------");

AbsFamilyDaily children = new Children();
children.templateMethod();

//输出结果
07:00 起床 
08:00 开始吃早餐 
09:00 爸爸去上班了...
20:00 看电视  
21:00 睡觉 
---------------
07:00 起床 
08:00 开始吃早餐 
09:30 妈妈开始做家务...
20:00 看电视  
21:00 睡觉 
---------------
07:00 起床 
08:00 开始吃早餐 
09:10 宝宝去上学了...
20:00 看电视  
21:00 睡觉
应用场景

模版方法模式，适用于以下场景

  • 算法整体步骤很固定，但其中个别部分易变，这时候可以使用模版方法模式，将容易变动的部分抽象出来，供具体子类实现。
  • 多个子类存在公共行为时，可以将其提取出来并集中到一个公共父类中以避免代码重复。首先，要识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模版方法来替换这些不同的代码。
  • 当需要控制子类的扩展时，模版方法只在特定点调用钩子操作，这样就只允许在这些点进行扩展。
扩展

模版方法模式中，基本方法包含：抽象方法、具体方法、钩子方法，正确使用钩子方法可以使得子类控制父类的行为。如下例子中，可以通过具体子类中重写钩子方法hookMethod()来改变抽象父类中的运行结果，结构如下：
在这里插入图片描述
同样上面的案例，宝宝不想看电视，我们只需要在抽象类中增加一个抽象钩子方法即可，具体子类实现钩子方法来控制父类中的运行结果。

/**
 *抽象类-家庭日常（增加钩子方法）
 */
public abstract class AbsFamilyDaily {

    /**
     * 模版方法（内部按照顺序调用基本方法）
     */
    final public void templateMethod() {
        getUp();
        eatBreakfast();
        doSomething();
        if(hookMethod()){
            watchingTV(); 
        }
        sleep();
    }

    //具体方法-起床
    protected void getUp() {
        System.out.println("07:00 起床 ");
    }
    //具体方法-吃饭
    protected void eatBreakfast() {
        System.out.println("08:00 开始吃早餐 ");
    }

    //抽象方法-做事情，每个人不一样由具体子类实现
    protected abstract void doSomething();
    
    //具体方法-看电视
    protected  void watchingTV(){
        System.out.println("20:00 看电视  ");
    }
    
    //具体方法-睡觉
    protected void sleep() {
        System.out.println("21:00 睡觉 ");
    }
    
    //抽象方法-钩子，通过具体子类实现，改变父类执行逻辑
    protected abstract boolean hookMethod();
    
}

/**
 *具体子类-孩子实现抽象钩子方法
 */
public class Children extends AbsFamilyDaily {
    @Override
    public void doSomething() {
        System.out.println("09:10 宝宝去上学了...");
    }

    //宝宝实现具体的钩子方法-返回false不想看电视
    @Override
    protected boolean hookMethod() {
        return false;
    }
}
//同样爸爸妈妈如看电视其具体子类中也实现该钩子方法，返回true即可
//输出结果：
07:00 起床 
08:00 开始吃早餐 
09:00 爸爸去上班了...
20:00 看电视  
21:00 睡觉 
---------------
07:00 起床 
08:00 开始吃早餐 
09:30 妈妈开始做家务...
20:00 看电视  
21:00 睡觉 
---------------
07:00 起床 
08:00 开始吃早餐 
09:10 宝宝去上学了...
21:00 睡觉

策略模式(定义一系列算法族，每个封装起来，使其可以相互替换)

定义

策略模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化并不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

但我感觉在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象[DPE]。这本身并没有解除客户端需要选择判断的压力，而策略模式与简单工厂模式结合后，选择具体实现的职责也可以由Context来承担，这就最大化地减轻了客户端的职责。

特点

优点

  • 避免使用多重条件语句，多重条件语句不利于维护。
  • 提供一系列可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复代码。
  • 可提供相同行为不同实现，客户可依据不同时间或空间选择。
  • 完美支持开闭原则，可以在不修改源代码情况下，灵活增加新算法。
  • 把算法使用放到环境类中，而算法的实现放到具体策略类中，实现二者分离。

缺点

  • 客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。
  • 造成很多的策略类。
结构

策略模式是准备一组算法，并将这些算法封装到一系列具体策略类里面，作为一个抽象策略类的子类。策略模式的重心不是如何实现算法，而是如何组织这些算法，从而让程序结构更加灵活，具有更好维护性和扩展性，基本结构如下：

策略模式主要角色如下：

  • 抽象策略(Abstract Strategy)类：定义一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
  • 具体策略(Concrete Strategy)类：实现了抽象策略定义的接口，提供具体的算法实现。
  • 环境(Context)类：持有一个策略类引用，最终给客户端调用

结构如下：
在这里插入图片描述

实现

例如，我们通常在开发过程中，为了安全性我们通常采用加密算法对我们的敏感字段进行加密处理，这里加密的方式有很多中(RSA、3DES、AES)等等，因此我们通过使用加密算法来讲解策略模式使用

  1. 定义一个抽象策略类，声明公共接口加密

    public interface AbsEncrypt {
    //声明公共接口-加密
    void encrypt();
}

  2. 声明具体策略类实现抽象接口中的方法

    //具体策略类-AES加密
public class AESEncrypt implements AbsEncrypt {
    @Override
    public void encrypt() {
        System.out.println("您当前选择的AES对称加密算法");
    }
}

    //具体策略类-DESede加密
public class DESedeEncrypt implements AbsEncrypt{
    @Override
    public void encrypt() {
        System.out.println("您当前选择的3DES对称加密算法");
    }
}

    //具体策略类-RSA加密
public class RSAEncrypt implements AbsEncrypt {
    @Override
    public void encrypt() {
      System.out.println("您当前选择的RSA非对称加密算法");
    }
}

  3. 定义环境类（持有一个策略类的引用，供客户端调用）

    public class Context {
    //持有一个策略类的引用，供客户端调用
    AbsEncrypt encrypt;

    public AbsEncrypt getEncrypt() {return encrypt;}

    public void setEncrypt(AbsEncrypt encrypt) {this.encrypt = encrypt;}

    public void encrypt(){encrypt.encrypt();}
}

  4. 测试：客户端调用

    Context context = new Context();
AbsEncrypt aesEncrypt = new AESEncrypt();
context.setEncrypt(aesEncrypt);
context.encrypt();

AbsEncrypt desedeEncrypt = new DESedeEncrypt();
context.setEncrypt(desedeEncrypt);
context.encrypt();

AbsEncrypt rsaEncrypt = new RSAEncrypt();
context.setEncrypt(rsaEncrypt);
context.encrypt();
//输出结果
您当前选择的AES对称加密算法
您当前选择的3DES对称加密算法
您当前选择的RSA非对称加密算法
应用场景
  • 一个系统需要动态的在几种算法中选择一种时，可将每个算法封装到具体策略类中。
  • 一个类定义了多种行为，并且这些行为在这个类操作中以多个条件语句出现，可将每个条件分支移植到它们对应的具体策略类中以代替这些条件语句。
  • 系统中各算法彼此完全独立，且要求对客户隐藏具体到算法实现细节。
  • 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态的选择要执行的行为。
扩展
1. 策略工厂模式(策略模式+简单工厂模式)

在一个使用策略模式的系统中，当存在的策略很多时，客户端管理所有策略算法将变得很复杂，如果在环境类中使用策略工厂模式来管理这些策略类将大大减少客户端的工作复杂度，其结构图如下 所示。

在这里插入图片描述

代码案例：

还是如上案例，加密算法使用策略工厂模式实现。

//抽象策略类
public interface AbsEncrypt {
    //声明公共接口-加密
    void encrypt();
}

//具体策略类-AES加密
public class AESEncrypt implements AbsEncrypt {
    @Override
    public void encrypt() {
        System.out.println("您当前选择的AES对称加密算法");
    }
}
//具体策略类-RSA加密
public class RSAEncrypt implements AbsEncrypt {
    @Override
    public void encrypt() {
      System.out.println("您当前选择的RSA非对称加密算法");
    }
}
//具体策略类-DESede加密
public class DESedeEncrypt implements AbsEncrypt{
    @Override
    public void encrypt() {
        System.out.println("您当前选择的3DES对称加密算法");
    }
}

//策略工厂
public class StrategyFactory {

    HashMap<String,AbsEncrypt> map = new HashMap<>();
    public void put(String key,AbsEncrypt absEncrypt){
        map.put(key,absEncrypt);
    }
    protected AbsEncrypt get(String key){
       return map.get(key);
    }
    public void encrypt(String key){
        get(key).encrypt();
    }
}

测试：输出

//扩展，策略工厂模式
StrategyFactory strategyFactory = new StrategyFactory();
strategyFactory.put("RSA",new RSAEncrypt());
strategyFactory.put("AES",new AESEncrypt());
strategyFactory.put("DESede",new DESedeEncrypt());
strategyFactory.encrypt("AES");
//输出
您当前选择的AES对称加密算法

命令模式(将系统中的相关操作抽象成命令，使调用者与实现者相关分离)

定义

将一个请求封装位一个对象，使发出请求的责任和执行请求的责任分隔开。这样两者之间通过命令对象进行沟通，这样方便命令对象进行存储、传递、调用、增加和管理。

特点

优点

  • 降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦。
  • 增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，满足开闭原则,对扩展比较灵活。
  • 可实现宏命令。命令模式可以与组合命令结合，将多个命令装配成一个组合命令，即宏命令。
  • 方便实现Undo和Redo操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。

缺点

  • 增加系统的复杂度，可能产生大量具体命令类，因此针对每一个具体的操作都要设计一个具体命令类。
结构

命令模式包含以下主要角色

  • 抽象命令类(Abstract Command)角色：声明执行命令的接口，拥有执行命令的抽象方法execute()。

  • 具体命令类(Concrete Command)角色：是抽象命令类的具体实现类，拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。

  • 实现者/接收者(Receiver)角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。

  • 调用者/请求者(Invoker)角色：请求的发送者，通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访问接收者。

    结构如下：在这里插入图片描述

实现

案例：顾客去餐厅吃早餐，通过服务员点菜，服务员再通知厨师进行烹饪，整个过程中，顾客与厨师并未产生任何交流，通过点餐命令服务员角色进行传递，这里通过命令模式进行展示。这里：

  • 点餐—相当于命令(例如：点包子、粥、河粉等)
  • 服务员—相当于调用者
  • 厨师—相当于接收者(包子厨师、粥厨师、河粉厨师)
  1. 定义抽象命令（早餐）
/**
 *抽象命令类-声明执行命令的接口
 */
public abstract class AbsBreakfast {
    public abstract void cooking();
}
  1. 定义具体命令对象（包子、河粉、油条）
/**
 *具体命令对象-包子
 *抽象命令对象的具体实现者，包含接收者对象，通过调用接收者对象的功能来实现命令要执行的操作
 */
public class BaoZi extends AbsBreakfast {
    //接收者，具体命令对象业务真正实现者
    BaoziChef baoziChef;

    public BaoZi() {baoziChef = new BaoziChef();}

    @Override
    public void cooking() {baoziChef.cooking();}
}

/**
 *具体命令对象-河粉
 */
public class HeFen extends AbsBreakfast {
    //接收者，具体命令对象业务真正实现者
    HeFenChef heFenChef;

    public HeFen() {heFenChef = new HeFenChef();}

    @Override
    public void cooking() {heFenChef.cooking();}
}

/**
 *具体命令对象-油条
 */
public class YouTiao extends AbsBreakfast{
    //接收者，具体命令对象业务真正实现者
    YouTiaoChef youTiaoChef;

    public YouTiao(){ youTiaoChef = new YouTiaoChef();}

    @Override
    public void cooking() {youTiaoChef.cooking();}
}
  1. 定义接收者（厨师）
/**
 *接收者-包子厨师(具体命令对象业务的真正实现者)
 */
public class BaoziChef {
    public void cooking() {
        System.out.println("我是包子厨师，我正在做包子");
    }
}

/**
 *接收者-河粉厨师(具体命令对象业务的真正实现者)
 */
public class HeFenChef {
    public void cooking() {
        System.out.println("我是河粉厨师，我正在做河粉");
    }
}

/**
 *接收者-油条厨师(具体命令对象业务的真正实现者)
 */
public class YouTiaoChef {
    public void cooking() {
        System.out.println("我是油条厨师，我正在炸油条");
    }
}
  1. 定义调用者（服务员）
/**
 *调用者-服务员（请求的发送者，通常拥有多个命令对象，并通过访问命令对象的来执行相关操作，不直接访问接收者）
 */
public class Waiter {
    //拥有多个命令对象(抽象命令)
    AbsBreakfast breakfast;

    public void setBreakfast(AbsBreakfast breakfast){this.breakfast = breakfast;}
    //通过调用命令对象来执行相关操作，不直接访问接收者
    public void cooking(){breakfast.cooking();}
}

测试

//调用者-发送命令-接收者执行
Waiter waiter = new Waiter();
waiter.setBreakfast(new BaoZi());
waiter.cooking();
waiter.setBreakfast(new HeFen());
waiter.cooking();
//输出
我是包子厨师，我正在做包子
我是河粉厨师，我正在做河粉
使用场景
  • 系统需要将请求调用者与请求接收者 解耦时，命令模式使得调用者和接收者不直接交互。
  • 系统需要随机请求命令或经常增加或删除命令时，命令模式比较方便实现。
  • 系统需要执行一组操作时，命令模式可以定义宏命令来实现该功能。
  • 当系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作时，可以将命令对象存储起来，采用备忘录来实现。
扩展
1. 宏命令模式

命令模式+组合模式 = 宏命令模式,也叫组合命令模式。宏命令包含一组命令，它充当了具体命令与调用者的双重角色，执行它时将递归调用它所包含的所有命令。

  • 具体命令相当于树叶构件
  • 调用者相当于树枝构件

结构如下：
在这里插入图片描述
其他不变，主要是调用者（树枝构件提供管理树叶构件功能）

//抽象命令
interface AbstractCommand
{
    public abstract void execute();
}

//树叶构件: 具体命令1
class ConcreteCommand1 implements AbstractCommand
{
    private CompositeReceiver receiver;
    ConcreteCommand1()
    {
        receiver=new CompositeReceiver();
    }
    public void execute()
    {       
        receiver.action1();
    }
}

//树叶构件: 具体命令2
class ConcreteCommand2 implements AbstractCommand
{
    private CompositeReceiver receiver;
    ConcreteCommand2()
    {
        receiver=new CompositeReceiver();
    }
    public void execute()
    {       
        receiver.action2();
    }
}

//接收者
class CompositeReceiver
{
    public void action1()
    {
        System.out.println("接收者的action1()方法被调用...");
    }
    public void action2()
    {
        System.out.println("接收者的action2()方法被调用...");
    }
}

调用者-树枝构件

//树枝构件: 调用者-提供管理树叶构件的功能
class CompositeInvoker implements AbstractCommand
{
    private ArrayList<AbstractCommand> children = new ArrayList<AbstractCommand>();   
    public void add(AbstractCommand c)
    {
        children.add(c);
    }   
    public void remove(AbstractCommand c)
    {
        children.remove(c);
    }   
    public AbstractCommand getChild(int i)
    {
        return children.get(i);
    }   
    public void execute()
    {
        for(Object obj:children)
        {
            ((AbstractCommand)obj).execute();
        }
    }    
}

测试

AbstractCommand cmd1=new ConcreteCommand1();
AbstractCommand cmd2=new ConcreteCommand2();
CompositeInvoker ir=new CompositeInvoker();
ir.add(cmd1);
ir.add(cmd2);
System.out.println("客户访问调用者的execute()方法...");
ir.execute();

参考链接

LoadTown
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之行为模式 23种模式中的几种
01-04
设计模式之行为模式 中介者、备忘录、状态、策略
设计模式----行为型设计模式
m0_46853673的博客
02-24 970
行为型设计模式观察者模式观察者模式介绍代码实现观察者模式总结观察者模式在Java中的应用责任链模式责任链模式介绍责任链模式代码责任链模式总结责任链模式在Java中的应用模板模式模板模式的介绍代码实现模板模式总结模板模式在Java中的应用迭代器模式迭代器模式介绍迭代器模式总结迭代器模式在Java中的应用策略模式策略模式的介绍策略模式代码策略模式总结策略模式在Java中的应用 行为性设计模式关注各个类之间的相互作用，将职责划分清除，使得代码更加清晰。 行为性模式分为类行为模式和对象行为模式，类行为模式采用继承机
我的设计模式速查手册（三）
下一道彩虹
07-23 2519
行为模式速查手册
设计模式 -- 行为型模式
m00ndown
09-21 163
策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式 策略模式： 策略模式属于对象行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响客户端的情况下发生变化。 模板方法： 定义一个操作中的算法的骨架，而将步骤延迟到子类中
23种设计模式——行为型模式（上）
weixin_40422539的博客
10-28 257
责任链模式 顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。 在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。 实现 我们创建抽象类 AbstractL...
设计模式之11个行为型模式
02-24
行为型简介职责链模式(ChainofResponsibility)命令模式(Command)解释器模式(Interpreter)迭代器模式(Iterator)中介者模式(Mediator)备忘录模式(Memento)观察者模式(Observer)状态模式(State)策略模式(Strategy)模板...
设计模式-行为模式.pdf
最新发布
05-24
### 设计模式之行为模式详解 #### 一、行为模式概览 行为模式是一类设计模式，关注于算法和对象间职责的分配。这类模式不仅仅描述了对象或类的结构，更重要的是描述了它们之间的通信模式，即如何通过对象间的交互...
软件设计模式作业三行为式模式
12-23
南华大学的这个作业主要探讨了五种行为模式：职责链模式、组合命令模式、中介者模式、备忘录模式和观察者模式，同时也涉及到了UML类图和代码规范。 1. 职责链模式：这种模式允许将请求沿着处理者链进行传递，直到...
软件设计模式行为型模式实验代码
01-08
包含4个实验，组合命令模式（使用组合命令模式实现多功能开关,让用户进行设置,要么控制教室的所有灯的开和关，要么控制教室所有风扇的开和关），中介者模式（ATC代表空中交通管制。空管调解员不过是机场可用的空中...
设计模式之行为型模式代码.zip
12-29
行为型设计模式主要关注对象之间的交互和责任分配，使系统的行为更加灵活、可扩展。以下将详细阐述标题和描述中提到的九种行为型设计模式： 1. **策略模式**： 策略模式定义了一系列算法，并将每个算法封装起来，...
设计模式之行为模式（一）
legendaryhaha的博客
04-13 2961
命令模式 命令模式：将请求封住成对象，通过对象来实现对请求的控制（排队、顺序执行和取消） 模式无非就是让模块间能够解耦，让程序的复用性更强，命令模式也不例外，它是解决代表客户发送请求的调用者和提供服务的接受者之间的耦合关系的。 譬如：我们去一家餐厅吃放，我们点菜，服务员将菜单传递给厨师，这个流程中，我们相当于客户端client，点菜相当于发送请求，服务员相当于调用者invoke，根据请求调用相...
设计模式（三）之行为型模式
Watson的博客
11-23 2311
本篇是关于设计模式的最后一讲，会讲到第三种设计模式——行为型模式，共11种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 先来张图，看看这11种模式的关系： 第一类：通过父类与子类的关系进行实现。第二类：两个类之间。第三类：类的状态。第四类：通过中间类。 策略模式（strategy）策略模式定义了一系列算法，并
23种设计模式--行为型模式
qq_44954686的博客
06-01 770
23种设计模式-行为型模式 文章目录23种设计模式-行为型模式模板模式命令模式访问者模式迭代器模式观察者模式中介者模式备忘录模式解释器模式状态模式策略模式职责链模式 模板模式 基本介绍： 模板方法模式，又叫做模板模式，在一个抽象类中公开定义它的方法模板。它的子类可以按需重写方法实现。但调用将以抽象类中的定义的方式进行 简单来说，模板方法模式定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以定义该算法的某些特定步骤 属于行为模式 钩子方法： 在模板方法模式
设计模式（行为型模式-适配器模式）
weixin_30394669的博客
08-25 118
适配器模式在我们实际生活中随处可见，如充电器、电脑显示器DVI 与VGA转接头等，下面以电脑cpu和主板为例来理解适配器模式 1.未使用适配器模式情形（主板 + AMD） 示例： /** * 主板类（只支持AMD接口的CPU） **/ public class MainBoard { public void power(AMD amd) { ...
设计模式(23)-行为型模式-VISITOR模式
DavidWang9527的专栏
06-01 792
3.11.1功能 在面向对象系统的开发和设计过程，经常会遇到一种情况就是需求变更（ChangeRequest），经常我们做好的一个设计、实现了一个系统原型，咱们的客户又会有了新的需求。我们又因此不得不去修改已有的设计，最常见就是解决方案就是给已经设计、实现好的类添加新的方法去实现客户新的需求，这样就陷入了设计变更的梦魇：不停地打补丁，其带来的后果就是设计根本就不可能封闭、编译永远都是整个系统代码
行为型模式总结
sld880311的专栏
04-22 1957
封装变化封装变化是很多行为模式的主题。当一个程序的某个方面的特征经常发生改变时，这些模式就定义一个封装这个方面的对象。这样当该程序的其他部分依赖于这个方面时，它们都可以与此对象协作。这些模式通常定义一个抽象类来描述这些封装变化的对象，并且通常该模式依据这个对象（这个主题也贯穿于其他种类的模式。AbstractFactory，Builder和Property都封装了关于对象是如何创建的信息。Decor
strategy - 行为对象型模式
kingSolider的博客
12-22 186
           1.意图             定义一系列算法并且封装起来是它们可以相互替换。此模式可以使算法独立于使用的客户而变化             2.参与者             Strategy -定义算法的公共接口，Context调用具体算法             ConcreteStrategy - 实现具体的算法             Context - 用一个具...
设计模式-对象行为型模式
odiulzuotian的专栏
04-19 3867
【对象行为型模式】涉及到算法和对象间职责的分配，描述了对象和类的模式，以及它们之间的通信模式。 用来对类或对象怎样交互和怎样分配职责进行描述 1、  策略模式（strategy）          是指定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。        存在基类策略接口，多个策略继承于基类；上层根据需求执行业务逻辑处理，内部存在策略接口。 PS:        a：在解决...
行为型模式大全（Java讲解）
覃会程的博客
07-15 1225
文章目录责任链模式chain of responsibility 行为型模式关注系统中对象之间的相互交互,研究系统在运行时对象之间的相互通信和协作进一步明确对象的职责,共有11种模式： 责任链模式 chain of responsibility 命令模式 command 解释器模式 interpreter 迭代器模式 iterator 中介者模式 mediator 备忘录模式 memento 观察者模式 observer 状态模式 state 策略模式 strategy 模板方法模式 templa
设计模式解析：行为模式与模板方法
"本文主要介绍了行为模式在设计模式中的重要地位和作用，强调了它们用于在对象间分配职责和描述复杂控制流。行为类模式如模板方法通过继承来分派行为，而行为对象模式则利用对象复合来实现。设计模式是可复用面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值